// Copyright (c) HashiCorp, Inc. // SPDX-License-Identifier: BUSL-1.1 package vault import ( "context" "crypto/hmac" "encoding/base64" "errors" "fmt" "os" "strconv" "strings" "time" "github.com/armon/go-metrics" "github.com/golang/protobuf/proto" "github.com/hashicorp/errwrap" "github.com/hashicorp/go-multierror" "github.com/hashicorp/go-secure-stdlib/strutil" "github.com/hashicorp/go-sockaddr" "github.com/hashicorp/go-uuid" uberAtomic "go.uber.org/atomic" "github.com/hashicorp/vault/command/server" "github.com/hashicorp/vault/helper/identity" "github.com/hashicorp/vault/helper/identity/mfa" "github.com/hashicorp/vault/helper/metricsutil" "github.com/hashicorp/vault/helper/namespace" "github.com/hashicorp/vault/internalshared/configutil" "github.com/hashicorp/vault/sdk/framework" "github.com/hashicorp/vault/sdk/helper/consts" "github.com/hashicorp/vault/sdk/helper/errutil" "github.com/hashicorp/vault/sdk/helper/jsonutil" "github.com/hashicorp/vault/sdk/helper/policyutil" "github.com/hashicorp/vault/sdk/helper/wrapping" "github.com/hashicorp/vault/sdk/logical" "github.com/hashicorp/vault/vault/quotas" "github.com/hashicorp/vault/vault/tokens" ) const ( replTimeout = 1 * time.Second EnvVaultDisableLocalAuthMountEntities = "VAULT_DISABLE_LOCAL_AUTH_MOUNT_ENTITIES" // base path to store locked users coreLockedUsersPath = "core/login/lockedUsers/" ) var ( // DefaultMaxRequestDuration is the amount of time we'll wait for a request // to complete, unless overridden on a per-handler basis DefaultMaxRequestDuration = 90 * time.Second ErrNoApplicablePolicies = errors.New("no applicable policies") ErrPolicyNotExistInTypeMap = errors.New("policy does not exist in type map") egpDebugLogging bool // if this returns an error, the request should be blocked and the error // should be returned to the client enterpriseBlockRequestIfError = blockRequestIfErrorImpl ) // HandlerProperties is used to seed configuration into a vaulthttp.Handler. // It's in this package to avoid a circular dependency type HandlerProperties struct { Core *Core ListenerConfig *configutil.Listener DisablePrintableCheck bool RecoveryMode bool RecoveryToken *uberAtomic.String } // fetchEntityAndDerivedPolicies returns the entity object for the given entity // ID. If the entity is merged into a different entity object, the entity into // which the given entity ID is merged into will be returned. This function // also returns the cumulative list of policies that the entity is entitled to // if skipDeriveEntityPolicies is set to false. This list includes the policies from the // entity itself and from all the groups in which the given entity ID is a member of. func (c *Core) fetchEntityAndDerivedPolicies(ctx context.Context, tokenNS *namespace.Namespace, entityID string, skipDeriveEntityPolicies bool) (*identity.Entity, map[string][]string, error) { if entityID == "" || c.identityStore == nil { return nil, nil, nil } // c.logger.Debug("entity set on the token", "entity_id", te.EntityID) // Fetch the entity entity, err := c.identityStore.MemDBEntityByID(entityID, false) if err != nil { c.logger.Error("failed to lookup entity using its ID", "error", err) return nil, nil, err } if entity == nil { // If there was no corresponding entity object found, it is // possible that the entity got merged into another entity. Try // finding entity based on the merged entity index. entity, err = c.identityStore.MemDBEntityByMergedEntityID(entityID, false) if err != nil { c.logger.Error("failed to lookup entity in merged entity ID index", "error", err) return nil, nil, err } } policies := make(map[string][]string) if entity != nil && !skipDeriveEntityPolicies { // c.logger.Debug("entity successfully fetched; adding entity policies to token's policies to create ACL") // Attach the policies on the entity if len(entity.Policies) != 0 { policies[entity.NamespaceID] = append(policies[entity.NamespaceID], entity.Policies...) } groupPolicies, err := c.identityStore.groupPoliciesByEntityID(entity.ID) if err != nil { c.logger.Error("failed to fetch group policies", "error", err) return nil, nil, err } policiesByNS, err := c.filterGroupPoliciesByNS(ctx, tokenNS, groupPolicies) if err != nil { return nil, nil, err } for nsID, pss := range policiesByNS { policies[nsID] = append(policies[nsID], pss...) } } return entity, policies, err } // filterGroupPoliciesByNS takes a context, token namespace, and a map of // namespace IDs to slices of group policy names and returns a similar map, // but filtered down to the policies that should apply to the token based on the // relationship between the namespace of the token and the namespace of the // policy. func (c *Core) filterGroupPoliciesByNS(ctx context.Context, tokenNS *namespace.Namespace, groupPolicies map[string][]string) (map[string][]string, error) { policies := make(map[string][]string) policyApplicationMode, err := c.GetGroupPolicyApplicationMode(ctx) if err != nil { return nil, err } for nsID, nsPolicies := range groupPolicies { filteredPolicies, err := c.getApplicableGroupPolicies(ctx, tokenNS, nsID, nsPolicies, policyApplicationMode) if err != nil && err != ErrNoApplicablePolicies { return nil, err } filteredPolicies = strutil.RemoveDuplicates(filteredPolicies, false) if len(filteredPolicies) != 0 { policies[nsID] = append(policies[nsID], filteredPolicies...) } } return policies, nil } // getApplicableGroupPolicies returns a slice of group policies that should // apply to the token based on the group policy application mode, // and the relationship between the token namespace and the group namespace. func (c *Core) getApplicableGroupPolicies(ctx context.Context, tokenNS *namespace.Namespace, nsID string, nsPolicies []string, policyApplicationMode string) ([]string, error) { policyNS, err := NamespaceByID(ctx, nsID, c) if err != nil { return nil, err } if policyNS == nil { return nil, namespace.ErrNoNamespace } var filteredPolicies []string if tokenNS.Path == policyNS.Path { // Same namespace - add all and continue for _, policyName := range nsPolicies { filteredPolicies = append(filteredPolicies, policyName) } return filteredPolicies, nil } for _, policyName := range nsPolicies { t, err := c.policyStore.GetNonEGPPolicyType(policyNS.ID, policyName) if err != nil && errors.Is(err, ErrPolicyNotExistInTypeMap) { // When we attempt to get a non-EGP policy type, and receive an // explicit error that it doesn't exist (in the type map) we log the // ns/policy and continue without error. c.Logger().Debug(fmt.Errorf("%w: %v/%v", err, policyNS.ID, policyName).Error()) continue } if err != nil || t == nil { return nil, fmt.Errorf("failed to look up type of policy: %w", err) } switch *t { case PolicyTypeRGP: if tokenNS.HasParent(policyNS) { filteredPolicies = append(filteredPolicies, policyName) } case PolicyTypeACL: if policyApplicationMode != groupPolicyApplicationModeWithinNamespaceHierarchy { // Group policy application mode isn't set to enforce // the namespace hierarchy, so apply all the ACLs, // regardless of their namespaces. filteredPolicies = append(filteredPolicies, policyName) continue } if policyNS.HasParent(tokenNS) { filteredPolicies = append(filteredPolicies, policyName) } default: return nil, fmt.Errorf("unexpected policy type: %v", t) } } if len(filteredPolicies) == 0 { return nil, ErrNoApplicablePolicies } return filteredPolicies, nil } func (c *Core) fetchACLTokenEntryAndEntity(ctx context.Context, req *logical.Request) (*ACL, *logical.TokenEntry, *identity.Entity, map[string][]string, error) { defer metrics.MeasureSince([]string{"core", "fetch_acl_and_token"}, time.Now()) // Ensure there is a client token if req.ClientToken == "" { return nil, nil, nil, nil, logical.ErrPermissionDenied } if c.tokenStore == nil { c.logger.Error("token store is unavailable") return nil, nil, nil, nil, ErrInternalError } // Resolve the token policy var te *logical.TokenEntry switch req.TokenEntry() { case nil: var err error te, err = c.tokenStore.Lookup(ctx, req.ClientToken) if err != nil { c.logger.Error("failed to lookup acl token", "error", err) return nil, nil, nil, nil, ErrInternalError } // Set the token entry here since it has not been cached yet req.SetTokenEntry(te) default: te = req.TokenEntry() } // Ensure the token is valid if te == nil { return nil, nil, nil, nil, logical.ErrPermissionDenied } // CIDR checks bind all tokens except non-expiring root tokens if te.TTL != 0 && len(te.BoundCIDRs) > 0 { var valid bool remoteSockAddr, err := sockaddr.NewSockAddr(req.Connection.RemoteAddr) if err != nil { if c.Logger().IsDebug() { c.Logger().Debug("could not parse remote addr into sockaddr", "error", err, "remote_addr", req.Connection.RemoteAddr) } return nil, nil, nil, nil, logical.ErrPermissionDenied } for _, cidr := range te.BoundCIDRs { if cidr.Contains(remoteSockAddr) { valid = true break } } if !valid { return nil, nil, nil, nil, logical.ErrPermissionDenied } } policyNames := make(map[string][]string) // Add tokens policies policyNames[te.NamespaceID] = append(policyNames[te.NamespaceID], te.Policies...) tokenNS, err := NamespaceByID(ctx, te.NamespaceID, c) if err != nil { c.logger.Error("failed to fetch token namespace", "error", err) return nil, nil, nil, nil, ErrInternalError } if tokenNS == nil { c.logger.Error("failed to fetch token namespace", "error", namespace.ErrNoNamespace) return nil, nil, nil, nil, ErrInternalError } // Add identity policies from all the namespaces entity, identityPolicies, err := c.fetchEntityAndDerivedPolicies(ctx, tokenNS, te.EntityID, te.NoIdentityPolicies) if err != nil { return nil, nil, nil, nil, ErrInternalError } for nsID, nsPolicies := range identityPolicies { policyNames[nsID] = policyutil.SanitizePolicies(append(policyNames[nsID], nsPolicies...), false) } // Attach token's namespace information to the context. Wrapping tokens by // should be able to be used anywhere, so we also special case behavior. var tokenCtx context.Context if len(policyNames) == 1 && len(policyNames[te.NamespaceID]) == 1 && (policyNames[te.NamespaceID][0] == responseWrappingPolicyName || policyNames[te.NamespaceID][0] == controlGroupPolicyName) && (strings.HasSuffix(req.Path, "sys/wrapping/unwrap") || strings.HasSuffix(req.Path, "sys/wrapping/lookup") || strings.HasSuffix(req.Path, "sys/wrapping/rewrap")) { // Use the request namespace; will find the copy of the policy for the // local namespace tokenCtx = ctx } else { // Use the token's namespace for looking up policy tokenCtx = namespace.ContextWithNamespace(ctx, tokenNS) } // Add the inline policy if it's set policies := make([]*Policy, 0) if te.InlinePolicy != "" { inlinePolicy, err := ParseACLPolicy(tokenNS, te.InlinePolicy) if err != nil { return nil, nil, nil, nil, ErrInternalError } policies = append(policies, inlinePolicy) } // Construct the corresponding ACL object. ACL construction should be // performed on the token's namespace. acl, err := c.policyStore.ACL(tokenCtx, entity, policyNames, policies...) if err != nil { c.logger.Error("failed to construct ACL", "error", err) return nil, nil, nil, nil, ErrInternalError } return acl, te, entity, identityPolicies, nil } func (c *Core) CheckToken(ctx context.Context, req *logical.Request, unauth bool) (*logical.Auth, *logical.TokenEntry, error) { defer metrics.MeasureSince([]string{"core", "check_token"}, time.Now()) var acl *ACL var te *logical.TokenEntry var entity *identity.Entity var identityPolicies map[string][]string // Even if unauth, if a token is provided, there's little reason not to // gather as much info as possible for the audit log and to e.g. control // trace mode for EGPs. if !unauth || (unauth && req.ClientToken != "") { var err error acl, te, entity, identityPolicies, err = c.fetchACLTokenEntryAndEntity(ctx, req) // In the unauth case we don't want to fail the command, since it's // unauth, we just have no information to attach to the request, so // ignore errors...this was best-effort anyways if err != nil && !unauth { return nil, te, err } } if entity != nil && entity.Disabled { c.logger.Warn("permission denied as the entity on the token is disabled") return nil, te, logical.ErrPermissionDenied } if te != nil && te.EntityID != "" && entity == nil { if c.perfStandby { return nil, nil, logical.ErrPerfStandbyPleaseForward } c.logger.Warn("permission denied as the entity on the token is invalid") return nil, te, logical.ErrPermissionDenied } // Check if this is a root protected path rootPath := c.router.RootPath(ctx, req.Path) if rootPath && unauth { return nil, nil, errors.New("cannot access root path in unauthenticated request") } // At this point we won't be forwarding a raw request; we should delete // authorization headers as appropriate switch req.ClientTokenSource { case logical.ClientTokenFromVaultHeader: delete(req.Headers, consts.AuthHeaderName) case logical.ClientTokenFromAuthzHeader: if headers, ok := req.Headers["Authorization"]; ok { retHeaders := make([]string, 0, len(headers)) for _, v := range headers { if strings.HasPrefix(v, "Bearer ") { continue } retHeaders = append(retHeaders, v) } req.Headers["Authorization"] = retHeaders } } // When we receive a write of either type, rather than require clients to // PUT/POST and trust the operation, we ask the backend to give us the real // skinny -- if the backend implements an existence check, it can tell us // whether a particular resource exists. Then we can mark it as an update // or creation as appropriate. if req.Operation == logical.CreateOperation || req.Operation == logical.UpdateOperation { existsResp, checkExists, resourceExists, err := c.router.RouteExistenceCheck(ctx, req) switch err { case logical.ErrUnsupportedPath: // fail later via bad path to avoid confusing items in the log checkExists = false case logical.ErrRelativePath: return nil, te, errutil.UserError{Err: err.Error()} case nil: if existsResp != nil && existsResp.IsError() { return nil, te, existsResp.Error() } // Otherwise, continue on default: c.logger.Error("failed to run existence check", "error", err) if _, ok := err.(errutil.UserError); ok { return nil, te, err } else { return nil, te, ErrInternalError } } switch { case !checkExists: // No existence check, so always treat it as an update operation, which is how it is pre 0.5 req.Operation = logical.UpdateOperation case resourceExists: // It exists, so force an update operation req.Operation = logical.UpdateOperation case !resourceExists: // It doesn't exist, force a create operation req.Operation = logical.CreateOperation default: panic("unreachable code") } } // Create the auth response auth := &logical.Auth{ ClientToken: req.ClientToken, Accessor: req.ClientTokenAccessor, } var clientID string var isTWE bool if te != nil { auth.IdentityPolicies = identityPolicies[te.NamespaceID] auth.TokenPolicies = te.Policies auth.Policies = policyutil.SanitizePolicies(append(te.Policies, identityPolicies[te.NamespaceID]...), false) auth.Metadata = te.Meta auth.DisplayName = te.DisplayName auth.EntityID = te.EntityID delete(identityPolicies, te.NamespaceID) auth.ExternalNamespacePolicies = identityPolicies // Store the entity ID in the request object req.EntityID = te.EntityID auth.TokenType = te.Type auth.TTL = te.TTL if te.CreationTime > 0 { auth.IssueTime = time.Unix(te.CreationTime, 0) } clientID, isTWE = te.CreateClientID() req.ClientID = clientID } // Check the standard non-root ACLs. Return the token entry if it's not // allowed so we can decrement the use count. authResults := c.performPolicyChecks(ctx, acl, te, req, entity, &PolicyCheckOpts{ Unauth: unauth, RootPrivsRequired: rootPath, }) auth.PolicyResults = &logical.PolicyResults{ Allowed: authResults.Allowed, } if !authResults.Allowed { retErr := authResults.Error // If we get a control group error and we are a performance standby, // restore the client token information to the request so that we can // forward this request properly to the active node. if retErr.ErrorOrNil() != nil && checkErrControlGroupTokenNeedsCreated(retErr) && c.perfStandby && len(req.ClientToken) != 0 { switch req.ClientTokenSource { case logical.ClientTokenFromVaultHeader: req.Headers[consts.AuthHeaderName] = []string{req.ClientToken} case logical.ClientTokenFromAuthzHeader: req.Headers["Authorization"] = append(req.Headers["Authorization"], fmt.Sprintf("Bearer %s", req.ClientToken)) } // We also return the appropriate error so that the caller can forward the // request to the active node return auth, te, logical.ErrPerfStandbyPleaseForward } if authResults.Error.ErrorOrNil() == nil || authResults.DeniedError { retErr = multierror.Append(retErr, logical.ErrPermissionDenied) } return auth, te, retErr } if authResults.ACLResults != nil && len(authResults.ACLResults.GrantingPolicies) > 0 { auth.PolicyResults.GrantingPolicies = authResults.ACLResults.GrantingPolicies } if authResults.SentinelResults != nil && len(authResults.SentinelResults.GrantingPolicies) > 0 { auth.PolicyResults.GrantingPolicies = append(auth.PolicyResults.GrantingPolicies, authResults.SentinelResults.GrantingPolicies...) } c.activityLogLock.RLock() activityLog := c.activityLog c.activityLogLock.RUnlock() // If it is an authenticated ( i.e. with vault token ) request, increment client count if !unauth && activityLog != nil { err := activityLog.HandleTokenUsage(ctx, te, clientID, isTWE) if err != nil { return auth, te, err } } return auth, te, nil } // HandleRequest is used to handle a new incoming request func (c *Core) HandleRequest(httpCtx context.Context, req *logical.Request) (resp *logical.Response, err error) { return c.switchedLockHandleRequest(httpCtx, req, true) } func (c *Core) switchedLockHandleRequest(httpCtx context.Context, req *logical.Request, doLocking bool) (resp *logical.Response, err error) { if doLocking { c.stateLock.RLock() defer c.stateLock.RUnlock() } if c.Sealed() { return nil, consts.ErrSealed } if c.standby && !c.perfStandby { return nil, consts.ErrStandby } if c.activeContext == nil || c.activeContext.Err() != nil { return nil, errors.New("active context canceled after getting state lock") } ctx, cancel := context.WithCancel(c.activeContext) go func(ctx context.Context, httpCtx context.Context) { select { case <-ctx.Done(): case <-httpCtx.Done(): cancel() } }(ctx, httpCtx) ns, err := namespace.FromContext(httpCtx) if err != nil { cancel() return nil, fmt.Errorf("could not parse namespace from http context: %w", err) } ctx = namespace.ContextWithNamespace(ctx, ns) inFlightReqID, ok := httpCtx.Value(logical.CtxKeyInFlightRequestID{}).(string) if ok { ctx = context.WithValue(ctx, logical.CtxKeyInFlightRequestID{}, inFlightReqID) } requestRole, ok := httpCtx.Value(logical.CtxKeyRequestRole{}).(string) if ok { ctx = context.WithValue(ctx, logical.CtxKeyRequestRole{}, requestRole) } body, ok := logical.ContextOriginalBodyValue(httpCtx) if ok { ctx = logical.CreateContextOriginalBody(ctx, body) } resp, err = c.handleCancelableRequest(ctx, req) req.SetTokenEntry(nil) cancel() return resp, err } func (c *Core) handleCancelableRequest(ctx context.Context, req *logical.Request) (resp *logical.Response, err error) { // Allowing writing to a path ending in / makes it extremely difficult to // understand user intent for the filesystem-like backends (kv, // cubbyhole) -- did they want a key named foo/ or did they want to write // to a directory foo/ with no (or forgotten) key, or...? It also affects // lookup, because paths ending in / are considered prefixes by some // backends. Basically, it's all just terrible, so don't allow it. if strings.HasSuffix(req.Path, "/") && (req.Operation == logical.UpdateOperation || req.Operation == logical.CreateOperation || req.Operation == logical.PatchOperation) { return logical.ErrorResponse("cannot write to a path ending in '/'"), nil } waitGroup, err := waitForReplicationState(ctx, c, req) if err != nil { return nil, err } // MountPoint will not always be set at this point, so we ensure the req contains it // as it is depended on by some functionality (e.g. quotas) req.MountPoint = c.router.MatchingMount(ctx, req.Path) // Decrement the wait group when our request is done if waitGroup != nil { defer waitGroup.Done() } if c.MissingRequiredState(req.RequiredState(), c.perfStandby) { return nil, logical.ErrMissingRequiredState } err = c.PopulateTokenEntry(ctx, req) if err != nil { return nil, err } // Always forward requests that are using a limited use count token. if c.perfStandby && req.ClientTokenRemainingUses > 0 { // Prevent forwarding on local-only requests. return nil, logical.ErrPerfStandbyPleaseForward } ns, err := namespace.FromContext(ctx) if err != nil { return nil, fmt.Errorf("could not parse namespace from http context: %w", err) } var requestBodyToken string var returnRequestAuthToken bool // req.Path will be relative by this point. The prefix check is first // to fail faster if we're not in this situation since it's a hot path switch { case strings.HasPrefix(req.Path, "sys/wrapping/"), strings.HasPrefix(req.Path, "auth/token/"): // Get the token ns info; if we match the paths below we want to // swap in the token context (but keep the relative path) te := req.TokenEntry() newCtx := ctx if te != nil { ns, err := NamespaceByID(ctx, te.NamespaceID, c) if err != nil { c.Logger().Warn("error looking up namespace from the token's namespace ID", "error", err) return nil, err } if ns != nil { newCtx = namespace.ContextWithNamespace(ctx, ns) } } switch req.Path { // Route the token wrapping request to its respective sys NS case "sys/wrapping/lookup", "sys/wrapping/rewrap", "sys/wrapping/unwrap": ctx = newCtx // A lookup on a token that is about to expire returns nil, which means by the // time we can validate a wrapping token lookup will return nil since it will // be revoked after the call. So we have to do the validation here. valid, err := c.validateWrappingToken(ctx, req) if err != nil { return logical.ErrorResponse(fmt.Sprintf("error validating wrapping token: %s", err.Error())), logical.ErrPermissionDenied } if !valid { return nil, consts.ErrInvalidWrappingToken } // The -self paths have no meaning outside of the token NS, so // requests for these paths always go to the token NS case "auth/token/lookup-self", "auth/token/renew-self", "auth/token/revoke-self": ctx = newCtx returnRequestAuthToken = true // For the following operations, we can set the proper namespace context // using the token's embedded nsID if a relative path was provided. // The operation will still be gated by ACLs, which are checked later. case "auth/token/lookup", "auth/token/renew", "auth/token/revoke", "auth/token/revoke-orphan": token, ok := req.Data["token"] // If the token is not present (e.g. a bad request), break out and let the backend // handle the error if !ok { // If this is a token lookup request and if the token is not // explicitly provided, it will use the client token so we simply set // the context to the client token's context. if req.Path == "auth/token/lookup" { ctx = newCtx } break } if token == nil { return logical.ErrorResponse("invalid token"), logical.ErrPermissionDenied } // We don't care if the token is a server side consistent token or not. Either way, we're going // to be returning it for these paths instead of the short token stored in vault. requestBodyToken = token.(string) if IsSSCToken(token.(string)) { token, err = c.CheckSSCToken(ctx, token.(string), c.isLoginRequest(ctx, req), c.perfStandby) // If we receive an error from CheckSSCToken, we can assume the token is bad somehow, and the client // should receive a 403 bad token error like they do for all other invalid tokens, unless the error // specifies that we should forward the request or retry the request. if err != nil { if errors.Is(err, logical.ErrPerfStandbyPleaseForward) || errors.Is(err, logical.ErrMissingRequiredState) { return nil, err } return logical.ErrorResponse("bad token"), logical.ErrPermissionDenied } req.Data["token"] = token } _, nsID := namespace.SplitIDFromString(token.(string)) if nsID != "" { ns, err := NamespaceByID(ctx, nsID, c) if err != nil { c.Logger().Warn("error looking up namespace from the token's namespace ID", "error", err) return nil, err } if ns != nil { ctx = namespace.ContextWithNamespace(ctx, ns) } } } // The following relative sys/leases/ paths handles re-routing requests // to the proper namespace using the lease ID on applicable paths. case strings.HasPrefix(req.Path, "sys/leases/"): switch req.Path { // For the following operations, we can set the proper namespace context // using the lease's embedded nsID if a relative path was provided. // The operation will still be gated by ACLs, which are checked later. case "sys/leases/lookup", "sys/leases/renew", "sys/leases/revoke", "sys/leases/revoke-force": leaseID, ok := req.Data["lease_id"] // If lease ID is not present, break out and let the backend handle the error if !ok || leaseID == nil { break } _, nsID := namespace.SplitIDFromString(leaseID.(string)) if nsID != "" { ns, err := NamespaceByID(ctx, nsID, c) if err != nil { c.Logger().Warn("error looking up namespace from the lease's namespace ID", "error", err) return nil, err } if ns != nil { ctx = namespace.ContextWithNamespace(ctx, ns) } } } // Prevent any metrics requests to be forwarded from a standby node. // Instead, we return an error since we cannot be sure if we have an // active token store to validate the provided token. case strings.HasPrefix(req.Path, "sys/metrics"): if c.standby && !c.perfStandby { return nil, ErrCannotForwardLocalOnly } } ns, err = namespace.FromContext(ctx) if err != nil { return nil, errwrap.Wrapf("could not parse namespace from http context: {{err}}", err) } if !hasNamespaces(c) && ns.Path != "" { return nil, logical.CodedError(403, "namespaces feature not enabled") } walState := &logical.WALState{} ctx = logical.IndexStateContext(ctx, walState) var auth *logical.Auth if c.isLoginRequest(ctx, req) { resp, auth, err = c.handleLoginRequest(ctx, req) } else { resp, auth, err = c.handleRequest(ctx, req) } if err == nil && c.requestResponseCallback != nil { c.requestResponseCallback(c.router.MatchingBackend(ctx, req.Path), req, resp) } // If we saved the token in the request, we should return it in the response // data. if resp != nil && resp.Data != nil { if _, ok := resp.Data["error"]; !ok { if requestBodyToken != "" { resp.Data["id"] = requestBodyToken } else if returnRequestAuthToken && req.InboundSSCToken != "" { resp.Data["id"] = req.InboundSSCToken } } } if resp != nil && resp.Auth != nil && requestBodyToken != "" { // if a client token has already been set and the request body token's internal token // is equal to that value, then we can return the original request body token tok, _ := c.DecodeSSCToken(requestBodyToken) if resp.Auth.ClientToken == tok { resp.Auth.ClientToken = requestBodyToken } } // Ensure we don't leak internal data if resp != nil { if resp.Secret != nil { resp.Secret.InternalData = nil } if resp.Auth != nil { resp.Auth.InternalData = nil } } // We are wrapping if there is anything to wrap (not a nil response) and a // TTL was specified for the token. Errors on a call should be returned to // the caller, so wrapping is turned off if an error is hit and the error // is logged to the audit log. wrapping := resp != nil && err == nil && !resp.IsError() && resp.WrapInfo != nil && resp.WrapInfo.TTL != 0 && resp.WrapInfo.Token == "" if wrapping { cubbyResp, cubbyErr := c.wrapInCubbyhole(ctx, req, resp, auth) // If not successful, returns either an error response from the // cubbyhole backend or an error; if either is set, set resp and err to // those and continue so that that's what we audit log. Otherwise // finish the wrapping and audit log that. if cubbyResp != nil || cubbyErr != nil { resp = cubbyResp err = cubbyErr } else { wrappingResp := &logical.Response{ WrapInfo: resp.WrapInfo, Warnings: resp.Warnings, } resp = wrappingResp } } auditResp := resp // When unwrapping we want to log the actual response that will be written // out. We still want to return the raw value to avoid automatic updating // to any of it. if req.Path == "sys/wrapping/unwrap" && resp != nil && resp.Data != nil && resp.Data[logical.HTTPRawBody] != nil { // Decode the JSON if resp.Data[logical.HTTPRawBodyAlreadyJSONDecoded] != nil { delete(resp.Data, logical.HTTPRawBodyAlreadyJSONDecoded) } else { httpResp := &logical.HTTPResponse{} err := jsonutil.DecodeJSON(resp.Data[logical.HTTPRawBody].([]byte), httpResp) if err != nil { c.logger.Error("failed to unmarshal wrapped HTTP response for audit logging", "error", err) return nil, ErrInternalError } auditResp = logical.HTTPResponseToLogicalResponse(httpResp) } } var nonHMACReqDataKeys []string var nonHMACRespDataKeys []string entry := c.router.MatchingMountEntry(ctx, req.Path) if entry != nil { // Get and set ignored HMAC'd value. Reset those back to empty afterwards. if rawVals, ok := entry.synthesizedConfigCache.Load("audit_non_hmac_request_keys"); ok { nonHMACReqDataKeys = rawVals.([]string) } // Get and set ignored HMAC'd value. Reset those back to empty afterwards. if auditResp != nil { if rawVals, ok := entry.synthesizedConfigCache.Load("audit_non_hmac_response_keys"); ok { nonHMACRespDataKeys = rawVals.([]string) } } } // Create an audit trail of the response if !isControlGroupRun(req) { switch req.Path { case "sys/replication/dr/status", "sys/replication/performance/status", "sys/replication/status": default: logInput := &logical.LogInput{ Auth: auth, Request: req, Response: auditResp, OuterErr: err, NonHMACReqDataKeys: nonHMACReqDataKeys, NonHMACRespDataKeys: nonHMACRespDataKeys, } if auditErr := c.auditBroker.LogResponse(ctx, logInput, c.auditedHeaders); auditErr != nil { c.logger.Error("failed to audit response", "request_path", req.Path, "error", auditErr) return nil, ErrInternalError } } } if walState.LocalIndex != 0 || walState.ReplicatedIndex != 0 { walState.ClusterID = c.ClusterID() if walState.LocalIndex == 0 { if c.perfStandby { walState.LocalIndex = LastRemoteWAL(c) } else { walState.LocalIndex = LastWAL(c) } } if walState.ReplicatedIndex == 0 { if c.perfStandby { walState.ReplicatedIndex = LastRemoteUpstreamWAL(c) } else { walState.ReplicatedIndex = LastRemoteWAL(c) } } req.SetResponseState(walState) } return } func isControlGroupRun(req *logical.Request) bool { return req.ControlGroup != nil } func (c *Core) doRouting(ctx context.Context, req *logical.Request) (*logical.Response, error) { // If we're replicating and we get a read-only error from a backend, need to forward to primary resp, err := c.router.Route(ctx, req) if shouldForward(c, resp, err) { fwdResp, fwdErr := forward(ctx, c, req) if fwdErr != nil && err != logical.ErrReadOnly { // When handling the request locally, we got an error that // contained ErrReadOnly, but had additional information. // Since we've now forwarded this request and got _another_ // error, we should tell the user about both errors, so // they know about both. // // When there is no error from forwarding, the request // succeeded and so no additional context is necessary. When // the initial error here was only ErrReadOnly, it's likely // the plugin authors intended to forward this request // remotely anyway. repErr, ok := fwdErr.(*logical.ReplicationCodedError) if ok { fwdErr = &logical.ReplicationCodedError{ Msg: fmt.Sprintf("errors from both primary and secondary; primary error was %s; secondary errors follow: %s", repErr.Error(), err.Error()), Code: repErr.Code, } } else { fwdErr = multierror.Append(fwdErr, err) } } return fwdResp, fwdErr } return resp, err } func (c *Core) isLoginRequest(ctx context.Context, req *logical.Request) bool { return c.router.LoginPath(ctx, req.Path) } func (c *Core) handleRequest(ctx context.Context, req *logical.Request) (retResp *logical.Response, retAuth *logical.Auth, retErr error) { defer metrics.MeasureSince([]string{"core", "handle_request"}, time.Now()) var nonHMACReqDataKeys []string entry := c.router.MatchingMountEntry(ctx, req.Path) if entry != nil { // Set here so the audit log has it even if authorization fails req.MountType = entry.Type req.SetMountRunningSha256(entry.RunningSha256) req.SetMountRunningVersion(entry.RunningVersion) req.SetMountIsExternalPlugin(entry.IsExternalPlugin()) req.SetMountClass(entry.MountClass()) // Get and set ignored HMAC'd value. if rawVals, ok := entry.synthesizedConfigCache.Load("audit_non_hmac_request_keys"); ok { nonHMACReqDataKeys = rawVals.([]string) } } ns, err := namespace.FromContext(ctx) if err != nil { c.logger.Error("failed to get namespace from context", "error", err) retErr = multierror.Append(retErr, ErrInternalError) return } // Validate the token auth, te, ctErr := c.CheckToken(ctx, req, false) if ctErr == logical.ErrRelativePath { return logical.ErrorResponse(ctErr.Error()), nil, ctErr } if ctErr == logical.ErrPerfStandbyPleaseForward { return nil, nil, ctErr } // Updating in-flight request data with client/entity ID inFlightReqID, ok := ctx.Value(logical.CtxKeyInFlightRequestID{}).(string) if ok && req.ClientID != "" { c.UpdateInFlightReqData(inFlightReqID, req.ClientID) } // We run this logic first because we want to decrement the use count even // in the case of an error (assuming we can successfully look up; if we // need to forward, we exit before now) if te != nil && !isControlGroupRun(req) { // Attempt to use the token (decrement NumUses) var err error te, err = c.tokenStore.UseToken(ctx, te) if err != nil { c.logger.Error("failed to use token", "error", err) retErr = multierror.Append(retErr, ErrInternalError) return nil, nil, retErr } if te == nil { // Token has been revoked by this point retErr = multierror.Append(retErr, logical.ErrPermissionDenied) return nil, nil, retErr } if te.NumUses == tokenRevocationPending { // We defer a revocation until after logic has run, since this is a // valid request (this is the token's final use). We pass the ID in // directly just to be safe in case something else modifies te later. defer func(id string) { nsActiveCtx := namespace.ContextWithNamespace(c.activeContext, ns) leaseID, err := c.expiration.CreateOrFetchRevocationLeaseByToken(nsActiveCtx, te) if err == nil { err = c.expiration.LazyRevoke(ctx, leaseID) } if err != nil { c.logger.Error("failed to revoke token", "error", err) retResp = nil retAuth = nil retErr = multierror.Append(retErr, ErrInternalError) } if retResp != nil && retResp.Secret != nil && // Some backends return a TTL even without a Lease ID retResp.Secret.LeaseID != "" { retResp = logical.ErrorResponse("Secret cannot be returned; token had one use left, so leased credentials were immediately revoked.") return } }(te.ID) } } if ctErr != nil { newCtErr, cgResp, cgAuth, cgRetErr := checkNeedsCG(ctx, c, req, auth, ctErr, nonHMACReqDataKeys) switch { case newCtErr != nil: ctErr = newCtErr case cgResp != nil || cgAuth != nil: if cgRetErr != nil { retErr = multierror.Append(retErr, cgRetErr) } return cgResp, cgAuth, retErr } // If it is an internal error we return that, otherwise we // return invalid request so that the status codes can be correct switch { case ctErr == ErrInternalError, errwrap.Contains(ctErr, ErrInternalError.Error()), ctErr == logical.ErrPermissionDenied, errwrap.Contains(ctErr, logical.ErrPermissionDenied.Error()): switch ctErr.(type) { case *multierror.Error: retErr = ctErr default: retErr = multierror.Append(retErr, ctErr) } default: retErr = multierror.Append(retErr, logical.ErrInvalidRequest) } if !isControlGroupRun(req) { logInput := &logical.LogInput{ Auth: auth, Request: req, OuterErr: ctErr, NonHMACReqDataKeys: nonHMACReqDataKeys, } if err := c.auditBroker.LogRequest(ctx, logInput, c.auditedHeaders); err != nil { c.logger.Error("failed to audit request", "path", req.Path, "error", err) } } if errwrap.Contains(retErr, ErrInternalError.Error()) { return nil, auth, retErr } return logical.ErrorResponse(ctErr.Error()), auth, retErr } // Attach the display name req.DisplayName = auth.DisplayName // Create an audit trail of the request if !isControlGroupRun(req) { logInput := &logical.LogInput{ Auth: auth, Request: req, NonHMACReqDataKeys: nonHMACReqDataKeys, } if err := c.auditBroker.LogRequest(ctx, logInput, c.auditedHeaders); err != nil { c.logger.Error("failed to audit request", "path", req.Path, "error", err) retErr = multierror.Append(retErr, ErrInternalError) return nil, auth, retErr } } if err := enterpriseBlockRequestIfError(c, ns.Path, req.Path); err != nil { return nil, nil, multierror.Append(retErr, err) } leaseGenerated := false quotaResp, quotaErr := c.applyLeaseCountQuota(ctx, "as.Request{ Path: req.Path, MountPath: strings.TrimPrefix(req.MountPoint, ns.Path), NamespacePath: ns.Path, }) if quotaErr != nil { c.logger.Error("failed to apply quota", "path", req.Path, "error", quotaErr) retErr = multierror.Append(retErr, quotaErr) return nil, auth, retErr } if !quotaResp.Allowed { if c.logger.IsTrace() { c.logger.Trace("request rejected due to lease count quota violation", "request_path", req.Path) } retErr = multierror.Append(retErr, fmt.Errorf("request path %q: %w", req.Path, quotas.ErrLeaseCountQuotaExceeded)) return nil, auth, retErr } defer func() { if quotaResp.Access != nil { quotaAckErr := c.ackLeaseQuota(quotaResp.Access, leaseGenerated) if quotaAckErr != nil { retErr = multierror.Append(retErr, quotaAckErr) } } }() // Route the request resp, routeErr := c.doRouting(ctx, req) if resp != nil { // If wrapping is used, use the shortest between the request and response var wrapTTL time.Duration var wrapFormat, creationPath string var sealWrap bool // Ensure no wrap info information is set other than, possibly, the TTL if resp.WrapInfo != nil { if resp.WrapInfo.TTL > 0 { wrapTTL = resp.WrapInfo.TTL } wrapFormat = resp.WrapInfo.Format creationPath = resp.WrapInfo.CreationPath sealWrap = resp.WrapInfo.SealWrap resp.WrapInfo = nil } if req.WrapInfo != nil { if req.WrapInfo.TTL > 0 { switch { case wrapTTL == 0: wrapTTL = req.WrapInfo.TTL case req.WrapInfo.TTL < wrapTTL: wrapTTL = req.WrapInfo.TTL } } // If the wrap format hasn't been set by the response, set it to // the request format if req.WrapInfo.Format != "" && wrapFormat == "" { wrapFormat = req.WrapInfo.Format } } if wrapTTL > 0 { resp.WrapInfo = &wrapping.ResponseWrapInfo{ TTL: wrapTTL, Format: wrapFormat, CreationPath: creationPath, SealWrap: sealWrap, } } } // If there is a secret, we must register it with the expiration manager. // We exclude renewal of a lease, since it does not need to be re-registered if resp != nil && resp.Secret != nil && !strings.HasPrefix(req.Path, "sys/renew") && !strings.HasPrefix(req.Path, "sys/leases/renew") { // KV mounts should return the TTL but not register // for a lease as this provides a massive slowdown registerLease := true matchingMountEntry := c.router.MatchingMountEntry(ctx, req.Path) if matchingMountEntry == nil { c.logger.Error("unable to retrieve kv mount entry from router") retErr = multierror.Append(retErr, ErrInternalError) return nil, auth, retErr } switch matchingMountEntry.Type { case "kv", "generic": // If we are kv type, first see if we are an older passthrough // backend, and otherwise check the mount entry options. matchingBackend := c.router.MatchingBackend(ctx, req.Path) if matchingBackend == nil { c.logger.Error("unable to retrieve kv backend from router") retErr = multierror.Append(retErr, ErrInternalError) return nil, auth, retErr } if ptbe, ok := matchingBackend.(*PassthroughBackend); ok { if !ptbe.GeneratesLeases() { registerLease = false resp.Secret.Renewable = false } } else if matchingMountEntry.Options == nil || matchingMountEntry.Options["leased_passthrough"] != "true" { registerLease = false resp.Secret.Renewable = false } case "plugin": // If we are a plugin type and the plugin name is "kv" check the // mount entry options. if matchingMountEntry.Config.PluginName == "kv" && (matchingMountEntry.Options == nil || matchingMountEntry.Options["leased_passthrough"] != "true") { registerLease = false resp.Secret.Renewable = false } } if registerLease { sysView := c.router.MatchingSystemView(ctx, req.Path) if sysView == nil { c.logger.Error("unable to look up sys view for login path", "request_path", req.Path) return nil, nil, ErrInternalError } ttl, warnings, err := framework.CalculateTTL(sysView, 0, resp.Secret.TTL, 0, resp.Secret.MaxTTL, 0, time.Time{}) if err != nil { return nil, nil, err } for _, warning := range warnings { resp.AddWarning(warning) } resp.Secret.TTL = ttl registerFunc, funcGetErr := getLeaseRegisterFunc(c) if funcGetErr != nil { retErr = multierror.Append(retErr, funcGetErr) return nil, auth, retErr } leaseID, err := registerFunc(ctx, req, resp, "") if err != nil { c.logger.Error("failed to register lease", "request_path", req.Path, "error", err) retErr = multierror.Append(retErr, ErrInternalError) return nil, auth, retErr } leaseGenerated = true resp.Secret.LeaseID = leaseID // Count the lease creation ttl_label := metricsutil.TTLBucket(resp.Secret.TTL) mountPointWithoutNs := ns.TrimmedPath(req.MountPoint) c.MetricSink().IncrCounterWithLabels( []string{"secret", "lease", "creation"}, 1, []metrics.Label{ metricsutil.NamespaceLabel(ns), {"secret_engine", req.MountType}, {"mount_point", mountPointWithoutNs}, {"creation_ttl", ttl_label}, }, ) } } // Only the token store is allowed to return an auth block, for any // other request this is an internal error. if resp != nil && resp.Auth != nil { if !strings.HasPrefix(req.Path, "auth/token/") { c.logger.Error("unexpected Auth response for non-token backend", "request_path", req.Path) retErr = multierror.Append(retErr, ErrInternalError) return nil, auth, retErr } // Fetch the namespace to which the token belongs tokenNS, err := NamespaceByID(ctx, te.NamespaceID, c) if err != nil { c.logger.Error("failed to fetch token's namespace", "error", err) retErr = multierror.Append(retErr, err) return nil, auth, retErr } if tokenNS == nil { c.logger.Error(namespace.ErrNoNamespace.Error()) retErr = multierror.Append(retErr, namespace.ErrNoNamespace) return nil, auth, retErr } _, identityPolicies, err := c.fetchEntityAndDerivedPolicies(ctx, tokenNS, resp.Auth.EntityID, false) if err != nil { // Best-effort clean up on error, so we log the cleanup error as a // warning but still return as internal error. if err := c.tokenStore.revokeOrphan(ctx, resp.Auth.ClientToken); err != nil { c.logger.Warn("failed to clean up token lease from entity and policy lookup failure", "request_path", req.Path, "error", err) } return nil, nil, ErrInternalError } // We skip expiration manager registration for token renewal since it // does not need to be re-registered if strings.HasPrefix(req.Path, "auth/token/renew") { // We build the "policies" list to be returned by starting with // token policies, and add identity policies right after this // conditional tok, _ := c.DecodeSSCToken(req.InboundSSCToken) if resp.Auth.ClientToken == tok { resp.Auth.ClientToken = req.InboundSSCToken } resp.Auth.Policies = policyutil.SanitizePolicies(resp.Auth.TokenPolicies, policyutil.DoNotAddDefaultPolicy) } else { resp.Auth.TokenPolicies = policyutil.SanitizePolicies(resp.Auth.Policies, policyutil.DoNotAddDefaultPolicy) switch resp.Auth.TokenType { case logical.TokenTypeBatch: case logical.TokenTypeService: if !c.perfStandby { registeredTokenEntry := &logical.TokenEntry{ TTL: auth.TTL, Policies: auth.TokenPolicies, Path: resp.Auth.CreationPath, NamespaceID: ns.ID, } // Only logins apply to role based quotas, so we can omit the role here, as we are not logging in. if err := c.expiration.RegisterAuth(ctx, registeredTokenEntry, resp.Auth, ""); err != nil { // Best-effort clean up on error, so we log the cleanup error as // a warning but still return as internal error. if err := c.tokenStore.revokeOrphan(ctx, resp.Auth.ClientToken); err != nil { c.logger.Warn("failed to clean up token lease during auth/token/ request", "request_path", req.Path, "error", err) } c.logger.Error("failed to register token lease during auth/token/ request", "request_path", req.Path, "error", err) retErr = multierror.Append(retErr, ErrInternalError) return nil, auth, retErr } if registeredTokenEntry.ExternalID != "" { resp.Auth.ClientToken = registeredTokenEntry.ExternalID } leaseGenerated = true } } } // We do these later since it's not meaningful for backends/expmgr to // have what is purely a snapshot of current identity policies, and // plugins can be confused if they are checking contents of // Auth.Policies instead of Auth.TokenPolicies resp.Auth.Policies = policyutil.SanitizePolicies(append(resp.Auth.Policies, identityPolicies[te.NamespaceID]...), policyutil.DoNotAddDefaultPolicy) resp.Auth.IdentityPolicies = policyutil.SanitizePolicies(identityPolicies[te.NamespaceID], policyutil.DoNotAddDefaultPolicy) delete(identityPolicies, te.NamespaceID) resp.Auth.ExternalNamespacePolicies = identityPolicies } if resp != nil && req.Path == "cubbyhole/response" && len(te.Policies) == 1 && te.Policies[0] == responseWrappingPolicyName { resp.AddWarning("Reading from 'cubbyhole/response' is deprecated. Please use sys/wrapping/unwrap to unwrap responses, as it provides additional security checks and other benefits.") } // Return the response and error if routeErr != nil { retErr = multierror.Append(retErr, routeErr) } return resp, auth, retErr } // handleLoginRequest is used to handle a login request, which is an // unauthenticated request to the backend. func (c *Core) handleLoginRequest(ctx context.Context, req *logical.Request) (retResp *logical.Response, retAuth *logical.Auth, retErr error) { defer metrics.MeasureSince([]string{"core", "handle_login_request"}, time.Now()) req.Unauthenticated = true var nonHMACReqDataKeys []string entry := c.router.MatchingMountEntry(ctx, req.Path) if entry != nil { // Set here so the audit log has it even if authorization fails req.MountType = entry.Type req.SetMountRunningSha256(entry.RunningSha256) req.SetMountRunningVersion(entry.RunningVersion) req.SetMountIsExternalPlugin(entry.IsExternalPlugin()) req.SetMountClass(entry.MountClass()) // Get and set ignored HMAC'd value. if rawVals, ok := entry.synthesizedConfigCache.Load("audit_non_hmac_request_keys"); ok { nonHMACReqDataKeys = rawVals.([]string) } } // Do an unauth check. This will cause EGP policies to be checked var auth *logical.Auth var ctErr error auth, _, ctErr = c.CheckToken(ctx, req, true) if ctErr == logical.ErrPerfStandbyPleaseForward { return nil, nil, ctErr } // Updating in-flight request data with client/entity ID inFlightReqID, ok := ctx.Value(logical.CtxKeyInFlightRequestID{}).(string) if ok && req.ClientID != "" { c.UpdateInFlightReqData(inFlightReqID, req.ClientID) } if ctErr != nil { // If it is an internal error we return that, otherwise we // return invalid request so that the status codes can be correct var errType error switch ctErr { case ErrInternalError, logical.ErrPermissionDenied: errType = ctErr default: errType = logical.ErrInvalidRequest } logInput := &logical.LogInput{ Auth: auth, Request: req, OuterErr: ctErr, NonHMACReqDataKeys: nonHMACReqDataKeys, } if err := c.auditBroker.LogRequest(ctx, logInput, c.auditedHeaders); err != nil { c.logger.Error("failed to audit request", "path", req.Path, "error", err) return nil, nil, ErrInternalError } if errType != nil { retErr = multierror.Append(retErr, errType) } if ctErr == ErrInternalError { return nil, auth, retErr } return logical.ErrorResponse(ctErr.Error()), auth, retErr } switch req.Path { case "sys/replication/dr/status", "sys/replication/performance/status", "sys/replication/status": default: // Create an audit trail of the request. Attach auth if it was returned, // e.g. if a token was provided. logInput := &logical.LogInput{ Auth: auth, Request: req, NonHMACReqDataKeys: nonHMACReqDataKeys, } if err := c.auditBroker.LogRequest(ctx, logInput, c.auditedHeaders); err != nil { c.logger.Error("failed to audit request", "path", req.Path, "error", err) return nil, nil, ErrInternalError } } // The token store uses authentication even when creating a new token, // so it's handled in handleRequest. It should not be reached here. if strings.HasPrefix(req.Path, "auth/token/") { c.logger.Error("unexpected login request for token backend", "request_path", req.Path) return nil, nil, ErrInternalError } // check if user lockout feature is disabled isUserLockoutDisabled, err := c.isUserLockoutDisabled(entry) if err != nil { return nil, nil, err } // if user lockout feature is not disabled, check if the user is locked if !isUserLockoutDisabled { isloginUserLocked, err := c.isUserLocked(ctx, entry, req) if err != nil { return nil, nil, err } if isloginUserLocked { return nil, nil, logical.ErrPermissionDenied } } // Route the request resp, routeErr := c.doRouting(ctx, req) // if routeErr has invalid credentials error, update the userFailedLoginMap if routeErr != nil && routeErr == logical.ErrInvalidCredentials { if !isUserLockoutDisabled { err := c.failedUserLoginProcess(ctx, entry, req) if err != nil { return nil, nil, err } } return resp, nil, routeErr } if resp != nil { // If wrapping is used, use the shortest between the request and response var wrapTTL time.Duration var wrapFormat, creationPath string var sealWrap bool // Ensure no wrap info information is set other than, possibly, the TTL if resp.WrapInfo != nil { if resp.WrapInfo.TTL > 0 { wrapTTL = resp.WrapInfo.TTL } wrapFormat = resp.WrapInfo.Format creationPath = resp.WrapInfo.CreationPath sealWrap = resp.WrapInfo.SealWrap resp.WrapInfo = nil } if req.WrapInfo != nil { if req.WrapInfo.TTL > 0 { switch { case wrapTTL == 0: wrapTTL = req.WrapInfo.TTL case req.WrapInfo.TTL < wrapTTL: wrapTTL = req.WrapInfo.TTL } } if req.WrapInfo.Format != "" && wrapFormat == "" { wrapFormat = req.WrapInfo.Format } } if wrapTTL > 0 { resp.WrapInfo = &wrapping.ResponseWrapInfo{ TTL: wrapTTL, Format: wrapFormat, CreationPath: creationPath, SealWrap: sealWrap, } } } // A login request should never return a secret! if resp != nil && resp.Secret != nil { c.logger.Error("unexpected Secret response for login path", "request_path", req.Path) return nil, nil, ErrInternalError } ns, err := namespace.FromContext(ctx) if err != nil { c.logger.Error("failed to get namespace from context", "error", err) retErr = multierror.Append(retErr, ErrInternalError) return } // If the response generated an authentication, then generate the token if resp != nil && resp.Auth != nil && req.Path != "sys/mfa/validate" { leaseGenerated := false // by placing this after the authorization check, we don't leak // information about locked namespaces to unauthenticated clients. if err := enterpriseBlockRequestIfError(c, ns.Path, req.Path); err != nil { retErr = multierror.Append(retErr, err) return } // Check for request role in context to role based quotas var role string reqRole := ctx.Value(logical.CtxKeyRequestRole{}) if reqRole != nil { role = reqRole.(string) } // The request successfully authenticated itself. Run the quota checks // before creating lease. quotaResp, quotaErr := c.applyLeaseCountQuota(ctx, "as.Request{ Path: req.Path, MountPath: strings.TrimPrefix(req.MountPoint, ns.Path), Role: role, NamespacePath: ns.Path, }) if quotaErr != nil { c.logger.Error("failed to apply quota", "path", req.Path, "error", quotaErr) retErr = multierror.Append(retErr, quotaErr) return } if !quotaResp.Allowed { if c.logger.IsTrace() { c.logger.Trace("request rejected due to lease count quota violation", "request_path", req.Path) } retErr = multierror.Append(retErr, fmt.Errorf("request path %q: %w", req.Path, quotas.ErrLeaseCountQuotaExceeded)) return } defer func() { if quotaResp.Access != nil { quotaAckErr := c.ackLeaseQuota(quotaResp.Access, leaseGenerated) if quotaAckErr != nil { retErr = multierror.Append(retErr, quotaAckErr) } } }() var entity *identity.Entity auth = resp.Auth mEntry := c.router.MatchingMountEntry(ctx, req.Path) if auth.Alias != nil && mEntry != nil && c.identityStore != nil { if mEntry.Local && os.Getenv(EnvVaultDisableLocalAuthMountEntities) != "" { goto CREATE_TOKEN } // Overwrite the mount type and mount path in the alias // information auth.Alias.MountType = req.MountType auth.Alias.MountAccessor = req.MountAccessor auth.Alias.Local = mEntry.Local if auth.Alias.Name == "" { return nil, nil, fmt.Errorf("missing name in alias") } var err error // Fetch the entity for the alias, or create an entity if one // doesn't exist. entity, entityCreated, err := c.identityStore.CreateOrFetchEntity(ctx, auth.Alias) if err != nil { switch auth.Alias.Local { case true: // Only create a new entity if the error was a readonly error and the creation flag is true // i.e the entity was in the middle of being created if entityCreated && errors.Is(err, logical.ErrReadOnly) { entity, err = possiblyForwardEntityCreation(ctx, c, err, auth, nil) if err != nil { if strings.Contains(err.Error(), errCreateEntityUnimplemented) { resp.AddWarning("primary cluster doesn't yet issue entities for local auth mounts; falling back to not issuing entities for local auth mounts") goto CREATE_TOKEN } else { return nil, nil, err } } } err = updateLocalAlias(ctx, c, auth, entity) default: entity, entityCreated, err = possiblyForwardAliasCreation(ctx, c, err, auth, entity) } } if err != nil { return nil, nil, err } if entity == nil { return nil, nil, fmt.Errorf("failed to create an entity for the authenticated alias") } if entity.Disabled { return nil, nil, logical.ErrPermissionDenied } auth.EntityID = entity.ID auth.EntityCreated = entityCreated validAliases, err := c.identityStore.refreshExternalGroupMembershipsByEntityID(ctx, auth.EntityID, auth.GroupAliases, req.MountAccessor) if err != nil { return nil, nil, err } auth.GroupAliases = validAliases } CREATE_TOKEN: // Determine the source of the login source := c.router.MatchingMount(ctx, req.Path) // Login MFA entity, _, err := c.fetchEntityAndDerivedPolicies(ctx, ns, auth.EntityID, true) if err != nil { return nil, nil, ErrInternalError } // finding the MFAEnforcementConfig that matches the ns and either of // entityID, MountAccessor, GroupID, or Auth type. matchedMfaEnforcementList, err := c.buildMFAEnforcementConfigList(ctx, entity, req.Path) if err != nil { return nil, nil, fmt.Errorf("failed to find MFAEnforcement configuration, error: %v", err) } // (for the context, a response warning above says: "primary cluster // doesn't yet issue entities for local auth mounts; falling back // to not issuing entities for local auth mounts") // based on the above, if the entity is nil, check if MFAEnforcementConfig // is configured or not. If not, continue as usual, but if there // is something, then report an error indicating that the user is not // allowed to login because there is no entity associated with it. // This is because an entity is needed to enforce MFA. if entity == nil && len(matchedMfaEnforcementList) > 0 { // this logic means that an MFAEnforcementConfig was configured with // only mount type or mount accessor return nil, nil, logical.ErrPermissionDenied } // The resp.Auth has been populated with the information that is required for MFA validation // This is why, the MFA check is placed at this point. The resp.Auth is going to be fully cached // in memory so that it would be used to return to the user upon MFA validation is completed. if entity != nil { if len(matchedMfaEnforcementList) == 0 && len(req.MFACreds) > 0 { resp.AddWarning("Found MFA header but failed to find MFA Enforcement Config") } // If X-Vault-MFA header is supplied to the login request, // run single-phase login MFA check, else run two-phase login MFA check if len(matchedMfaEnforcementList) > 0 && len(req.MFACreds) > 0 { for _, eConfig := range matchedMfaEnforcementList { err = c.validateLoginMFA(ctx, eConfig, entity, req.Connection.RemoteAddr, req.MFACreds) if err != nil { return nil, nil, logical.ErrPermissionDenied } } } else if len(matchedMfaEnforcementList) > 0 && len(req.MFACreds) == 0 { mfaRequestID, err := uuid.GenerateUUID() if err != nil { return nil, nil, err } // sending back the MFARequirement config mfaRequirement := &logical.MFARequirement{ MFARequestID: mfaRequestID, MFAConstraints: make(map[string]*logical.MFAConstraintAny), } for _, eConfig := range matchedMfaEnforcementList { mfaAny, err := c.buildMfaEnforcementResponse(eConfig) if err != nil { return nil, nil, err } mfaRequirement.MFAConstraints[eConfig.Name] = mfaAny } // for two phased MFA enforcement, we should not return the regular auth // response. This flag is indicate to store the auth response for later // and return MFARequirement only respAuth := &MFACachedAuthResponse{ CachedAuth: resp.Auth, RequestPath: req.Path, RequestNSID: ns.ID, RequestNSPath: ns.Path, RequestConnRemoteAddr: req.Connection.RemoteAddr, // this is needed for the DUO method TimeOfStorage: time.Now(), RequestID: mfaRequestID, } err = possiblyForwardSaveCachedAuthResponse(ctx, c, respAuth) if err != nil { return nil, nil, err } auth = nil resp.Auth = &logical.Auth{ MFARequirement: mfaRequirement, } resp.AddWarning("A login request was issued that is subject to MFA validation. Please make sure to validate the login by sending another request to mfa/validate endpoint.") // going to return early before generating the token // the user receives the mfaRequirement, and need to use the // login MFA validate endpoint to get the token return resp, auth, nil } } // Attach the display name, might be used by audit backends req.DisplayName = auth.DisplayName requiresLease := resp.Auth.TokenType != logical.TokenTypeBatch // If role was not already determined by http.rateLimitQuotaWrapping // and a lease will be generated, calculate a role for the leaseEntry. // We can skip this step if there are no pre-existing role-based quotas // for this mount and Vault is configured to skip lease role-based lease counting // until after they're created. This effectively zeroes out the lease count // for new role-based quotas upon creation, rather than counting old leases toward // the total. if reqRole == nil && requiresLease && !c.impreciseLeaseRoleTracking { role = c.DetermineRoleFromLoginRequest(ctx, req.MountPoint, req.Data) } leaseGen, respTokenCreate, errCreateToken := c.LoginCreateToken(ctx, ns, req.Path, source, role, resp) leaseGenerated = leaseGen if errCreateToken != nil { return respTokenCreate, nil, errCreateToken } resp = respTokenCreate } // Successful login, remove any entry from userFailedLoginInfo map // if it exists. This is done for batch tokens (for oss & ent) // For service tokens on oss it is taken care by core RegisterAuth function. // For service tokens on ent it is taken care by registerAuth RPC calls. // This update is done as part of registerAuth of RPC calls from standby // to active node. This is added there to reduce RPC calls if !isUserLockoutDisabled && (auth.TokenType == logical.TokenTypeBatch) { loginUserInfoKey := FailedLoginUser{ aliasName: auth.Alias.Name, mountAccessor: auth.Alias.MountAccessor, } // We don't need to try to delete the lockedUsers storage entry, since we're // processing a login request. If a login attempt is allowed, it means the user is // unlocked and we only add storage entry when the user gets locked. err = updateUserFailedLoginInfo(ctx, c, loginUserInfoKey, nil, true) if err != nil { return nil, nil, err } } // if we were already going to return some error from this login, do that. // if not, we will then check if the API is locked for the requesting // namespace, to avoid leaking locked namespaces to unauthenticated clients. if resp != nil && resp.Data != nil { if _, ok := resp.Data["error"]; ok { return resp, auth, routeErr } } if routeErr != nil { return resp, auth, routeErr } // this check handles the bad login credential case if err := enterpriseBlockRequestIfError(c, ns.Path, req.Path); err != nil { return nil, nil, multierror.Append(retErr, err) } return resp, auth, routeErr } // LoginCreateToken creates a token as a result of a login request. // If MFA is enforced, mfa/validate endpoint calls this functions // after successful MFA validation to generate the token. func (c *Core) LoginCreateToken(ctx context.Context, ns *namespace.Namespace, reqPath, mountPoint, role string, resp *logical.Response) (bool, *logical.Response, error) { auth := resp.Auth source := strings.TrimPrefix(mountPoint, credentialRoutePrefix) source = strings.ReplaceAll(source, "/", "-") // Prepend the source to the display name auth.DisplayName = strings.TrimSuffix(source+auth.DisplayName, "-") // Determine mount type mountEntry := c.router.MatchingMountEntry(ctx, reqPath) if mountEntry == nil { return false, nil, fmt.Errorf("failed to find a matching mount") } sysView := c.router.MatchingSystemView(ctx, reqPath) if sysView == nil { c.logger.Error("unable to look up sys view for login path", "request_path", reqPath) return false, nil, ErrInternalError } tokenTTL, warnings, err := framework.CalculateTTL(sysView, 0, auth.TTL, auth.Period, auth.MaxTTL, auth.ExplicitMaxTTL, time.Time{}) if err != nil { return false, nil, err } for _, warning := range warnings { resp.AddWarning(warning) } _, identityPolicies, err := c.fetchEntityAndDerivedPolicies(ctx, ns, auth.EntityID, false) if err != nil { return false, nil, ErrInternalError } auth.TokenPolicies = policyutil.SanitizePolicies(auth.Policies, !auth.NoDefaultPolicy) allPolicies := policyutil.SanitizePolicies(append(auth.TokenPolicies, identityPolicies[ns.ID]...), policyutil.DoNotAddDefaultPolicy) // Prevent internal policies from being assigned to tokens. We check // this on auth.Policies including derived ones from Identity before // actually making the token. for _, policy := range allPolicies { if policy == "root" { return false, logical.ErrorResponse("auth methods cannot create root tokens"), logical.ErrInvalidRequest } if strutil.StrListContains(nonAssignablePolicies, policy) { return false, logical.ErrorResponse(fmt.Sprintf("cannot assign policy %q", policy)), logical.ErrInvalidRequest } } var registerFunc RegisterAuthFunc var funcGetErr error // Batch tokens should not be forwarded to perf standby if auth.TokenType == logical.TokenTypeBatch { registerFunc = c.RegisterAuth } else { registerFunc, funcGetErr = getAuthRegisterFunc(c) } if funcGetErr != nil { return false, nil, funcGetErr } leaseGenerated := false err = registerFunc(ctx, tokenTTL, reqPath, auth, role) switch { case err == nil: if auth.TokenType != logical.TokenTypeBatch { leaseGenerated = true } case err == ErrInternalError: return false, nil, err default: return false, logical.ErrorResponse(err.Error()), logical.ErrInvalidRequest } auth.IdentityPolicies = policyutil.SanitizePolicies(identityPolicies[ns.ID], policyutil.DoNotAddDefaultPolicy) delete(identityPolicies, ns.ID) auth.ExternalNamespacePolicies = identityPolicies auth.Policies = allPolicies // Count the successful token creation ttl_label := metricsutil.TTLBucket(tokenTTL) // Do not include namespace path in mount point; already present as separate label. mountPointWithoutNs := ns.TrimmedPath(mountPoint) c.metricSink.IncrCounterWithLabels( []string{"token", "creation"}, 1, []metrics.Label{ metricsutil.NamespaceLabel(ns), {"auth_method", mountEntry.Type}, {"mount_point", mountPointWithoutNs}, {"creation_ttl", ttl_label}, {"token_type", auth.TokenType.String()}, }, ) return leaseGenerated, resp, nil } // failedUserLoginProcess updates the userFailedLoginMap with login count and last failed // login time for users with failed login attempt // If the user gets locked for current login attempt, it updates the storage entry too func (c *Core) failedUserLoginProcess(ctx context.Context, mountEntry *MountEntry, req *logical.Request) error { // get the user lockout configuration for the user userLockoutConfiguration := c.getUserLockoutConfiguration(mountEntry) // determine the key for userFailedLoginInfo map loginUserInfoKey, err := c.getLoginUserInfoKey(ctx, mountEntry, req) if err != nil { return err } // get entry from userFailedLoginInfo map for the key userFailedLoginInfo, err := getUserFailedLoginInfo(ctx, c, loginUserInfoKey) if err != nil { return err } // update the last failed login time with current time failedLoginInfo := FailedLoginInfo{ lastFailedLoginTime: int(time.Now().Unix()), } // set the failed login count value for the entry in userFailedLoginInfo map switch userFailedLoginInfo { case nil: // entry does not exist in userfailedLoginMap failedLoginInfo.count = 1 default: failedLoginInfo.count = userFailedLoginInfo.count + 1 // if counter reset, set the count value to 1 as this gets counted as new entry lastFailedLoginTime := time.Unix(int64(userFailedLoginInfo.lastFailedLoginTime), 0) counterResetDuration := userLockoutConfiguration.LockoutCounterReset if time.Now().After(lastFailedLoginTime.Add(counterResetDuration)) { failedLoginInfo.count = 1 } } // update the userFailedLoginInfo map (and/or storage) with the updated/new entry err = updateUserFailedLoginInfo(ctx, c, loginUserInfoKey, &failedLoginInfo, false) if err != nil { return err } return nil } // getLoginUserInfoKey gets failedUserLoginInfo map key for login user func (c *Core) getLoginUserInfoKey(ctx context.Context, mountEntry *MountEntry, req *logical.Request) (FailedLoginUser, error) { userInfo := FailedLoginUser{} aliasName, err := c.aliasNameFromLoginRequest(ctx, req) if err != nil { return userInfo, err } if aliasName == "" { return userInfo, errors.New("failed to determine alias name from login request") } userInfo.aliasName = aliasName userInfo.mountAccessor = mountEntry.Accessor return userInfo, nil } // isUserLockoutDisabled checks if user lockout feature to prevent brute forcing is disabled // Auth types userpass, ldap and approle support this feature // precedence: environment var setting >> auth tune setting >> config file setting >> default (enabled) func (c *Core) isUserLockoutDisabled(mountEntry *MountEntry) (bool, error) { if !strutil.StrListContains(configutil.GetSupportedUserLockoutsAuthMethods(), mountEntry.Type) { return true, nil } // check environment variable if disableUserLockoutEnv := os.Getenv(consts.VaultDisableUserLockout); disableUserLockoutEnv != "" { var err error disableUserLockout, err := strconv.ParseBool(disableUserLockoutEnv) if err != nil { return false, errors.New("Error parsing the environment variable VAULT_DISABLE_USER_LOCKOUT") } if disableUserLockout { return true, nil } return false, nil } // read auth tune for mount entry userLockoutConfigFromMount := mountEntry.Config.UserLockoutConfig if userLockoutConfigFromMount != nil && userLockoutConfigFromMount.DisableLockout { return true, nil } // read config for auth type from config file userLockoutConfiguration := c.getUserLockoutFromConfig(mountEntry.Type) if userLockoutConfiguration.DisableLockout { return true, nil } // default return false, nil } // isUserLocked determines if the login user is locked func (c *Core) isUserLocked(ctx context.Context, mountEntry *MountEntry, req *logical.Request) (locked bool, err error) { // get userFailedLoginInfo map key for login user loginUserInfoKey, err := c.getLoginUserInfoKey(ctx, mountEntry, req) if err != nil { return false, err } // get entry from userFailedLoginInfo map for the key userFailedLoginInfo, err := getUserFailedLoginInfo(ctx, c, loginUserInfoKey) if err != nil { return false, err } userLockoutConfiguration := c.getUserLockoutConfiguration(mountEntry) switch userFailedLoginInfo { case nil: // entry not found in userFailedLoginInfo map, check storage to re-verify ns, err := namespace.FromContext(ctx) if err != nil { return false, fmt.Errorf("could not parse namespace from http context: %w", err) } storageUserLockoutPath := fmt.Sprintf(coreLockedUsersPath+"%s/%s/%s", ns.ID, loginUserInfoKey.mountAccessor, loginUserInfoKey.aliasName) existingEntry, err := c.barrier.Get(ctx, storageUserLockoutPath) if err != nil { return false, err } var lastLoginTime int if existingEntry == nil { // no storage entry found, user is not locked return false, nil } err = jsonutil.DecodeJSON(existingEntry.Value, &lastLoginTime) if err != nil { return false, err } // if time passed from last login time is within lockout duration, the user is locked if time.Now().Unix()-int64(lastLoginTime) < int64(userLockoutConfiguration.LockoutDuration.Seconds()) { // user locked return true, nil } // else user is not locked. Entry is stale, this will be removed from storage during cleanup // by the background thread default: // entry found in userFailedLoginInfo map, check if the user is locked isCountOverLockoutThreshold := userFailedLoginInfo.count >= uint(userLockoutConfiguration.LockoutThreshold) isWithinLockoutDuration := time.Now().Unix()-int64(userFailedLoginInfo.lastFailedLoginTime) < int64(userLockoutConfiguration.LockoutDuration.Seconds()) if isCountOverLockoutThreshold && isWithinLockoutDuration { // user locked return true, nil } } return false, nil } // getUserLockoutConfiguration gets the user lockout configuration for a mount entry // it checks the config file and auth tune values // precedence: auth tune >> config file values for auth type >> config file values for all type // >> default user lockout values // getUserLockoutFromConfig call in this function takes care of config file precedence func (c *Core) getUserLockoutConfiguration(mountEntry *MountEntry) (userLockoutConfig UserLockoutConfig) { // get user configuration values from config file userLockoutConfig = c.getUserLockoutFromConfig(mountEntry.Type) authTuneUserLockoutConfig := mountEntry.Config.UserLockoutConfig // if user lockout is not configured using auth tune, return values from config file if authTuneUserLockoutConfig == nil { return userLockoutConfig } // replace values in return with config file configuration // for fields that are not configured using auth tune if authTuneUserLockoutConfig.LockoutThreshold != 0 { userLockoutConfig.LockoutThreshold = authTuneUserLockoutConfig.LockoutThreshold } if authTuneUserLockoutConfig.LockoutDuration != 0 { userLockoutConfig.LockoutDuration = authTuneUserLockoutConfig.LockoutDuration } if authTuneUserLockoutConfig.LockoutCounterReset != 0 { userLockoutConfig.LockoutCounterReset = authTuneUserLockoutConfig.LockoutCounterReset } if authTuneUserLockoutConfig.DisableLockout { userLockoutConfig.DisableLockout = authTuneUserLockoutConfig.DisableLockout } return userLockoutConfig } // getUserLockoutFromConfig gets the userlockout configuration for given mount type from config file // it reads the user lockout configuration from server config // it has values for "all" type and any mountType that is configured using config file // "all" type values are updated in shared config with default values i.e; if "all" type is // not configured in config file, it is updated in shared config with default configuration // If "all" type is configured in config file, any missing fields are updated with default values // similarly missing values for a given mount type in config file are updated with "all" type // default values // If user_lockout configuration is not configured using config file at all, defaults are returned func (c *Core) getUserLockoutFromConfig(mountType string) UserLockoutConfig { defaultUserLockoutConfig := UserLockoutConfig{ LockoutThreshold: configutil.UserLockoutThresholdDefault, LockoutDuration: configutil.UserLockoutDurationDefault, LockoutCounterReset: configutil.UserLockoutCounterResetDefault, DisableLockout: configutil.DisableUserLockoutDefault, } conf := c.rawConfig.Load() if conf == nil { return defaultUserLockoutConfig } userlockouts := conf.(*server.Config).UserLockouts if userlockouts == nil { return defaultUserLockoutConfig } for _, userLockoutConfig := range userlockouts { switch userLockoutConfig.Type { case "all": defaultUserLockoutConfig = UserLockoutConfig{ LockoutThreshold: userLockoutConfig.LockoutThreshold, LockoutDuration: userLockoutConfig.LockoutDuration, LockoutCounterReset: userLockoutConfig.LockoutCounterReset, DisableLockout: userLockoutConfig.DisableLockout, } case mountType: return UserLockoutConfig{ LockoutThreshold: userLockoutConfig.LockoutThreshold, LockoutDuration: userLockoutConfig.LockoutDuration, LockoutCounterReset: userLockoutConfig.LockoutCounterReset, DisableLockout: userLockoutConfig.DisableLockout, } } } return defaultUserLockoutConfig } func (c *Core) buildMfaEnforcementResponse(eConfig *mfa.MFAEnforcementConfig) (*logical.MFAConstraintAny, error) { mfaAny := &logical.MFAConstraintAny{ Any: []*logical.MFAMethodID{}, } for _, methodID := range eConfig.MFAMethodIDs { mConfig, err := c.loginMFABackend.MemDBMFAConfigByID(methodID) if err != nil { return nil, fmt.Errorf("failed to get methodID %s from MFA config table, error: %v", methodID, err) } mfaMethod := &logical.MFAMethodID{ Type: mConfig.Type, ID: methodID, UsesPasscode: mConfig.Type == mfaMethodTypeTOTP, Name: mConfig.Name, } mfaAny.Any = append(mfaAny.Any, mfaMethod) } return mfaAny, nil } func blockRequestIfErrorImpl(_ *Core, _, _ string) error { return nil } // RegisterAuth uses a logical.Auth object to create a token entry in the token // store, and registers a corresponding token lease to the expiration manager. // role is the login role used as part of the creation of the token entry. If not // relevant, can be omitted (by being provided as ""). func (c *Core) RegisterAuth(ctx context.Context, tokenTTL time.Duration, path string, auth *logical.Auth, role string) error { // We first assign token policies to what was returned from the backend // via auth.Policies. Then, we get the full set of policies into // auth.Policies from the backend + entity information -- this is not // stored in the token, but we perform sanity checks on it and return // that information to the user. // Generate a token ns, err := namespace.FromContext(ctx) if err != nil { return err } te := logical.TokenEntry{ Path: path, Meta: auth.Metadata, DisplayName: auth.DisplayName, CreationTime: time.Now().Unix(), TTL: tokenTTL, NumUses: auth.NumUses, EntityID: auth.EntityID, BoundCIDRs: auth.BoundCIDRs, Policies: auth.TokenPolicies, NamespaceID: ns.ID, ExplicitMaxTTL: auth.ExplicitMaxTTL, Period: auth.Period, Type: auth.TokenType, } if te.TTL == 0 && (len(te.Policies) != 1 || te.Policies[0] != "root") { c.logger.Error("refusing to create a non-root zero TTL token") return ErrInternalError } if err := c.tokenStore.create(ctx, &te); err != nil { c.logger.Error("failed to create token", "error", err) return ErrInternalError } // Populate the client token, accessor, and TTL auth.ClientToken = te.ID auth.Accessor = te.Accessor auth.TTL = te.TTL auth.Orphan = te.Parent == "" switch auth.TokenType { case logical.TokenTypeBatch: // Ensure it's not marked renewable since it isn't auth.Renewable = false case logical.TokenTypeService: // Register with the expiration manager if err := c.expiration.RegisterAuth(ctx, &te, auth, role); err != nil { if err := c.tokenStore.revokeOrphan(ctx, te.ID); err != nil { c.logger.Warn("failed to clean up token lease during login request", "request_path", path, "error", err) } c.logger.Error("failed to register token lease during login request", "request_path", path, "error", err) return ErrInternalError } if te.ExternalID != "" { auth.ClientToken = te.ExternalID } // Successful login, remove any entry from userFailedLoginInfo map // if it exists. This is done for service tokens (for oss) here. // For ent it is taken care by registerAuth RPC calls. if auth.Alias != nil { loginUserInfoKey := FailedLoginUser{ aliasName: auth.Alias.Name, mountAccessor: auth.Alias.MountAccessor, } // We don't need to try to delete the lockedUsers storage entry, since we're // processing a login request. If a login attempt is allowed, it means the user is // unlocked and we only add storage entry when the user gets locked. err = updateUserFailedLoginInfo(ctx, c, loginUserInfoKey, nil, true) if err != nil { return err } } } return nil } // LocalGetUserFailedLoginInfo gets the failed login information for a user based on alias name and mountAccessor func (c *Core) LocalGetUserFailedLoginInfo(ctx context.Context, userKey FailedLoginUser) *FailedLoginInfo { c.userFailedLoginInfoLock.Lock() value, exists := c.userFailedLoginInfo[userKey] c.userFailedLoginInfoLock.Unlock() if exists { return value } return nil } // LocalUpdateUserFailedLoginInfo updates the failed login information for a user based on alias name and mountAccessor func (c *Core) LocalUpdateUserFailedLoginInfo(ctx context.Context, userKey FailedLoginUser, failedLoginInfo *FailedLoginInfo, deleteEntry bool) error { c.userFailedLoginInfoLock.Lock() defer c.userFailedLoginInfoLock.Unlock() switch deleteEntry { case false: // update entry in the map c.userFailedLoginInfo[userKey] = failedLoginInfo // get the user lockout configuration for the user mountEntry := c.router.MatchingMountByAccessor(userKey.mountAccessor) if mountEntry == nil { mountEntry = &MountEntry{} mountEntry.NamespaceID = namespace.RootNamespaceID } userLockoutConfiguration := c.getUserLockoutConfiguration(mountEntry) // if failed login count has reached threshold, create a storage entry as the user got locked if failedLoginInfo.count >= uint(userLockoutConfiguration.LockoutThreshold) { // user locked storageUserLockoutPath := fmt.Sprintf(coreLockedUsersPath+"%s/%s/%s", mountEntry.NamespaceID, userKey.mountAccessor, userKey.aliasName) compressedBytes, err := jsonutil.EncodeJSONAndCompress(failedLoginInfo.lastFailedLoginTime, nil) if err != nil { c.logger.Error("failed to encode or compress failed login user entry", "error", err) return err } // Create an entry entry := &logical.StorageEntry{ Key: storageUserLockoutPath, Value: compressedBytes, } // Write to the physical backend if err := c.barrier.Put(ctx, entry); err != nil { c.logger.Error("failed to persist failed login user entry", "error", err) return err } } default: // delete the entry from the map, if no key exists it is no-op delete(c.userFailedLoginInfo, userKey) } return nil } // PopulateTokenEntry looks up req.ClientToken in the token store and uses // it to set other fields in req. Does nothing if ClientToken is empty // or a JWT token, or for service tokens that don't exist in the token store. // Should be called with read stateLock held. func (c *Core) PopulateTokenEntry(ctx context.Context, req *logical.Request) error { if req.ClientToken == "" { return nil } // Also attach the accessor if we have it. This doesn't fail if it // doesn't exist because the request may be to an unauthenticated // endpoint/login endpoint where a bad current token doesn't matter, or // a token from a Vault version pre-accessors. We ignore errors for // JWTs. token := req.ClientToken var err error req.InboundSSCToken = token decodedToken := token if IsSSCToken(token) { // If ForwardToActive is set to ForwardSSCTokenToActive, we ignore // whether the endpoint is a login request, as since we have the token // forwarded to us, we should treat it as an unauthenticated endpoint // and ensure the token is populated too regardless. // Notably, this is important for some endpoints, such as endpoints // such as sys/ui/mounts/internal, which is unauthenticated but a token // may be provided to be used. // Without the check to see if // c.ForwardToActive() == ForwardSSCTokenToActive unauthenticated // requests that do not use a token but were provided one anyway // could fail with a 412. // We only follow this behaviour if we're a perf standby, as // this behaviour only makes sense in that case as only they // could be missing the token population. // Without ForwardToActive being set to ForwardSSCTokenToActive, // behaviours that rely on this functionality also wouldn't make // much sense, as they would fail with 412 required index not present // as perf standbys aren't guaranteed to have the WAL state // for new tokens. unauth := c.isLoginRequest(ctx, req) if c.ForwardToActive() == ForwardSSCTokenToActive && c.perfStandby { unauth = false } decodedToken, err = c.CheckSSCToken(ctx, token, unauth, c.perfStandby) // If we receive an error from CheckSSCToken, we can assume the token is bad somehow, and the client // should receive a 403 bad token error like they do for all other invalid tokens, unless the error // specifies that we should forward the request or retry the request. if err != nil { if errors.Is(err, logical.ErrPerfStandbyPleaseForward) || errors.Is(err, logical.ErrMissingRequiredState) { return err } return logical.ErrPermissionDenied } } req.ClientToken = decodedToken // We ignore the token returned from CheckSSCToken here as Lookup also // decodes the SSCT, and it may need the original SSCT to check state. te, err := c.LookupToken(ctx, token) if err != nil { // If we're missing required state, return that error // as-is to the client if errors.Is(err, logical.ErrPerfStandbyPleaseForward) || errors.Is(err, logical.ErrMissingRequiredState) { return err } // If we have two dots but the second char is a dot it's a vault // token of the form s.SOMETHING.nsid, not a JWT if !IsJWT(token) { return fmt.Errorf("error performing token check: %w", err) } } if err == nil && te != nil { req.ClientTokenAccessor = te.Accessor req.ClientTokenRemainingUses = te.NumUses req.SetTokenEntry(te) } return nil } func (c *Core) CheckSSCToken(ctx context.Context, token string, unauth bool, isPerfStandby bool) (string, error) { if unauth && token != "" { // This token shouldn't really be here, but alas it was sent along with the request // Since we're already knee deep in the token checking code pre-existing token checking // code, we have to deal with this token whether we like it or not. So, we'll just try // to get the inner token, and if that fails, return the token as-is. We intentionally // will skip any token checks, because this is an unauthenticated paths and the token // is just a nuisance rather than a means of auth. // We cannot return whatever we like here, because if we do then CheckToken, which looks up // the corresponding lease, will not find the token entry and lease. There are unauth'ed // endpoints that use the token entry (such as sys/ui/mounts/internal) to do custom token // checks, which would then fail. Therefore, we must try to get whatever thing is tied to // token entries, but we must explicitly not do any SSC Token checks. tok, err := c.DecodeSSCToken(token) if err != nil || tok == "" { return token, nil } return tok, nil } return c.checkSSCTokenInternal(ctx, token, isPerfStandby) } // DecodeSSCToken returns the random part of an SSCToken without // performing any signature or WAL checks. func (c *Core) DecodeSSCToken(token string) (string, error) { // Skip batch and old style service tokens. These can have the prefix "b.", // "s." (for old tokens) or "hvb." if !IsSSCToken(token) { return token, nil } tok, err := c.DecodeSSCTokenInternal(token) if err != nil { return "", err } return tok.Random, nil } // DecodeSSCTokenInternal is a helper used to get the inner part of a SSC token without // checking the token signature or the WAL index. func (c *Core) DecodeSSCTokenInternal(token string) (*tokens.Token, error) { signedToken := &tokens.SignedToken{} // Skip batch and old style service tokens. These can have the prefix "b.", // "s." (for old tokens) or "hvb." if !strings.HasPrefix(token, consts.ServiceTokenPrefix) { return nil, fmt.Errorf("not service token") } // Consider the suffix of the token only when unmarshalling suffixToken := token[4:] tokenBytes, err := base64.RawURLEncoding.DecodeString(suffixToken) if err != nil { return nil, fmt.Errorf("can't decode token") } err = proto.Unmarshal(tokenBytes, signedToken) if err != nil { return nil, err } plainToken := &tokens.Token{} err2 := proto.Unmarshal([]byte(signedToken.Token), plainToken) if err2 != nil { return nil, err2 } return plainToken, nil } func (c *Core) checkSSCTokenInternal(ctx context.Context, token string, isPerfStandby bool) (string, error) { signedToken := &tokens.SignedToken{} // Skip batch and old style service tokens. These can have the prefix "b.", // "s." (for old tokens) or "hvb." if !strings.HasPrefix(token, consts.ServiceTokenPrefix) { return token, nil } // Check token length to guess if this is an server side consistent token or not. // Note that even when the DisableSSCTokens flag is set, index // bearing tokens that have already been given out may still be used. if !IsSSCToken(token) { return token, nil } // Consider the suffix of the token only when unmarshalling suffixToken := token[4:] tokenBytes, err := base64.RawURLEncoding.DecodeString(suffixToken) if err != nil { c.logger.Warn("cannot decode token", "error", err) return token, nil } err = proto.Unmarshal(tokenBytes, signedToken) if err != nil { return "", fmt.Errorf("error occurred when unmarshalling ssc token: %w", err) } hm, err := c.tokenStore.CalculateSignedTokenHMAC(signedToken.Token) if !hmac.Equal(hm, signedToken.Hmac) { return "", fmt.Errorf("token mac for %+v is incorrect: err %w", signedToken, err) } plainToken := &tokens.Token{} err = proto.Unmarshal([]byte(signedToken.Token), plainToken) if err != nil { return "", err } // Disregard SSCT on perf-standbys for non-raft storage if c.perfStandby && c.getRaftBackend() == nil { return plainToken.Random, nil } ep := int(plainToken.IndexEpoch) if ep < c.tokenStore.GetSSCTokensGenerationCounter() { return plainToken.Random, nil } requiredWalState := &logical.WALState{ClusterID: c.ClusterID(), LocalIndex: plainToken.LocalIndex, ReplicatedIndex: 0} if c.HasWALState(requiredWalState, isPerfStandby) { return plainToken.Random, nil } // Make sure to forward the request instead of checking the token if the flag // is set and we're on a perf standby if c.ForwardToActive() == ForwardSSCTokenToActive && isPerfStandby { return "", logical.ErrPerfStandbyPleaseForward } // In this case, the server side consistent token cannot be used on this node. We return the appropriate // status code. return "", logical.ErrMissingRequiredState }