forked from TrueCloudLab/policy-engine
320 lines
9.1 KiB
Go
320 lines
9.1 KiB
Go
package iam
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"git.frostfs.info/TrueCloudLab/policy-engine/pkg/chain"
|
|
)
|
|
|
|
const condKeyAWSPrincipalARN = "aws:PrincipalArn"
|
|
|
|
const (
|
|
// String condition operators.
|
|
CondStringEquals string = "StringEquals"
|
|
CondStringNotEquals string = "StringNotEquals"
|
|
CondStringEqualsIgnoreCase string = "StringEqualsIgnoreCase"
|
|
CondStringNotEqualsIgnoreCase string = "StringNotEqualsIgnoreCase"
|
|
CondStringLike string = "StringLike"
|
|
CondStringNotLike string = "StringNotLike"
|
|
|
|
// Numeric condition operators.
|
|
CondNumericEquals string = "NumericEquals"
|
|
CondNumericNotEquals string = "NumericNotEquals"
|
|
CondNumericLessThan string = "NumericLessThan"
|
|
CondNumericLessThanEquals string = "NumericLessThanEquals"
|
|
CondNumericGreaterThan string = "NumericGreaterThan"
|
|
CondNumericGreaterThanEquals string = "NumericGreaterThanEquals"
|
|
|
|
// Date condition operators.
|
|
CondDateEquals string = "DateEquals"
|
|
CondDateNotEquals string = "DateNotEquals"
|
|
CondDateLessThan string = "DateLessThan"
|
|
CondDateLessThanEquals string = "DateLessThanEquals"
|
|
CondDateGreaterThan string = "DateGreaterThan"
|
|
CondDateGreaterThanEquals string = "DateGreaterThanEquals"
|
|
|
|
// Bolean condition operators.
|
|
CondBool string = "Bool"
|
|
|
|
// IP address condition operators.
|
|
CondIPAddress string = "IpAddress"
|
|
CondNotIPAddress string = "NotIpAddress"
|
|
|
|
// ARN condition operators.
|
|
CondArnEquals string = "ArnEquals"
|
|
CondArnLike string = "ArnLike"
|
|
CondArnNotEquals string = "ArnNotEquals"
|
|
CondArnNotLike string = "ArnNotLike"
|
|
|
|
// Custom condition operators.
|
|
CondSliceContains string = "SliceContains"
|
|
)
|
|
|
|
const (
|
|
arnIAMPrefix = "arn:aws:iam::"
|
|
s3ResourcePrefix = "arn:aws:s3:::"
|
|
s3ActionPrefix = "s3:"
|
|
iamActionPrefix = "iam:"
|
|
)
|
|
|
|
var (
|
|
// ErrInvalidPrincipalFormat occurs when principal has unknown/unsupported format.
|
|
ErrInvalidPrincipalFormat = errors.New("invalid principal format")
|
|
|
|
// ErrInvalidResourceFormat occurs when resource has unknown/unsupported format.
|
|
ErrInvalidResourceFormat = errors.New("invalid resource format")
|
|
|
|
// ErrInvalidActionFormat occurs when action has unknown/unsupported format.
|
|
ErrInvalidActionFormat = errors.New("invalid action format")
|
|
|
|
// ErrActionsNotApplicable occurs when failed to convert any actions.
|
|
ErrActionsNotApplicable = errors.New("actions not applicable")
|
|
)
|
|
|
|
type formPrincipalConditionFunc func(string) chain.Condition
|
|
|
|
type transformConditionFunc func(gr GroupedConditions) (GroupedConditions, error)
|
|
|
|
func convertToChainConditions(c Conditions, transformer transformConditionFunc) ([]GroupedConditions, error) {
|
|
conditions, err := convertToChainCondition(c)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for i := range conditions {
|
|
if conditions[i], err = transformer(conditions[i]); err != nil {
|
|
return nil, fmt.Errorf("transform condition: %w", err)
|
|
}
|
|
}
|
|
|
|
return conditions, nil
|
|
}
|
|
|
|
type GroupedConditions struct {
|
|
Conditions []chain.Condition
|
|
Any bool
|
|
}
|
|
|
|
func convertToChainCondition(c Conditions) ([]GroupedConditions, error) {
|
|
var grouped []GroupedConditions
|
|
|
|
for op, KVs := range c {
|
|
condType, convertValue, err := getConditionTypeAndConverter(op)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for key, values := range KVs {
|
|
group := GroupedConditions{
|
|
Conditions: make([]chain.Condition, len(values)),
|
|
Any: len(values) > 1,
|
|
}
|
|
|
|
for i, val := range values {
|
|
converted, err := convertValue(val)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
group.Conditions[i] = chain.Condition{
|
|
Op: condType,
|
|
Object: chain.ObjectRequest,
|
|
Key: key,
|
|
Value: converted,
|
|
}
|
|
}
|
|
grouped = append(grouped, group)
|
|
}
|
|
}
|
|
|
|
return grouped, nil
|
|
}
|
|
|
|
func getConditionTypeAndConverter(op string) (chain.ConditionType, convertFunction, error) {
|
|
switch {
|
|
case strings.HasPrefix(op, "String"):
|
|
switch op {
|
|
case CondStringEquals:
|
|
return chain.CondStringEquals, noConvertFunction, nil
|
|
case CondStringNotEquals:
|
|
return chain.CondStringNotEquals, noConvertFunction, nil
|
|
case CondStringEqualsIgnoreCase:
|
|
return chain.CondStringEqualsIgnoreCase, noConvertFunction, nil
|
|
case CondStringNotEqualsIgnoreCase:
|
|
return chain.CondStringNotEqualsIgnoreCase, noConvertFunction, nil
|
|
case CondStringLike:
|
|
return chain.CondStringLike, noConvertFunction, nil
|
|
case CondStringNotLike:
|
|
return chain.CondStringNotLike, noConvertFunction, nil
|
|
default:
|
|
return 0, nil, fmt.Errorf("unsupported condition operator: '%s'", op)
|
|
}
|
|
case strings.HasPrefix(op, "Arn"):
|
|
switch op {
|
|
case CondArnEquals:
|
|
return chain.CondStringEquals, noConvertFunction, nil
|
|
case CondArnNotEquals:
|
|
return chain.CondStringNotEquals, noConvertFunction, nil
|
|
case CondArnLike:
|
|
return chain.CondStringLike, noConvertFunction, nil
|
|
case CondArnNotLike:
|
|
return chain.CondStringNotLike, noConvertFunction, nil
|
|
default:
|
|
return 0, nil, fmt.Errorf("unsupported condition operator: '%s'", op)
|
|
}
|
|
case strings.HasPrefix(op, "Numeric"):
|
|
// TODO
|
|
return 0, nil, fmt.Errorf("currently nummeric conditions unsupported: '%s'", op)
|
|
case strings.HasPrefix(op, "Date"):
|
|
switch op {
|
|
case CondDateEquals:
|
|
return chain.CondStringEquals, dateConvertFunction, nil
|
|
case CondDateNotEquals:
|
|
return chain.CondStringNotEquals, dateConvertFunction, nil
|
|
case CondDateLessThan:
|
|
return chain.CondStringLessThan, dateConvertFunction, nil
|
|
case CondDateLessThanEquals:
|
|
return chain.CondStringLessThanEquals, dateConvertFunction, nil
|
|
case CondDateGreaterThan:
|
|
return chain.CondStringGreaterThan, dateConvertFunction, nil
|
|
case CondDateGreaterThanEquals:
|
|
return chain.CondStringGreaterThanEquals, dateConvertFunction, nil
|
|
default:
|
|
return 0, nil, fmt.Errorf("unsupported condition operator: '%s'", op)
|
|
}
|
|
case op == CondBool:
|
|
return chain.CondStringEqualsIgnoreCase, noConvertFunction, nil
|
|
case op == CondIPAddress:
|
|
// todo consider using converters
|
|
// "203.0.113.0/24" -> "203.0.113.*",
|
|
// "2001:DB8:1234:5678::/64" -> "2001:DB8:1234:5678:*"
|
|
// or having specific condition type for IP
|
|
return chain.CondStringLike, noConvertFunction, nil
|
|
case op == CondNotIPAddress:
|
|
return chain.CondStringNotLike, noConvertFunction, nil
|
|
case op == CondSliceContains:
|
|
return chain.CondSliceContains, noConvertFunction, nil
|
|
default:
|
|
return 0, nil, fmt.Errorf("unsupported condition operator: '%s'", op)
|
|
}
|
|
}
|
|
|
|
type convertFunction func(string) (string, error)
|
|
|
|
func noConvertFunction(val string) (string, error) {
|
|
return val, nil
|
|
}
|
|
|
|
func dateConvertFunction(val string) (string, error) {
|
|
if _, err := strconv.ParseInt(val, 10, 64); err == nil {
|
|
return val, nil
|
|
}
|
|
|
|
parsed, err := time.Parse(time.RFC3339, val)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return strconv.FormatInt(parsed.UTC().Unix(), 10), nil
|
|
}
|
|
|
|
func parsePrincipalAsIAMUser(principal string) (account string, user string, err error) {
|
|
if !strings.HasPrefix(principal, arnIAMPrefix) {
|
|
return "", "", ErrInvalidPrincipalFormat
|
|
}
|
|
|
|
// iam arn format arn:aws:iam::<account>:user/<user-name-with-path>
|
|
iamResource := strings.TrimPrefix(principal, arnIAMPrefix)
|
|
sepIndex := strings.Index(iamResource, ":user/")
|
|
if sepIndex < 0 {
|
|
return "", "", ErrInvalidPrincipalFormat
|
|
}
|
|
|
|
account = iamResource[:sepIndex]
|
|
user = iamResource[sepIndex+6:]
|
|
if len(user) == 0 {
|
|
return "", "", ErrInvalidPrincipalFormat
|
|
}
|
|
|
|
userNameIndex := strings.LastIndexByte(user, '/')
|
|
if userNameIndex > -1 {
|
|
user = user[userNameIndex+1:]
|
|
if len(user) == 0 {
|
|
return "", "", ErrInvalidPrincipalFormat
|
|
}
|
|
}
|
|
|
|
return account, user, nil
|
|
}
|
|
|
|
func validateResource(resource string) error {
|
|
if resource == Wildcard {
|
|
return nil
|
|
}
|
|
|
|
if !strings.HasPrefix(resource, s3ResourcePrefix) && !strings.HasPrefix(resource, arnIAMPrefix) {
|
|
return ErrInvalidResourceFormat
|
|
}
|
|
|
|
index := strings.IndexByte(resource, Wildcard[0])
|
|
if index != -1 && index != utf8.RuneCountInString(resource)-1 {
|
|
return ErrInvalidResourceFormat
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func validateAction(action string) error {
|
|
if action == Wildcard {
|
|
return nil
|
|
}
|
|
|
|
if !strings.HasPrefix(action, s3ActionPrefix) && !strings.HasPrefix(action, iamActionPrefix) {
|
|
return ErrInvalidActionFormat
|
|
}
|
|
|
|
index := strings.IndexByte(action, Wildcard[0])
|
|
if index != -1 && index != utf8.RuneCountInString(action)-1 {
|
|
return ErrInvalidActionFormat
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func splitGroupedConditions(groupedConditions []GroupedConditions) [][]chain.Condition {
|
|
var orConditions []chain.Condition
|
|
commonConditions := make([]chain.Condition, 0, len(groupedConditions))
|
|
for _, grouped := range groupedConditions {
|
|
if grouped.Any {
|
|
orConditions = append(orConditions, grouped.Conditions...)
|
|
} else {
|
|
commonConditions = append(commonConditions, grouped.Conditions...)
|
|
}
|
|
}
|
|
|
|
if len(orConditions) == 0 {
|
|
return [][]chain.Condition{commonConditions}
|
|
}
|
|
|
|
res := make([][]chain.Condition, len(orConditions))
|
|
for i, condition := range orConditions {
|
|
res[i] = append([]chain.Condition{condition}, commonConditions...)
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
func formStatus(statement Statement) chain.Status {
|
|
status := chain.AccessDenied
|
|
if statement.Effect == AllowEffect {
|
|
status = chain.Allow
|
|
}
|
|
|
|
return status
|
|
}
|