2019-11-22 18:33:31 -05:00
|
|
|
// Copyright 2019 The Gitea Authors. All rights reserved.
|
2022-11-27 13:20:29 -05:00
|
|
|
// SPDX-License-Identifier: MIT
|
2019-11-22 18:33:31 -05:00
|
|
|
|
2021-06-09 12:53:16 -05:00
|
|
|
package auth
|
2019-11-22 18:33:31 -05:00
|
|
|
|
|
|
|
import (
|
2023-09-14 12:09:32 -05:00
|
|
|
"context"
|
2019-11-22 18:33:31 -05:00
|
|
|
"errors"
|
2021-01-05 08:05:40 -05:00
|
|
|
"net/http"
|
2019-11-22 18:33:31 -05:00
|
|
|
"strings"
|
2023-06-18 02:59:09 -05:00
|
|
|
"sync"
|
2019-11-22 18:33:31 -05:00
|
|
|
|
2022-01-02 08:12:35 -05:00
|
|
|
"code.gitea.io/gitea/models/auth"
|
Avatar refactor, move avatar code from `models` to `models.avatars`, remove duplicated code (#17123)
Why this refactor
The goal is to move most files from `models` package to `models.xxx` package. Many models depend on avatar model, so just move this first.
And the existing logic is not clear, there are too many function like `AvatarLink`, `RelAvatarLink`, `SizedRelAvatarLink`, `SizedAvatarLink`, `MakeFinalAvatarURL`, `HashedAvatarLink`, etc. This refactor make everything clear:
* user.AvatarLink()
* user.AvatarLinkWithSize(size)
* avatars.GenerateEmailAvatarFastLink(email, size)
* avatars.GenerateEmailAvatarFinalLink(email, size)
And many duplicated code are deleted in route handler, the handler and the model share the same avatar logic now.
2021-10-05 18:25:46 -05:00
|
|
|
"code.gitea.io/gitea/models/avatars"
|
2023-11-23 22:49:41 -05:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2021-11-24 04:49:20 -05:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2019-11-22 18:33:31 -05:00
|
|
|
"code.gitea.io/gitea/modules/base"
|
2023-04-13 14:45:33 -05:00
|
|
|
gitea_context "code.gitea.io/gitea/modules/context"
|
2019-11-22 18:33:31 -05:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2022-04-29 14:38:11 -05:00
|
|
|
"code.gitea.io/gitea/modules/util"
|
2021-01-30 03:55:53 -05:00
|
|
|
"code.gitea.io/gitea/modules/web/middleware"
|
2021-07-24 05:16:34 -05:00
|
|
|
"code.gitea.io/gitea/services/auth/source/sspi"
|
2019-11-22 18:33:31 -05:00
|
|
|
|
2020-06-18 04:18:44 -05:00
|
|
|
gouuid "github.com/google/uuid"
|
2019-11-22 18:33:31 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
tplSignIn base.TplName = "user/auth/signin"
|
|
|
|
)
|
|
|
|
|
2023-09-17 18:32:56 -05:00
|
|
|
type SSPIAuth interface {
|
|
|
|
AppendAuthenticateHeader(w http.ResponseWriter, data string)
|
|
|
|
Authenticate(r *http.Request, w http.ResponseWriter) (userInfo *SSPIUserInfo, outToken string, err error)
|
|
|
|
}
|
|
|
|
|
2019-11-22 18:33:31 -05:00
|
|
|
var (
|
2023-09-17 18:32:56 -05:00
|
|
|
sspiAuth SSPIAuth // a global instance of the websspi authenticator to avoid acquiring the server credential handle on every request
|
|
|
|
sspiAuthOnce sync.Once
|
|
|
|
sspiAuthErrInit error
|
2019-11-22 18:33:31 -05:00
|
|
|
|
|
|
|
// Ensure the struct implements the interface.
|
2023-06-18 02:59:09 -05:00
|
|
|
_ Method = &SSPI{}
|
2019-11-22 18:33:31 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
// SSPI implements the SingleSignOn interface and authenticates requests
|
|
|
|
// via the built-in SSPI module in Windows for SPNEGO authentication.
|
2023-09-17 18:32:56 -05:00
|
|
|
// The SSPI plugin is expected to be executed last, as it returns 401 status code if negotiation
|
|
|
|
// fails (or if negotiation should continue), which would prevent other authentication methods
|
|
|
|
// to execute at all.
|
2023-04-13 14:45:33 -05:00
|
|
|
type SSPI struct{}
|
2019-11-22 18:33:31 -05:00
|
|
|
|
2021-06-09 12:53:16 -05:00
|
|
|
// Name represents the name of auth method
|
|
|
|
func (s *SSPI) Name() string {
|
|
|
|
return "sspi"
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verify uses SSPI (Windows implementation of SPNEGO) to authenticate the request.
|
2021-07-08 06:38:13 -05:00
|
|
|
// If authentication is successful, returns the corresponding user object.
|
2019-11-22 18:33:31 -05:00
|
|
|
// If negotiation should continue or authentication fails, immediately returns a 401 HTTP
|
|
|
|
// response code, as required by the SPNEGO protocol.
|
refactor auth interface to return error when verify failure (#22119)
This PR changed the Auth interface signature from
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) *user_model.User`
to
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) (*user_model.User, error)`.
There is a new return argument `error` which means the verification
condition matched but verify process failed, we should stop the auth
process.
Before this PR, when return a `nil` user, we don't know the reason why
it returned `nil`. If the match condition is not satisfied or it
verified failure? For these two different results, we should have
different handler. If the match condition is not satisfied, we should
try next auth method and if there is no more auth method, it's an
anonymous user. If the condition matched but verify failed, the auth
process should be stop and return immediately.
This will fix #20563
Co-authored-by: KN4CK3R <admin@oldschoolhack.me>
Co-authored-by: Jason Song <i@wolfogre.com>
2022-12-28 00:53:28 -05:00
|
|
|
func (s *SSPI) Verify(req *http.Request, w http.ResponseWriter, store DataStore, sess SessionStore) (*user_model.User, error) {
|
2023-09-17 18:32:56 -05:00
|
|
|
sspiAuthOnce.Do(func() { sspiAuthErrInit = sspiAuthInit() })
|
|
|
|
if sspiAuthErrInit != nil {
|
|
|
|
return nil, sspiAuthErrInit
|
2023-06-18 02:59:09 -05:00
|
|
|
}
|
2021-01-05 20:38:00 -05:00
|
|
|
if !s.shouldAuthenticate(req) {
|
refactor auth interface to return error when verify failure (#22119)
This PR changed the Auth interface signature from
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) *user_model.User`
to
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) (*user_model.User, error)`.
There is a new return argument `error` which means the verification
condition matched but verify process failed, we should stop the auth
process.
Before this PR, when return a `nil` user, we don't know the reason why
it returned `nil`. If the match condition is not satisfied or it
verified failure? For these two different results, we should have
different handler. If the match condition is not satisfied, we should
try next auth method and if there is no more auth method, it's an
anonymous user. If the condition matched but verify failed, the auth
process should be stop and return immediately.
This will fix #20563
Co-authored-by: KN4CK3R <admin@oldschoolhack.me>
Co-authored-by: Jason Song <i@wolfogre.com>
2022-12-28 00:53:28 -05:00
|
|
|
return nil, nil
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
|
2023-10-10 23:24:07 -05:00
|
|
|
cfg, err := s.getConfig(req.Context())
|
2019-11-22 18:33:31 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Error("could not get SSPI config: %v", err)
|
refactor auth interface to return error when verify failure (#22119)
This PR changed the Auth interface signature from
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) *user_model.User`
to
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) (*user_model.User, error)`.
There is a new return argument `error` which means the verification
condition matched but verify process failed, we should stop the auth
process.
Before this PR, when return a `nil` user, we don't know the reason why
it returned `nil`. If the match condition is not satisfied or it
verified failure? For these two different results, we should have
different handler. If the match condition is not satisfied, we should
try next auth method and if there is no more auth method, it's an
anonymous user. If the condition matched but verify failed, the auth
process should be stop and return immediately.
This will fix #20563
Co-authored-by: KN4CK3R <admin@oldschoolhack.me>
Co-authored-by: Jason Song <i@wolfogre.com>
2022-12-28 00:53:28 -05:00
|
|
|
return nil, err
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
|
2021-05-09 11:04:53 -05:00
|
|
|
log.Trace("SSPI Authorization: Attempting to authenticate")
|
2021-01-05 20:38:00 -05:00
|
|
|
userInfo, outToken, err := sspiAuth.Authenticate(req, w)
|
2019-11-22 18:33:31 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Warn("Authentication failed with error: %v\n", err)
|
2021-01-05 20:38:00 -05:00
|
|
|
sspiAuth.AppendAuthenticateHeader(w, outToken)
|
2019-11-22 18:33:31 -05:00
|
|
|
|
|
|
|
// Include the user login page in the 401 response to allow the user
|
|
|
|
// to login with another authentication method if SSPI authentication
|
|
|
|
// fails
|
2021-01-05 20:38:00 -05:00
|
|
|
store.GetData()["Flash"] = map[string]string{
|
2021-01-14 10:35:10 -05:00
|
|
|
"ErrorMsg": err.Error(),
|
2021-01-05 20:38:00 -05:00
|
|
|
}
|
|
|
|
store.GetData()["EnableOpenIDSignIn"] = setting.Service.EnableOpenIDSignIn
|
|
|
|
store.GetData()["EnableSSPI"] = true
|
2023-07-18 12:32:49 -05:00
|
|
|
// in this case, the Verify function is called in Gitea's web context
|
2023-04-13 14:45:33 -05:00
|
|
|
// FIXME: it doesn't look good to render the page here, why not redirect?
|
2023-07-18 12:32:49 -05:00
|
|
|
gitea_context.GetWebContext(req).HTML(http.StatusUnauthorized, tplSignIn)
|
refactor auth interface to return error when verify failure (#22119)
This PR changed the Auth interface signature from
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) *user_model.User`
to
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) (*user_model.User, error)`.
There is a new return argument `error` which means the verification
condition matched but verify process failed, we should stop the auth
process.
Before this PR, when return a `nil` user, we don't know the reason why
it returned `nil`. If the match condition is not satisfied or it
verified failure? For these two different results, we should have
different handler. If the match condition is not satisfied, we should
try next auth method and if there is no more auth method, it's an
anonymous user. If the condition matched but verify failed, the auth
process should be stop and return immediately.
This will fix #20563
Co-authored-by: KN4CK3R <admin@oldschoolhack.me>
Co-authored-by: Jason Song <i@wolfogre.com>
2022-12-28 00:53:28 -05:00
|
|
|
return nil, err
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
if outToken != "" {
|
2021-01-05 20:38:00 -05:00
|
|
|
sspiAuth.AppendAuthenticateHeader(w, outToken)
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
username := sanitizeUsername(userInfo.Username, cfg)
|
|
|
|
if len(username) == 0 {
|
refactor auth interface to return error when verify failure (#22119)
This PR changed the Auth interface signature from
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) *user_model.User`
to
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) (*user_model.User, error)`.
There is a new return argument `error` which means the verification
condition matched but verify process failed, we should stop the auth
process.
Before this PR, when return a `nil` user, we don't know the reason why
it returned `nil`. If the match condition is not satisfied or it
verified failure? For these two different results, we should have
different handler. If the match condition is not satisfied, we should
try next auth method and if there is no more auth method, it's an
anonymous user. If the condition matched but verify failed, the auth
process should be stop and return immediately.
This will fix #20563
Co-authored-by: KN4CK3R <admin@oldschoolhack.me>
Co-authored-by: Jason Song <i@wolfogre.com>
2022-12-28 00:53:28 -05:00
|
|
|
return nil, nil
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
log.Info("Authenticated as %s\n", username)
|
|
|
|
|
2022-05-20 09:08:52 -05:00
|
|
|
user, err := user_model.GetUserByName(req.Context(), username)
|
2019-11-22 18:33:31 -05:00
|
|
|
if err != nil {
|
2021-11-24 04:49:20 -05:00
|
|
|
if !user_model.IsErrUserNotExist(err) {
|
2019-11-22 18:33:31 -05:00
|
|
|
log.Error("GetUserByName: %v", err)
|
refactor auth interface to return error when verify failure (#22119)
This PR changed the Auth interface signature from
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) *user_model.User`
to
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) (*user_model.User, error)`.
There is a new return argument `error` which means the verification
condition matched but verify process failed, we should stop the auth
process.
Before this PR, when return a `nil` user, we don't know the reason why
it returned `nil`. If the match condition is not satisfied or it
verified failure? For these two different results, we should have
different handler. If the match condition is not satisfied, we should
try next auth method and if there is no more auth method, it's an
anonymous user. If the condition matched but verify failed, the auth
process should be stop and return immediately.
This will fix #20563
Co-authored-by: KN4CK3R <admin@oldschoolhack.me>
Co-authored-by: Jason Song <i@wolfogre.com>
2022-12-28 00:53:28 -05:00
|
|
|
return nil, err
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
if !cfg.AutoCreateUsers {
|
|
|
|
log.Error("User '%s' not found", username)
|
refactor auth interface to return error when verify failure (#22119)
This PR changed the Auth interface signature from
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) *user_model.User`
to
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) (*user_model.User, error)`.
There is a new return argument `error` which means the verification
condition matched but verify process failed, we should stop the auth
process.
Before this PR, when return a `nil` user, we don't know the reason why
it returned `nil`. If the match condition is not satisfied or it
verified failure? For these two different results, we should have
different handler. If the match condition is not satisfied, we should
try next auth method and if there is no more auth method, it's an
anonymous user. If the condition matched but verify failed, the auth
process should be stop and return immediately.
This will fix #20563
Co-authored-by: KN4CK3R <admin@oldschoolhack.me>
Co-authored-by: Jason Song <i@wolfogre.com>
2022-12-28 00:53:28 -05:00
|
|
|
return nil, nil
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
2023-09-14 12:09:32 -05:00
|
|
|
user, err = s.newUser(req.Context(), username, cfg)
|
2019-11-22 18:33:31 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Error("CreateUser: %v", err)
|
refactor auth interface to return error when verify failure (#22119)
This PR changed the Auth interface signature from
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) *user_model.User`
to
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) (*user_model.User, error)`.
There is a new return argument `error` which means the verification
condition matched but verify process failed, we should stop the auth
process.
Before this PR, when return a `nil` user, we don't know the reason why
it returned `nil`. If the match condition is not satisfied or it
verified failure? For these two different results, we should have
different handler. If the match condition is not satisfied, we should
try next auth method and if there is no more auth method, it's an
anonymous user. If the condition matched but verify failed, the auth
process should be stop and return immediately.
This will fix #20563
Co-authored-by: KN4CK3R <admin@oldschoolhack.me>
Co-authored-by: Jason Song <i@wolfogre.com>
2022-12-28 00:53:28 -05:00
|
|
|
return nil, err
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure requests to API paths and PWA resources do not create a new session
|
2021-01-30 03:55:53 -05:00
|
|
|
if !middleware.IsAPIPath(req) && !isAttachmentDownload(req) {
|
2021-01-05 20:38:00 -05:00
|
|
|
handleSignIn(w, req, sess, user)
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
|
2021-05-09 11:04:53 -05:00
|
|
|
log.Trace("SSPI Authorization: Logged in user %-v", user)
|
refactor auth interface to return error when verify failure (#22119)
This PR changed the Auth interface signature from
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) *user_model.User`
to
`Verify(http *http.Request, w http.ResponseWriter, store DataStore, sess
SessionStore) (*user_model.User, error)`.
There is a new return argument `error` which means the verification
condition matched but verify process failed, we should stop the auth
process.
Before this PR, when return a `nil` user, we don't know the reason why
it returned `nil`. If the match condition is not satisfied or it
verified failure? For these two different results, we should have
different handler. If the match condition is not satisfied, we should
try next auth method and if there is no more auth method, it's an
anonymous user. If the condition matched but verify failed, the auth
process should be stop and return immediately.
This will fix #20563
Co-authored-by: KN4CK3R <admin@oldschoolhack.me>
Co-authored-by: Jason Song <i@wolfogre.com>
2022-12-28 00:53:28 -05:00
|
|
|
return user, nil
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// getConfig retrieves the SSPI configuration from login sources
|
2023-10-10 23:24:07 -05:00
|
|
|
func (s *SSPI) getConfig(ctx context.Context) (*sspi.Source, error) {
|
2023-11-23 22:49:41 -05:00
|
|
|
sources, err := db.Find[auth.Source](ctx, auth.FindSourcesOptions{
|
2023-11-02 20:41:00 -05:00
|
|
|
IsActive: util.OptionalBoolTrue,
|
|
|
|
LoginType: auth.SSPI,
|
|
|
|
})
|
2019-11-22 18:33:31 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if len(sources) == 0 {
|
|
|
|
return nil, errors.New("no active login sources of type SSPI found")
|
|
|
|
}
|
|
|
|
if len(sources) > 1 {
|
|
|
|
return nil, errors.New("more than one active login source of type SSPI found")
|
|
|
|
}
|
2021-07-24 05:16:34 -05:00
|
|
|
return sources[0].Cfg.(*sspi.Source), nil
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
|
2021-01-05 08:05:40 -05:00
|
|
|
func (s *SSPI) shouldAuthenticate(req *http.Request) (shouldAuth bool) {
|
2019-11-22 18:33:31 -05:00
|
|
|
shouldAuth = false
|
2021-01-05 08:05:40 -05:00
|
|
|
path := strings.TrimSuffix(req.URL.Path, "/")
|
2019-11-22 18:33:31 -05:00
|
|
|
if path == "/user/login" {
|
2021-01-05 08:05:40 -05:00
|
|
|
if req.FormValue("user_name") != "" && req.FormValue("password") != "" {
|
2019-11-22 18:33:31 -05:00
|
|
|
shouldAuth = false
|
2021-01-05 20:38:00 -05:00
|
|
|
} else if req.FormValue("auth_with_sspi") == "1" {
|
2019-11-22 18:33:31 -05:00
|
|
|
shouldAuth = true
|
|
|
|
}
|
2021-01-30 03:55:53 -05:00
|
|
|
} else if middleware.IsAPIPath(req) || isAttachmentDownload(req) {
|
2019-11-22 18:33:31 -05:00
|
|
|
shouldAuth = true
|
|
|
|
}
|
2022-06-20 05:02:49 -05:00
|
|
|
return shouldAuth
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// newUser creates a new user object for the purpose of automatic registration
|
|
|
|
// and populates its name and email with the information present in request headers.
|
2023-09-14 12:09:32 -05:00
|
|
|
func (s *SSPI) newUser(ctx context.Context, username string, cfg *sspi.Source) (*user_model.User, error) {
|
2020-06-18 04:18:44 -05:00
|
|
|
email := gouuid.New().String() + "@localhost.localdomain"
|
2021-11-24 04:49:20 -05:00
|
|
|
user := &user_model.User{
|
2022-04-29 14:38:11 -05:00
|
|
|
Name: username,
|
|
|
|
Email: email,
|
|
|
|
Passwd: gouuid.New().String(),
|
|
|
|
Language: cfg.DefaultLanguage,
|
|
|
|
UseCustomAvatar: true,
|
|
|
|
Avatar: avatars.DefaultAvatarLink(),
|
2019-11-22 18:33:31 -05:00
|
|
|
}
|
2022-04-29 14:38:11 -05:00
|
|
|
emailNotificationPreference := user_model.EmailNotificationsDisabled
|
|
|
|
overwriteDefault := &user_model.CreateUserOverwriteOptions{
|
|
|
|
IsActive: util.OptionalBoolOf(cfg.AutoActivateUsers),
|
|
|
|
KeepEmailPrivate: util.OptionalBoolTrue,
|
|
|
|
EmailNotificationsPreference: &emailNotificationPreference,
|
|
|
|
}
|
2023-09-14 12:09:32 -05:00
|
|
|
if err := user_model.CreateUser(ctx, user, overwriteDefault); err != nil {
|
2019-11-22 18:33:31 -05:00
|
|
|
return nil, err
|
|
|
|
}
|
2021-08-12 02:26:33 -05:00
|
|
|
|
2019-11-22 18:33:31 -05:00
|
|
|
return user, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// stripDomainNames removes NETBIOS domain name and separator from down-level logon names
|
|
|
|
// (eg. "DOMAIN\user" becomes "user"), and removes the UPN suffix (domain name) and separator
|
|
|
|
// from UPNs (eg. "user@domain.local" becomes "user")
|
|
|
|
func stripDomainNames(username string) string {
|
|
|
|
if strings.Contains(username, "\\") {
|
|
|
|
parts := strings.SplitN(username, "\\", 2)
|
|
|
|
if len(parts) > 1 {
|
|
|
|
username = parts[1]
|
|
|
|
}
|
|
|
|
} else if strings.Contains(username, "@") {
|
|
|
|
parts := strings.Split(username, "@")
|
|
|
|
if len(parts) > 1 {
|
|
|
|
username = parts[0]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return username
|
|
|
|
}
|
|
|
|
|
2021-07-24 05:16:34 -05:00
|
|
|
func replaceSeparators(username string, cfg *sspi.Source) string {
|
2019-11-22 18:33:31 -05:00
|
|
|
newSep := cfg.SeparatorReplacement
|
|
|
|
username = strings.ReplaceAll(username, "\\", newSep)
|
|
|
|
username = strings.ReplaceAll(username, "/", newSep)
|
|
|
|
username = strings.ReplaceAll(username, "@", newSep)
|
|
|
|
return username
|
|
|
|
}
|
|
|
|
|
2021-07-24 05:16:34 -05:00
|
|
|
func sanitizeUsername(username string, cfg *sspi.Source) string {
|
2019-11-22 18:33:31 -05:00
|
|
|
if len(username) == 0 {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
if cfg.StripDomainNames {
|
|
|
|
username = stripDomainNames(username)
|
|
|
|
}
|
|
|
|
// Replace separators even if we have already stripped the domain name part,
|
|
|
|
// as the username can contain several separators: eg. "MICROSOFT\useremail@live.com"
|
|
|
|
username = replaceSeparators(username, cfg)
|
|
|
|
return username
|
|
|
|
}
|