209 lines
7 KiB
Go
209 lines
7 KiB
Go
package ape
|
|
|
|
import (
|
|
"context"
|
|
"crypto/ecdsa"
|
|
"errors"
|
|
"fmt"
|
|
|
|
objectV2 "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/object"
|
|
aperequest "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/ape/request"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/ape/router"
|
|
"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-sdk-go/ape"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/bearer"
|
|
cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
|
|
oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
|
|
"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"
|
|
nativeschema "git.frostfs.info/TrueCloudLab/policy-engine/schema/native"
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
|
|
)
|
|
|
|
type checkerImpl struct {
|
|
chainRouter policyengine.ChainRouter
|
|
headerProvider HeaderProvider
|
|
frostFSIDClient frostfsidcore.SubjectProvider
|
|
nm netmap.Source
|
|
st netmap.State
|
|
cnrSource container.Source
|
|
nodePK []byte
|
|
}
|
|
|
|
func NewChecker(chainRouter policyengine.ChainRouter, headerProvider HeaderProvider, frostFSIDClient frostfsidcore.SubjectProvider, nm netmap.Source, st netmap.State, cnrSource container.Source, nodePK []byte) Checker {
|
|
return &checkerImpl{
|
|
chainRouter: chainRouter,
|
|
headerProvider: headerProvider,
|
|
frostFSIDClient: frostFSIDClient,
|
|
nm: nm,
|
|
st: st,
|
|
cnrSource: cnrSource,
|
|
nodePK: nodePK,
|
|
}
|
|
}
|
|
|
|
type Prm struct {
|
|
Namespace string
|
|
|
|
Container cid.ID
|
|
|
|
// Object ID is omitted for some methods.
|
|
Object *oid.ID
|
|
|
|
// If Header is set, then object attributes and properties will be parsed from
|
|
// a request/response's header.
|
|
Header *objectV2.Header
|
|
|
|
// Method must be represented only as a constant represented in native schema.
|
|
Method string
|
|
|
|
// Role must be representedonly as a constant represented in native schema.
|
|
Role string
|
|
|
|
// An encoded sender's public key string.
|
|
SenderKey string
|
|
|
|
// An encoded container's owner user ID.
|
|
ContainerOwner user.ID
|
|
|
|
// If SoftAPECheck is set to true, then NoRuleFound is interpreted as allow.
|
|
SoftAPECheck bool
|
|
|
|
// If true, object headers will not retrieved from storage engine.
|
|
WithoutHeaderRequest bool
|
|
|
|
// The request's bearer token. It is used in order to check APE overrides with the token.
|
|
BearerToken *bearer.Token
|
|
}
|
|
|
|
var (
|
|
errMissingOID = errors.New("object ID is not set")
|
|
errInvalidTargetType = errors.New("bearer token defines non-container target override")
|
|
errBearerExpired = errors.New("bearer token has expired")
|
|
errBearerInvalidSignature = errors.New("bearer token has invalid signature")
|
|
errBearerInvalidContainerID = errors.New("bearer token was created for another container")
|
|
errBearerNotSignedByOwner = errors.New("bearer token is not signed by the container owner")
|
|
errBearerInvalidOwner = errors.New("bearer token owner differs from the request sender")
|
|
)
|
|
|
|
// isValidBearer checks whether bearer token was correctly signed by authorized
|
|
// entity. This method might be defined on whole ACL service because it will
|
|
// require fetching current epoch to check lifetime.
|
|
func isValidBearer(token *bearer.Token, ownerCnr user.ID, containerID cid.ID, publicKey *keys.PublicKey, st netmap.State) error {
|
|
if token == nil {
|
|
return nil
|
|
}
|
|
|
|
// First check token lifetime. Simplest verification.
|
|
if token.InvalidAt(st.CurrentEpoch()) {
|
|
return errBearerExpired
|
|
}
|
|
|
|
// Then check if bearer token is signed correctly.
|
|
if !token.VerifySignature() {
|
|
return errBearerInvalidSignature
|
|
}
|
|
|
|
// Check for ape overrides defined in the bearer token.
|
|
apeOverride := token.APEOverride()
|
|
if len(apeOverride.Chains) > 0 && apeOverride.Target.TargetType != ape.TargetTypeContainer {
|
|
return fmt.Errorf("%w: %s", errInvalidTargetType, apeOverride.Target.TargetType.ToV2().String())
|
|
}
|
|
|
|
// Then check if container is either empty or equal to the container in the request.
|
|
var targetCnr cid.ID
|
|
err := targetCnr.DecodeString(apeOverride.Target.Name)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid cid format: %s", apeOverride.Target.Name)
|
|
}
|
|
if !containerID.Equals(targetCnr) {
|
|
return errBearerInvalidContainerID
|
|
}
|
|
|
|
// Then check if container owner signed this token.
|
|
if !bearer.ResolveIssuer(*token).Equals(ownerCnr) {
|
|
return errBearerNotSignedByOwner
|
|
}
|
|
|
|
// Then check if request sender has rights to use this token.
|
|
var usrSender user.ID
|
|
user.IDFromKey(&usrSender, (ecdsa.PublicKey)(*publicKey))
|
|
|
|
if !token.AssertUser(usrSender) {
|
|
return errBearerInvalidOwner
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// CheckAPE checks if a request or a response is permitted creating an ape request and passing
|
|
// it to chain router.
|
|
func (c *checkerImpl) CheckAPE(ctx context.Context, prm Prm) error {
|
|
// APE check is ignored for some inter-node requests.
|
|
if prm.Role == nativeschema.PropertyValueContainerRoleContainer {
|
|
return nil
|
|
} else if prm.Role == nativeschema.PropertyValueContainerRoleIR {
|
|
switch prm.Method {
|
|
case nativeschema.MethodGetObject,
|
|
nativeschema.MethodHeadObject,
|
|
nativeschema.MethodSearchObject,
|
|
nativeschema.MethodRangeObject,
|
|
nativeschema.MethodHashObject:
|
|
return nil
|
|
default:
|
|
}
|
|
}
|
|
|
|
r, err := c.newAPERequest(ctx, prm)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create ape request: %w", err)
|
|
}
|
|
pub, err := keys.NewPublicKeyFromString(prm.SenderKey)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
groups, err := aperequest.Groups(c.frostFSIDClient, pub)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get group ids: %w", err)
|
|
}
|
|
|
|
// Policy contract keeps group related chains as namespace-group pair.
|
|
for i := range groups {
|
|
groups[i] = fmt.Sprintf("%s:%s", prm.Namespace, groups[i])
|
|
}
|
|
|
|
if prm.BearerToken != nil && !prm.BearerToken.Impersonate() {
|
|
if err := isValidBearer(prm.BearerToken, prm.ContainerOwner, prm.Container, pub, c.st); err != nil {
|
|
return fmt.Errorf("bearer token validation error: %w", err)
|
|
}
|
|
btRouter, err := router.SingleUseRouterWithBearerTokenChains([]bearer.APEOverride{prm.BearerToken.APEOverride()})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
status, found, err := btRouter.IsAllowed(apechain.Ingress, policyengine.NewRequestTargetWithContainer(prm.Container.EncodeToString()), r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if found && status == apechain.Allow {
|
|
return nil
|
|
}
|
|
if status != apechain.NoRuleFound {
|
|
return fmt.Errorf("bearer token: method %s: %s", prm.Method, status)
|
|
}
|
|
}
|
|
|
|
rt := policyengine.NewRequestTargetExtended(prm.Namespace, prm.Container.EncodeToString(), fmt.Sprintf("%s:%s", prm.Namespace, pub.Address()), groups)
|
|
status, ruleFound, err := c.chainRouter.IsAllowed(apechain.Ingress, rt, r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !ruleFound && prm.SoftAPECheck || status == apechain.Allow {
|
|
return nil
|
|
}
|
|
|
|
return fmt.Errorf("method %s: %s", prm.Method, status)
|
|
}
|