// Query if name/passwd can login against the LDAP directory pool // Create a local user if success // Return the same LoginUserPlain semantic // FIXME: https://github.com/go-gitea/gitea/issues/672 func LoginUserLdapSource(u *User, name, passwd string, sourceId int64, cfg *LDAPConfig, autoRegister bool) (*User, error) { name, fn, sn, mail, logged := cfg.Ldapsource.SearchEntry(name, passwd) if !logged { // User not in LDAP, do nothing return nil, ErrUserNotExist } if !autoRegister { return u, nil } // Fallback. if len(mail) == 0 { mail = uuid.NewV4().String() + "@localhost" } u = &User{ LowerName: strings.ToLower(name), Name: name, FullName: fn + " " + sn, LoginType: LDAP, LoginSource: sourceId, LoginName: name, Passwd: passwd, Email: mail, IsActive: true, } return u, CreateUser(u) }
// CreateHookTask creates a new hook task, // it handles conversion from Payload to PayloadContent. func CreateHookTask(t *HookTask) error { data, err := t.BasePayload.GetJSONPayload() if err != nil { return err } t.Uuid = uuid.NewV4().String() t.PayloadContent = string(data) _, err = x.Insert(t) return err }
// NewAccessToken creates new access token. func NewAccessToken(t *AccessToken) error { t.Sha1 = base.EncodeSha1(uuid.NewV4().String()) _, err := x.Insert(t) return err }
// SignedInUser returns the user object of signed user. // It returns a bool value to indicate whether user uses basic auth or not. func SignedInUser(req *http.Request, sess session.Store) (*models.User, bool) { if !models.HasEngine { return nil, false } uid := SignedInId(req, sess) if uid <= 0 { if setting.Service.EnableReverseProxyAuth { webAuthUser := req.Header.Get(setting.ReverseProxyAuthUser) if len(webAuthUser) > 0 { u, err := models.GetUserByName(webAuthUser) if err != nil { if err != models.ErrUserNotExist { log.Error(4, "GetUserByName: %v", err) return nil, false } // Check if enabled auto-registration. if setting.Service.EnableReverseProxyAutoRegister { u := &models.User{ Name: webAuthUser, Email: uuid.NewV4().String() + "@localhost", Passwd: webAuthUser, IsActive: true, } if err = models.CreateUser(u); err != nil { // FIXME: should I create a system notice? log.Error(4, "CreateUser: %v", err) return nil, false } else { return u, false } } } return u, false } } // Check with basic auth. baHead := req.Header.Get("Authorization") if len(baHead) > 0 { auths := strings.Fields(baHead) if len(auths) == 2 && auths[0] == "Basic" { uname, passwd, _ := base.BasicAuthDecode(auths[1]) u, err := models.UserSignIn(uname, passwd) if err != nil { if err != models.ErrUserNotExist { log.Error(4, "UserSignIn: %v", err) } return nil, false } return u, true } } return nil, false } u, err := models.GetUserById(uid) if err != nil { log.Error(4, "GetUserById: %v", err) return nil, false } return u, false }
func runServ(c *cli.Context) { if c.IsSet("config") { setting.CustomConf = c.String("config") } setup("serv.log") fail := func(userMessage, logMessage string, args ...interface{}) { fmt.Fprintln(os.Stderr, "Gogs: ", userMessage) log.GitLogger.Fatal(2, logMessage, args...) } if len(c.Args()) < 1 { fail("Not enough arguments", "Not enough arugments") } keys := strings.Split(c.Args()[0], "-") if len(keys) != 2 { fail("key-id format error", "Invalid key id: %s", c.Args()[0]) } keyId, err := com.StrTo(keys[1]).Int64() if err != nil { fail("key-id format error", "Invalid key id: %s", err) } user, err := models.GetUserByKeyId(keyId) if err != nil { fail("internal error", "Fail to get user by key ID(%d): %v", keyId, err) } cmd := os.Getenv("SSH_ORIGINAL_COMMAND") if cmd == "" { println("Hi", user.Name, "! You've successfully authenticated, but Gogs does not provide shell access.") if user.IsAdmin { println("If this is unexpected, please log in with password and setup Gogs under another user.") } return } verb, args := parseCmd(cmd) repoPath := strings.Trim(args, "'") rr := strings.SplitN(repoPath, "/", 2) if len(rr) != 2 { fail("Invalid repository path", "Invalide repository path: %v", args) } repoUserName := rr[0] repoName := strings.TrimSuffix(rr[1], ".git") repoUser, err := models.GetUserByName(repoUserName) if err != nil { if err == models.ErrUserNotExist { fail("Repository owner does not exist", "Unregistered owner: %s", repoUserName) } fail("Internal error", "Fail to get repository owner(%s): %v", repoUserName, err) } repo, err := models.GetRepositoryByName(repoUser.Id, repoName) if err != nil { if models.IsErrRepoNotExist(err) { if user.Id == repoUser.Id || repoUser.IsOwnedBy(user.Id) { fail("Repository does not exist", "Repository does not exist: %s/%s", repoUser.Name, repoName) } else { fail(_ACCESS_DENIED_MESSAGE, "Repository does not exist: %s/%s", repoUser.Name, repoName) } } fail("Internal error", "Fail to get repository: %v", err) } requestedMode, has := COMMANDS[verb] if !has { fail("Unknown git command", "Unknown git command %s", verb) } mode, err := models.AccessLevel(user, repo) if err != nil { fail("Internal error", "Fail to check access: %v", err) } else if mode < requestedMode { clientMessage := _ACCESS_DENIED_MESSAGE if mode >= models.ACCESS_MODE_READ { clientMessage = "You do not have sufficient authorization for this action" } fail(clientMessage, "User %s does not have level %v access to repository %s", user.Name, requestedMode, repoPath) } uuid := uuid.NewV4().String() os.Setenv("uuid", uuid) var gitcmd *exec.Cmd verbs := strings.Split(verb, " ") if len(verbs) == 2 { gitcmd = exec.Command(verbs[0], verbs[1], repoPath) } else { gitcmd = exec.Command(verb, repoPath) } gitcmd.Dir = setting.RepoRootPath gitcmd.Stdout = os.Stdout gitcmd.Stdin = os.Stdin gitcmd.Stderr = os.Stderr if err = gitcmd.Run(); err != nil { fail("Internal error", "Fail to execute git command: %v", err) } if requestedMode == models.ACCESS_MODE_WRITE { tasks, err := models.GetUpdateTasksByUuid(uuid) if err != nil { log.GitLogger.Fatal(2, "GetUpdateTasksByUuid: %v", err) } for _, task := range tasks { err = models.Update(task.RefName, task.OldCommitId, task.NewCommitId, user.Name, repoUserName, repoName, user.Id) if err != nil { log.GitLogger.Error(2, "Fail to update: %v", err) } } if err = models.DelUpdateTasksByUuid(uuid); err != nil { log.GitLogger.Fatal(2, "DelUpdateTasksByUuid: %v", err) } } // Update key activity. key, err := models.GetPublicKeyById(keyId) if err != nil { fail("Internal error", "GetPublicKeyById: %v", err) } key.Updated = time.Now() if err = models.UpdatePublicKey(key); err != nil { fail("Internal error", "UpdatePublicKey: %v", err) } }