package container import ( "bytes" "context" "crypto/ecdsa" "crypto/elliptic" "crypto/sha256" "encoding/hex" "errors" "fmt" "strings" "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/container" "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs" session "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session" aperequest "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/ape/request" containercore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/container" frostfsidcore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/frostfsid" "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/netmap" "git.frostfs.info/TrueCloudLab/frostfs-observability/tracing" apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status" cnrSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container" cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id" netmapSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap" sessionSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/session" "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/user" apechain "git.frostfs.info/TrueCloudLab/policy-engine/pkg/chain" policyengine "git.frostfs.info/TrueCloudLab/policy-engine/pkg/engine" commonschema "git.frostfs.info/TrueCloudLab/policy-engine/schema/common" nativeschema "git.frostfs.info/TrueCloudLab/policy-engine/schema/native" "github.com/nspcc-dev/neo-go/pkg/crypto/keys" ) var ( errMissingContainerID = errors.New("missing container ID") errSessionContainerMissmatch = errors.New("requested container is not related to the session") errMissingVerificationHeader = errors.New("malformed request: empty verification header") errInvalidSessionTokenSignature = errors.New("malformed request: invalid session token signature") errInvalidSessionTokenOwner = errors.New("malformed request: invalid session token owner") errEmptyBodySignature = errors.New("malformed request: empty body signature") errMissingOwnerID = errors.New("malformed request: missing owner ID") errOwnerIDIsNotSet = errors.New("owner id is not set") errInvalidDomainZone = errors.New("invalid domain zone: no namespace is expected") undefinedContainerID = cid.ID{} ) type ir interface { InnerRingKeys() ([][]byte, error) } type containers interface { Get(cid.ID) (*containercore.Container, error) } type apeChecker struct { router policyengine.ChainRouter reader containers ir ir nm netmap.Source frostFSIDClient frostfsidcore.SubjectProvider next Server } func NewAPEServer(router policyengine.ChainRouter, reader containers, ir ir, nm netmap.Source, frostFSIDClient frostfsidcore.SubjectProvider, srv Server) Server { return &apeChecker{ router: router, reader: reader, ir: ir, next: srv, nm: nm, frostFSIDClient: frostFSIDClient, } } func (ac *apeChecker) AnnounceUsedSpace(ctx context.Context, req *container.AnnounceUsedSpaceRequest) (*container.AnnounceUsedSpaceResponse, error) { ctx, span := tracing.StartSpanFromContext(ctx, "apeChecker.AnnounceUsedSpace") defer span.End() // this method is not used, so not checked return ac.next.AnnounceUsedSpace(ctx, req) } func (ac *apeChecker) Delete(ctx context.Context, req *container.DeleteRequest) (*container.DeleteResponse, error) { ctx, span := tracing.StartSpanFromContext(ctx, "apeChecker.Delete") defer span.End() if err := ac.validateContainerBoundedOperation(req.GetBody().GetContainerID(), req.GetMetaHeader(), req.GetVerificationHeader(), nativeschema.MethodDeleteContainer); err != nil { return nil, err } return ac.next.Delete(ctx, req) } func (ac *apeChecker) Get(ctx context.Context, req *container.GetRequest) (*container.GetResponse, error) { ctx, span := tracing.StartSpanFromContext(ctx, "apeChecker.Get") defer span.End() if err := ac.validateContainerBoundedOperation(req.GetBody().GetContainerID(), req.GetMetaHeader(), req.GetVerificationHeader(), nativeschema.MethodGetContainer); err != nil { return nil, err } return ac.next.Get(ctx, req) } func (ac *apeChecker) GetExtendedACL(ctx context.Context, req *container.GetExtendedACLRequest) (*container.GetExtendedACLResponse, error) { ctx, span := tracing.StartSpanFromContext(ctx, "apeChecker.GetExtendedACL") defer span.End() if err := ac.validateContainerBoundedOperation(req.GetBody().GetContainerID(), req.GetMetaHeader(), req.GetVerificationHeader(), nativeschema.MethodGetContainerEACL); err != nil { return nil, err } return ac.next.GetExtendedACL(ctx, req) } func (ac *apeChecker) List(ctx context.Context, req *container.ListRequest) (*container.ListResponse, error) { ctx, span := tracing.StartSpanFromContext(ctx, "apeChecker.List") defer span.End() role, pk, err := ac.getRoleWithoutContainerID(req.GetBody().GetOwnerID(), req.GetMetaHeader(), req.GetVerificationHeader()) if err != nil { return nil, err } reqProps := map[string]string{ nativeschema.PropertyKeyActorPublicKey: hex.EncodeToString(pk.Bytes()), nativeschema.PropertyKeyActorRole: role, } reqProps, err = ac.fillWithUserClaimTags(reqProps, pk) if err != nil { return nil, err } namespace, err := ac.namespaceByOwner(req.GetBody().GetOwnerID()) if err != nil { return nil, fmt.Errorf("could not get owner namespace: %w", err) } if err := ac.validateNamespaceByPublicKey(pk, namespace); err != nil { return nil, err } request := aperequest.NewRequest( nativeschema.MethodListContainers, aperequest.NewResource( resourceName(namespace, ""), make(map[string]string), ), reqProps, ) rt := policyengine.NewRequestTargetWithNamespace(namespace) rt.User = &policyengine.Target{ Type: policyengine.User, Name: fmt.Sprintf("%s:%s", namespace, pk.Address()), } s, found, err := ac.router.IsAllowed(apechain.Ingress, rt, request) if err != nil { return nil, err } if found && s == apechain.Allow { return ac.next.List(ctx, req) } return nil, apeErr(nativeschema.MethodListContainers, s) } func (ac *apeChecker) Put(ctx context.Context, req *container.PutRequest) (*container.PutResponse, error) { ctx, span := tracing.StartSpanFromContext(ctx, "apeChecker.Put") defer span.End() role, pk, err := ac.getRoleWithoutContainerID(req.GetBody().GetContainer().GetOwnerID(), req.GetMetaHeader(), req.GetVerificationHeader()) if err != nil { return nil, err } reqProps := map[string]string{ nativeschema.PropertyKeyActorPublicKey: hex.EncodeToString(pk.Bytes()), nativeschema.PropertyKeyActorRole: role, } reqProps, err = ac.fillWithUserClaimTags(reqProps, pk) if err != nil { return nil, err } namespace, err := ac.namespaceByOwner(req.GetBody().GetContainer().GetOwnerID()) if err != nil { return nil, fmt.Errorf("get namespace error: %w", err) } if err = validateNamespace(req.GetBody().GetContainer(), namespace); err != nil { return nil, err } request := aperequest.NewRequest( nativeschema.MethodPutContainer, aperequest.NewResource( resourceName(namespace, ""), make(map[string]string), ), reqProps, ) rt := policyengine.NewRequestTargetWithNamespace(namespace) rt.User = &policyengine.Target{ Type: policyengine.User, Name: fmt.Sprintf("%s:%s", namespace, pk.Address()), } s, found, err := ac.router.IsAllowed(apechain.Ingress, rt, request) if err != nil { return nil, err } if found && s == apechain.Allow { return ac.next.Put(ctx, req) } return nil, apeErr(nativeschema.MethodPutContainer, s) } func (ac *apeChecker) getRoleWithoutContainerID(oID *refs.OwnerID, mh *session.RequestMetaHeader, vh *session.RequestVerificationHeader) (string, *keys.PublicKey, error) { if vh == nil { return "", nil, errMissingVerificationHeader } if oID == nil { return "", nil, errMissingOwnerID } var ownerID user.ID if err := ownerID.ReadFromV2(*oID); err != nil { return "", nil, err } actor, pk, err := ac.getActorAndPublicKey(mh, vh, undefinedContainerID) if err != nil { return "", nil, err } if actor.Equals(ownerID) { return nativeschema.PropertyValueContainerRoleOwner, pk, nil } pkBytes := pk.Bytes() isIR, err := ac.isInnerRingKey(pkBytes) if err != nil { return "", nil, err } if isIR { return nativeschema.PropertyValueContainerRoleIR, pk, nil } return nativeschema.PropertyValueContainerRoleOthers, pk, nil } func (ac *apeChecker) SetExtendedACL(ctx context.Context, req *container.SetExtendedACLRequest) (*container.SetExtendedACLResponse, error) { ctx, span := tracing.StartSpanFromContext(ctx, "apeChecker.SetExtendedACL") defer span.End() if err := ac.validateContainerBoundedOperation(req.GetBody().GetEACL().GetContainerID(), req.GetMetaHeader(), req.GetVerificationHeader(), nativeschema.MethodSetContainerEACL); err != nil { return nil, err } return ac.next.SetExtendedACL(ctx, req) } func (ac *apeChecker) validateContainerBoundedOperation(containerID *refs.ContainerID, mh *session.RequestMetaHeader, vh *session.RequestVerificationHeader, op string) error { if vh == nil { return errMissingVerificationHeader } id, err := getContainerID(containerID) if err != nil { return err } cont, err := ac.reader.Get(id) if err != nil { return err } reqProps, pk, err := ac.getRequestProps(mh, vh, cont, id) if err != nil { return err } namespace := "" cntNamespace, hasNamespace := strings.CutSuffix(cnrSDK.ReadDomain(cont.Value).Zone(), ".ns") if hasNamespace { namespace = cntNamespace } request := aperequest.NewRequest( op, aperequest.NewResource( resourceName(namespace, id.EncodeToString()), ac.getContainerProps(cont), ), reqProps, ) s, found, err := ac.router.IsAllowed(apechain.Ingress, policyengine.NewRequestTargetExtended(namespace, id.EncodeToString(), fmt.Sprintf("%s:%s", namespace, pk.Address()), nil), request) if err != nil { return err } if found && s == apechain.Allow { return nil } return apeErr(op, s) } func apeErr(operation string, status apechain.Status) error { errAccessDenied := &apistatus.ObjectAccessDenied{} errAccessDenied.WriteReason(fmt.Sprintf("access to container operation %s is denied by access policy engine: %s", operation, status.String())) return errAccessDenied } func getContainerID(reqContID *refs.ContainerID) (cid.ID, error) { if reqContID == nil { return cid.ID{}, errMissingContainerID } var id cid.ID err := id.ReadFromV2(*reqContID) if err != nil { return cid.ID{}, fmt.Errorf("invalid container ID: %w", err) } return id, nil } func resourceName(namespace string, container string) string { if namespace == "" && container == "" { return nativeschema.ResourceFormatRootContainers } if namespace == "" && container != "" { return fmt.Sprintf(nativeschema.ResourceFormatRootContainer, container) } if namespace != "" && container == "" { return fmt.Sprintf(nativeschema.ResourceFormatNamespaceContainers, namespace) } return fmt.Sprintf(nativeschema.ResourceFormatNamespaceContainer, namespace, container) } func (ac *apeChecker) getContainerProps(c *containercore.Container) map[string]string { return map[string]string{ nativeschema.PropertyKeyContainerOwnerID: c.Value.Owner().EncodeToString(), } } func (ac *apeChecker) getRequestProps(mh *session.RequestMetaHeader, vh *session.RequestVerificationHeader, cont *containercore.Container, cnrID cid.ID, ) (map[string]string, *keys.PublicKey, error) { actor, pk, err := ac.getActorAndPublicKey(mh, vh, cnrID) if err != nil { return nil, nil, err } role, err := ac.getRole(actor, pk, cont, cnrID) if err != nil { return nil, nil, err } reqProps := map[string]string{ nativeschema.PropertyKeyActorPublicKey: hex.EncodeToString(pk.Bytes()), nativeschema.PropertyKeyActorRole: role, } reqProps, err = ac.fillWithUserClaimTags(reqProps, pk) if err != nil { return nil, nil, err } return reqProps, pk, nil } func (ac *apeChecker) getRole(actor *user.ID, pk *keys.PublicKey, cont *containercore.Container, cnrID cid.ID) (string, error) { if cont.Value.Owner().Equals(*actor) { return nativeschema.PropertyValueContainerRoleOwner, nil } pkBytes := pk.Bytes() isIR, err := ac.isInnerRingKey(pkBytes) if err != nil { return "", err } if isIR { return nativeschema.PropertyValueContainerRoleIR, nil } isContainer, err := ac.isContainerKey(pkBytes, cnrID, cont) if err != nil { return "", err } if isContainer { return nativeschema.PropertyValueContainerRoleContainer, nil } return nativeschema.PropertyValueContainerRoleOthers, nil } func (ac *apeChecker) getActorAndPublicKey(mh *session.RequestMetaHeader, vh *session.RequestVerificationHeader, cnrID cid.ID) (*user.ID, *keys.PublicKey, error) { st, err := ac.getSessionToken(mh) if err != nil { return nil, nil, err } if st != nil { return ac.getActorAndPKFromSessionToken(st, cnrID) } return ac.getActorAndPKFromSignature(vh) } func (ac *apeChecker) getActorAndPKFromSignature(vh *session.RequestVerificationHeader) (*user.ID, *keys.PublicKey, error) { for vh.GetOrigin() != nil { vh = vh.GetOrigin() } sig := vh.GetBodySignature() if sig == nil { return nil, nil, errEmptyBodySignature } key, err := keys.NewPublicKeyFromBytes(sig.GetKey(), elliptic.P256()) if err != nil { return nil, nil, fmt.Errorf("invalid signature key: %w", err) } var userID user.ID user.IDFromKey(&userID, (ecdsa.PublicKey)(*key)) return &userID, key, nil } func (ac *apeChecker) getSessionToken(mh *session.RequestMetaHeader) (*sessionSDK.Container, error) { for mh.GetOrigin() != nil { mh = mh.GetOrigin() } st := mh.GetSessionToken() if st == nil { return nil, nil } var tok sessionSDK.Container err := tok.ReadFromV2(*st) if err != nil { return nil, fmt.Errorf("invalid session token: %w", err) } return &tok, nil } func (ac *apeChecker) getActorAndPKFromSessionToken(st *sessionSDK.Container, cnrID cid.ID) (*user.ID, *keys.PublicKey, error) { if cnrID != undefinedContainerID && !st.AppliedTo(cnrID) { return nil, nil, errSessionContainerMissmatch } if !st.VerifySignature() { return nil, nil, errInvalidSessionTokenSignature } var tok session.Token st.WriteToV2(&tok) signaturePublicKey, err := keys.NewPublicKeyFromBytes(tok.GetSignature().GetKey(), elliptic.P256()) if err != nil { return nil, nil, fmt.Errorf("invalid key in session token signature: %w", err) } tokenIssuer := st.Issuer() if !isOwnerFromKey(tokenIssuer, signaturePublicKey) { return nil, nil, errInvalidSessionTokenOwner } return &tokenIssuer, signaturePublicKey, nil } func isOwnerFromKey(id user.ID, key *keys.PublicKey) bool { if key == nil { return false } var id2 user.ID user.IDFromKey(&id2, (ecdsa.PublicKey)(*key)) return id2.Equals(id) } func (ac *apeChecker) isInnerRingKey(pk []byte) (bool, error) { innerRingKeys, err := ac.ir.InnerRingKeys() if err != nil { return false, err } for i := range innerRingKeys { if bytes.Equal(innerRingKeys[i], pk) { return true, nil } } return false, nil } func (ac *apeChecker) isContainerKey(pk []byte, cnrID cid.ID, cont *containercore.Container) (bool, error) { binCnrID := make([]byte, sha256.Size) cnrID.Encode(binCnrID) nm, err := netmap.GetLatestNetworkMap(ac.nm) if err != nil { return false, err } in, err := isContainerNode(nm, pk, binCnrID, cont) if err != nil { return false, err } else if in { return true, nil } // then check previous netmap, this can happen in-between epoch change // when node migrates data from last epoch container nm, err = netmap.GetPreviousNetworkMap(ac.nm) if err != nil { return false, err } return isContainerNode(nm, pk, binCnrID, cont) } func isContainerNode(nm *netmapSDK.NetMap, pk, binCnrID []byte, cont *containercore.Container) (bool, error) { cnrVectors, err := nm.ContainerNodes(cont.Value.PlacementPolicy(), binCnrID) if err != nil { return false, err } for i := range cnrVectors { for j := range cnrVectors[i] { if bytes.Equal(cnrVectors[i][j].PublicKey(), pk) { return true, nil } } } return false, nil } func (ac *apeChecker) namespaceByOwner(owner *refs.OwnerID) (string, error) { var ownerSDK user.ID if owner == nil { return "", errOwnerIDIsNotSet } if err := ownerSDK.ReadFromV2(*owner); err != nil { return "", err } addr, err := ownerSDK.ScriptHash() if err != nil { return "", err } namespace := "" subject, err := ac.frostFSIDClient.GetSubject(addr) if err == nil { namespace = subject.Namespace } else { if !strings.Contains(err.Error(), frostfsidcore.SubjectNotFoundErrorMessage) { return "", fmt.Errorf("get subject error: %w", err) } } return namespace, nil } // validateNamespace validates a namespace set in a container. // If frostfs-id contract stores a namespace N1 for an owner ID and a container within a request // is set with namespace N2 (via Zone() property), then N2 is invalid and the request is denied. func validateNamespace(cnrV2 *container.Container, ownerIDNamespace string) error { if cnrV2 == nil { return nil } var cnr cnrSDK.Container if err := cnr.ReadFromV2(*cnrV2); err != nil { return err } cntNamespace, hasNamespace := strings.CutSuffix(cnrSDK.ReadDomain(cnr).Zone(), ".ns") if hasNamespace { if cntNamespace != ownerIDNamespace { if ownerIDNamespace == "" { return errInvalidDomainZone } return fmt.Errorf("invalid domain zone: expected namespace %s, but got %s", ownerIDNamespace, cntNamespace) } } else if ownerIDNamespace != "" { return fmt.Errorf("invalid domain zone: expected namespace %s, but got invalid or empty", ownerIDNamespace) } return nil } // validateNamespace validates if a namespace of a request actor equals to owner's namespace. // An actor's namespace is calculated by a public key. func (ac *apeChecker) validateNamespaceByPublicKey(pk *keys.PublicKey, ownerIDNamespace string) error { var actor user.ID user.IDFromKey(&actor, (ecdsa.PublicKey)(*pk)) actorOwnerID := new(refs.OwnerID) actor.WriteToV2(actorOwnerID) actorNamespace, err := ac.namespaceByOwner(actorOwnerID) if err != nil { return fmt.Errorf("could not get actor namespace: %w", err) } if actorNamespace != ownerIDNamespace { return fmt.Errorf("actor namespace %s differs from owner: %s", actorNamespace, ownerIDNamespace) } return nil } // fillWithUserClaimTags fills ape request properties with user claim tags getting them from frostfsid contract by actor public key. func (ac *apeChecker) fillWithUserClaimTags(reqProps map[string]string, pk *keys.PublicKey) (map[string]string, error) { if reqProps == nil { reqProps = make(map[string]string) } subj, err := ac.frostFSIDClient.GetSubject(pk.GetScriptHash()) if err != nil { if !strings.Contains(err.Error(), frostfsidcore.SubjectNotFoundErrorMessage) { return nil, fmt.Errorf("get subject error: %w", err) } return reqProps, nil } for k, v := range subj.KV { properyKey := fmt.Sprintf(commonschema.PropertyKeyFormatFrostFSIDUserClaim, k) reqProps[properyKey] = v } return reqProps, nil }