mirror of
https://github.com/go-gitea/gitea.git
synced 2026-11-19 15:14:40 +09:00
Adds audit actions for security-relevant changes that were not logged at all, and records a few remaining events on paths that skipped them: - Account login prohibition (`user:status:prohibitlogin`) and the organization setting that lets repository admins change team access - Actions runner registration tokens issued, runners removed or enabled/disabled, and Actions variables, for every scope - Instance config changes, including maintenance mode (`system:config:update`) - Deploy token regeneration and pull mirror address changes - Review deletion and dismissal, package removal, and release and tag removal - Repository restores via `gitea admin restore-repo`, OAuth2 secret rotation on API update, and SSH keys added or removed by authentication source sync The authentication source SSH key sync moved from the asymkey model to the asymkey service so it can record events. Follow-up to https://github.com/go-gitea/gitea/pull/40317 and https://github.com/go-gitea/gitea/pull/40322. --------- Co-authored-by: silverwind <me@silverwind.io>
343 lines
10 KiB
Go
343 lines
10 KiB
Go
// Copyright 2024 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package user
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
audit_model "gitea.dev/models/audit"
|
|
auth_model "gitea.dev/models/auth"
|
|
user_model "gitea.dev/models/user"
|
|
password_module "gitea.dev/modules/auth/password"
|
|
"gitea.dev/modules/log"
|
|
"gitea.dev/modules/optional"
|
|
"gitea.dev/modules/setting"
|
|
"gitea.dev/modules/structs"
|
|
"gitea.dev/modules/system"
|
|
"gitea.dev/modules/util"
|
|
"gitea.dev/services/audit"
|
|
)
|
|
|
|
type UpdateOptionField[T any] struct {
|
|
FieldValue T
|
|
FromSync bool
|
|
}
|
|
|
|
func UpdateOptionFieldFromValue[T any](value T) optional.Option[UpdateOptionField[T]] {
|
|
return optional.Some(UpdateOptionField[T]{FieldValue: value})
|
|
}
|
|
|
|
func UpdateOptionFieldFromSync[T any](value T) optional.Option[UpdateOptionField[T]] {
|
|
return optional.Some(UpdateOptionField[T]{FieldValue: value, FromSync: true})
|
|
}
|
|
|
|
func UpdateOptionFieldFromPtr[T any](value *T) optional.Option[UpdateOptionField[T]] {
|
|
if value == nil {
|
|
return optional.None[UpdateOptionField[T]]()
|
|
}
|
|
return UpdateOptionFieldFromValue(*value)
|
|
}
|
|
|
|
type UpdateOptions struct {
|
|
KeepEmailPrivate optional.Option[bool]
|
|
FullName optional.Option[string]
|
|
Website optional.Option[string]
|
|
Location optional.Option[string]
|
|
Description optional.Option[string]
|
|
AllowGitHook optional.Option[bool]
|
|
AllowImportLocal optional.Option[bool]
|
|
MaxRepoCreation optional.Option[int]
|
|
IsRestricted optional.Option[bool]
|
|
Visibility optional.Option[structs.VisibleType]
|
|
KeepActivityPrivate optional.Option[bool]
|
|
Language optional.Option[string]
|
|
Theme optional.Option[string]
|
|
DiffViewStyle optional.Option[string]
|
|
AllowCreateOrganization optional.Option[bool]
|
|
IsActive optional.Option[bool]
|
|
IsAdmin optional.Option[UpdateOptionField[bool]]
|
|
UserType optional.Option[user_model.UserType]
|
|
EmailNotificationsPreference optional.Option[string]
|
|
SetLastLogin bool
|
|
RepoAdminChangeTeamAccess optional.Option[bool]
|
|
}
|
|
|
|
func UpdateUser(ctx context.Context, u *user_model.User, opts *UpdateOptions) error {
|
|
cols := make([]string, 0, 20)
|
|
|
|
oldIsActive, oldIsRestricted, oldIsAdmin, oldVisibility, oldType := u.IsActive, u.IsRestricted, u.IsAdmin, u.Visibility, u.Type
|
|
oldRepoAdminChangeTeamAccess := u.RepoAdminChangeTeamAccess
|
|
|
|
if opts.KeepEmailPrivate.Has() {
|
|
u.KeepEmailPrivate = opts.KeepEmailPrivate.Value()
|
|
|
|
cols = append(cols, "keep_email_private")
|
|
}
|
|
|
|
if opts.FullName.Has() {
|
|
u.FullName = opts.FullName.Value()
|
|
|
|
cols = append(cols, "full_name")
|
|
}
|
|
if opts.Website.Has() {
|
|
u.Website = opts.Website.Value()
|
|
|
|
cols = append(cols, "website")
|
|
}
|
|
if opts.Location.Has() {
|
|
u.Location = opts.Location.Value()
|
|
|
|
cols = append(cols, "location")
|
|
}
|
|
if opts.Description.Has() {
|
|
u.Description = opts.Description.Value()
|
|
|
|
cols = append(cols, "description")
|
|
}
|
|
if opts.Language.Has() {
|
|
u.Language = opts.Language.Value()
|
|
|
|
cols = append(cols, "language")
|
|
}
|
|
if opts.Theme.Has() {
|
|
u.Theme = opts.Theme.Value()
|
|
|
|
cols = append(cols, "theme")
|
|
}
|
|
if opts.DiffViewStyle.Has() {
|
|
u.DiffViewStyle = opts.DiffViewStyle.Value()
|
|
|
|
cols = append(cols, "diff_view_style")
|
|
}
|
|
|
|
if opts.AllowGitHook.Has() {
|
|
u.AllowGitHook = opts.AllowGitHook.Value()
|
|
|
|
cols = append(cols, "allow_git_hook")
|
|
}
|
|
if opts.AllowImportLocal.Has() {
|
|
u.AllowImportLocal = opts.AllowImportLocal.Value()
|
|
|
|
cols = append(cols, "allow_import_local")
|
|
}
|
|
|
|
if opts.MaxRepoCreation.Has() {
|
|
u.MaxRepoCreation = opts.MaxRepoCreation.Value()
|
|
|
|
cols = append(cols, "max_repo_creation")
|
|
}
|
|
|
|
if opts.IsActive.Has() {
|
|
u.IsActive = opts.IsActive.Value()
|
|
|
|
cols = append(cols, "is_active")
|
|
}
|
|
if opts.IsRestricted.Has() {
|
|
u.IsRestricted = opts.IsRestricted.Value()
|
|
|
|
cols = append(cols, "is_restricted")
|
|
}
|
|
if opts.IsAdmin.Has() {
|
|
if opts.IsAdmin.Value().FieldValue /* true */ {
|
|
u.IsAdmin = opts.IsAdmin.Value().FieldValue // set IsAdmin=true
|
|
cols = append(cols, "is_admin")
|
|
} else if !user_model.IsLastAdminUser(ctx, u) /* not the last admin */ {
|
|
u.IsAdmin = opts.IsAdmin.Value().FieldValue // it's safe to change it from false to true (not the last admin)
|
|
cols = append(cols, "is_admin")
|
|
} else /* IsAdmin=false but this is the last admin user */ { //nolint:gocritic // make it easier to read
|
|
if !opts.IsAdmin.Value().FromSync {
|
|
return user_model.ErrDeleteLastAdminUser{UID: u.ID}
|
|
}
|
|
// else: syncing from external-source, this user is the last admin, so skip the "IsAdmin=false" change
|
|
}
|
|
}
|
|
|
|
// only validate and persist the visibility when it actually changes
|
|
if opts.Visibility.Has() && opts.Visibility.Value() != u.Visibility {
|
|
if !u.IsOrganization() && !setting.Service.AllowedUserVisibilityModesSlice.IsAllowedVisibility(opts.Visibility.Value()) {
|
|
return fmt.Errorf("visibility mode not allowed: %s", opts.Visibility.Value().String())
|
|
}
|
|
u.Visibility = opts.Visibility.Value()
|
|
|
|
cols = append(cols, "visibility")
|
|
}
|
|
if opts.KeepActivityPrivate.Has() {
|
|
if forced := setting.Service.ForceUserActivityVisibility; forced != "" && opts.KeepActivityPrivate.Value() != (forced == "private") {
|
|
return util.ErrorWrap(util.ErrUnprocessableContent, "activity visibility is forced to %s", forced)
|
|
}
|
|
u.KeepActivityPrivate = opts.KeepActivityPrivate.Value()
|
|
|
|
cols = append(cols, "keep_activity_private")
|
|
}
|
|
|
|
if opts.AllowCreateOrganization.Has() {
|
|
u.AllowCreateOrganization = opts.AllowCreateOrganization.Value()
|
|
|
|
cols = append(cols, "allow_create_organization")
|
|
}
|
|
if opts.RepoAdminChangeTeamAccess.Has() {
|
|
u.RepoAdminChangeTeamAccess = opts.RepoAdminChangeTeamAccess.Value()
|
|
|
|
cols = append(cols, "repo_admin_change_team_access")
|
|
}
|
|
|
|
if opts.UserType.Has() && opts.UserType.Value() != u.Type {
|
|
if err := CheckConvertUserType(u); err != nil {
|
|
return err
|
|
}
|
|
u.Type = opts.UserType.Value()
|
|
cols = append(cols, "type")
|
|
}
|
|
|
|
if opts.EmailNotificationsPreference.Has() {
|
|
u.EmailNotificationsPreference = opts.EmailNotificationsPreference.Value()
|
|
|
|
cols = append(cols, "email_notifications_preference")
|
|
}
|
|
|
|
if opts.SetLastLogin {
|
|
u.SetLastLogin()
|
|
|
|
cols = append(cols, "last_login_unix")
|
|
}
|
|
|
|
if err := user_model.UpdateUserCols(ctx, u, cols...); err != nil {
|
|
return err
|
|
}
|
|
|
|
if u.IsActive != oldIsActive {
|
|
audit.Record(ctx, audit_model.UserActive, u, "active", u.IsActive)
|
|
}
|
|
if u.IsAdmin != oldIsAdmin {
|
|
audit.Record(ctx, audit_model.UserAdmin, u, "admin", u.IsAdmin)
|
|
}
|
|
if u.IsRestricted != oldIsRestricted {
|
|
audit.Record(ctx, audit_model.UserRestricted, u, "restricted", u.IsRestricted)
|
|
}
|
|
if u.Visibility != oldVisibility {
|
|
audit.Record(ctx, audit_model.UserVisibility, u, "old_visibility", oldVisibility.String(), "new_visibility", u.Visibility.String())
|
|
}
|
|
if u.Type != oldType {
|
|
audit.Record(ctx, audit_model.UserType, u, "user_type", u.Type.DisplayName())
|
|
}
|
|
if u.RepoAdminChangeTeamAccess != oldRepoAdminChangeTeamAccess {
|
|
audit.Record(ctx, audit_model.OrganizationTeamAccess, u, "repo_admin_change_team_access", u.RepoAdminChangeTeamAccess)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type UpdateAuthOptions struct {
|
|
LoginSource optional.Option[int64]
|
|
LoginName optional.Option[string]
|
|
Password optional.Option[string]
|
|
MustChangePassword optional.Option[bool]
|
|
ProhibitLogin optional.Option[bool]
|
|
}
|
|
|
|
func UpdateAuth(ctx context.Context, u *user_model.User, opts *UpdateAuthOptions) error {
|
|
if u.IsTypeBot() && (opts.Password.Has() || opts.LoginSource.Value() != 0 || opts.LoginName.Value() != "") {
|
|
return util.NewInvalidArgumentErrorf("a bot account cannot have a password or authentication source")
|
|
}
|
|
loginSourceChanged := false
|
|
authSourceName := ""
|
|
if opts.LoginSource.Has() {
|
|
source, err := auth_model.GetSourceByID(ctx, opts.LoginSource.Value())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
loginSourceChanged = u.LoginSource != source.ID
|
|
authSourceName = source.Name
|
|
|
|
u.LoginType = source.Type
|
|
u.LoginSource = source.ID
|
|
}
|
|
if opts.LoginName.Has() {
|
|
u.LoginName = opts.LoginName.Value()
|
|
}
|
|
|
|
deleteAuthTokens := false
|
|
if opts.Password.Has() && (u.IsLocal() || u.IsOAuth2()) {
|
|
password := opts.Password.Value()
|
|
|
|
if len(password) < setting.MinPasswordLength {
|
|
return password_module.ErrMinLength
|
|
}
|
|
if !password_module.IsComplexEnough(password) {
|
|
return password_module.ErrComplexity
|
|
}
|
|
if err := password_module.IsPwned(ctx, password); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := u.SetPassword(password); err != nil {
|
|
return err
|
|
}
|
|
|
|
deleteAuthTokens = true
|
|
}
|
|
|
|
if opts.MustChangePassword.Has() {
|
|
u.MustChangePassword = opts.MustChangePassword.Value()
|
|
}
|
|
oldProhibitLogin := u.ProhibitLogin
|
|
if opts.ProhibitLogin.Has() {
|
|
u.ProhibitLogin = opts.ProhibitLogin.Value()
|
|
}
|
|
|
|
if err := user_model.UpdateUserCols(ctx, u, "login_type", "login_source", "login_name", "passwd", "passwd_hash_algo", "salt", "must_change_password", "prohibit_login"); err != nil {
|
|
return err
|
|
}
|
|
|
|
if deleteAuthTokens {
|
|
if err := auth_model.DeleteAuthTokensByUserID(ctx, u.ID); err != nil {
|
|
return err
|
|
}
|
|
|
|
audit.Record(ctx, audit_model.UserPassword, u)
|
|
}
|
|
if loginSourceChanged {
|
|
audit.Record(ctx, audit_model.UserAuthenticationSource, u, "auth_source", authSourceName)
|
|
}
|
|
if u.ProhibitLogin != oldProhibitLogin {
|
|
audit.Record(ctx, audit_model.UserProhibitLogin, u, "prohibit_login", u.ProhibitLogin)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func CheckConvertUserType(u *user_model.User) error {
|
|
switch {
|
|
case u.IsAdmin:
|
|
return user_model.ErrBotCanNotBeAdmin
|
|
case !u.IsIndividual() && !u.IsTypeBot():
|
|
return user_model.ErrUserTypeCanNotConvert
|
|
case !u.IsLocal():
|
|
return user_model.ErrBotMustBeLocal
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SyncForcedActivityVisibility applies FORCE_USER_ACTIVITY_VISIBILITY to all users when it changed since the last start
|
|
func SyncForcedActivityVisibility(ctx context.Context) error {
|
|
lastConfig := new(system.LastConfig)
|
|
if err := system.AppState.Get(ctx, lastConfig); err != nil {
|
|
return err
|
|
}
|
|
forced := setting.Service.ForceUserActivityVisibility
|
|
if lastConfig.ForceUserActivityVisibility == forced {
|
|
return nil
|
|
}
|
|
if forced != "" {
|
|
log.Info("FORCE_USER_ACTIVITY_VISIBILITY changed to %q, updating all users", forced)
|
|
if err := user_model.UpdateAllUsersKeepActivityPrivate(ctx, forced == "private"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
lastConfig.ForceUserActivityVisibility = forced
|
|
return system.AppState.Set(ctx, lastConfig)
|
|
}
|