2015-10-05 01:31:07 +02:00
|
|
|
/*
|
2017-03-18 19:28:41 +01:00
|
|
|
* Minio Cloud Storage, (C) 2015, 2016, 2017 Minio, Inc.
|
2015-10-05 01:31:07 +02:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2016-08-19 01:23:42 +02:00
|
|
|
package cmd
|
2015-10-02 08:51:17 +02:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
2016-12-01 03:30:59 +01:00
|
|
|
"errors"
|
2015-10-02 08:51:17 +02:00
|
|
|
"fmt"
|
2016-12-03 02:00:33 +01:00
|
|
|
"net/http"
|
2015-10-02 08:51:17 +02:00
|
|
|
"reflect"
|
2016-12-01 03:30:59 +01:00
|
|
|
"strconv"
|
2016-02-16 02:42:39 +01:00
|
|
|
"strings"
|
2015-10-02 08:51:17 +02:00
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
2017-01-18 21:24:34 +01:00
|
|
|
// startWithConds - map which indicates if a given condition supports starts-with policy operator
|
|
|
|
var startsWithConds = map[string]bool{
|
2018-12-28 23:04:39 +01:00
|
|
|
"$acl": true,
|
|
|
|
"$bucket": false,
|
|
|
|
"$cache-control": true,
|
|
|
|
"$content-type": true,
|
|
|
|
"$content-disposition": true,
|
|
|
|
"$content-encoding": true,
|
|
|
|
"$expires": true,
|
|
|
|
"$key": true,
|
2017-01-18 21:24:34 +01:00
|
|
|
"$success_action_redirect": true,
|
|
|
|
"$redirect": true,
|
|
|
|
"$success_action_status": false,
|
|
|
|
"$x-amz-algorithm": false,
|
|
|
|
"$x-amz-credential": false,
|
|
|
|
"$x-amz-date": false,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add policy conditionals.
|
|
|
|
const (
|
|
|
|
policyCondEqual = "eq"
|
|
|
|
policyCondStartsWith = "starts-with"
|
|
|
|
policyCondContentLength = "content-length-range"
|
|
|
|
)
|
|
|
|
|
2015-10-02 08:51:17 +02:00
|
|
|
// toString - Safely convert interface to string without causing panic.
|
|
|
|
func toString(val interface{}) string {
|
|
|
|
switch v := val.(type) {
|
|
|
|
case string:
|
|
|
|
return v
|
2018-08-06 19:26:40 +02:00
|
|
|
default:
|
|
|
|
return ""
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-03 02:00:33 +01:00
|
|
|
// toLowerString - safely convert interface to lower string
|
|
|
|
func toLowerString(val interface{}) string {
|
|
|
|
return strings.ToLower(toString(val))
|
|
|
|
}
|
|
|
|
|
2015-10-02 08:51:17 +02:00
|
|
|
// toInteger _ Safely convert interface to integer without causing panic.
|
2016-12-01 03:30:59 +01:00
|
|
|
func toInteger(val interface{}) (int64, error) {
|
2015-10-02 08:51:17 +02:00
|
|
|
switch v := val.(type) {
|
2016-11-21 13:15:26 +01:00
|
|
|
case float64:
|
2016-12-01 03:30:59 +01:00
|
|
|
return int64(v), nil
|
2016-11-21 13:15:26 +01:00
|
|
|
case int64:
|
2016-12-01 03:30:59 +01:00
|
|
|
return v, nil
|
2016-11-21 13:15:26 +01:00
|
|
|
case int:
|
2016-12-01 03:30:59 +01:00
|
|
|
return int64(v), nil
|
|
|
|
case string:
|
|
|
|
i, err := strconv.Atoi(v)
|
|
|
|
return int64(i), err
|
2018-08-06 19:26:40 +02:00
|
|
|
default:
|
|
|
|
return 0, errors.New("Invalid number format")
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// isString - Safely check if val is of type string without causing panic.
|
|
|
|
func isString(val interface{}) bool {
|
2018-08-06 19:26:40 +02:00
|
|
|
_, ok := val.(string)
|
|
|
|
return ok
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
|
2016-10-25 08:47:03 +02:00
|
|
|
// ContentLengthRange - policy content-length-range field.
|
|
|
|
type contentLengthRange struct {
|
2016-11-21 13:15:26 +01:00
|
|
|
Min int64
|
|
|
|
Max int64
|
2016-10-25 08:47:03 +02:00
|
|
|
Valid bool // If content-length-range was part of policy
|
|
|
|
}
|
|
|
|
|
2015-10-02 08:51:17 +02:00
|
|
|
// PostPolicyForm provides strict static type conversion and validation for Amazon S3's POST policy JSON string.
|
|
|
|
type PostPolicyForm struct {
|
|
|
|
Expiration time.Time // Expiration date and time of the POST policy.
|
|
|
|
Conditions struct { // Conditional policy structure.
|
|
|
|
Policies map[string]struct {
|
|
|
|
Operator string
|
|
|
|
Value string
|
|
|
|
}
|
2016-10-25 08:47:03 +02:00
|
|
|
ContentLengthRange contentLengthRange
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-26 19:15:57 +02:00
|
|
|
// parsePostPolicyForm - Parse JSON policy string into typed POostPolicyForm structure.
|
2017-06-22 04:53:09 +02:00
|
|
|
func parsePostPolicyForm(policy string) (ppf PostPolicyForm, e error) {
|
2015-10-02 08:51:17 +02:00
|
|
|
// Convert po into interfaces and
|
|
|
|
// perform strict type conversion using reflection.
|
|
|
|
var rawPolicy struct {
|
|
|
|
Expiration string `json:"expiration"`
|
|
|
|
Conditions []interface{} `json:"conditions"`
|
|
|
|
}
|
|
|
|
|
2016-04-29 23:24:10 +02:00
|
|
|
err := json.Unmarshal([]byte(policy), &rawPolicy)
|
|
|
|
if err != nil {
|
2017-06-22 04:53:09 +02:00
|
|
|
return ppf, err
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
parsedPolicy := PostPolicyForm{}
|
|
|
|
|
|
|
|
// Parse expiry time.
|
2016-04-29 23:24:10 +02:00
|
|
|
parsedPolicy.Expiration, err = time.Parse(time.RFC3339Nano, rawPolicy.Expiration)
|
|
|
|
if err != nil {
|
2017-06-22 04:53:09 +02:00
|
|
|
return ppf, err
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
parsedPolicy.Conditions.Policies = make(map[string]struct {
|
|
|
|
Operator string
|
|
|
|
Value string
|
|
|
|
})
|
|
|
|
|
|
|
|
// Parse conditions.
|
|
|
|
for _, val := range rawPolicy.Conditions {
|
|
|
|
switch condt := val.(type) {
|
|
|
|
case map[string]interface{}: // Handle key:value map types.
|
|
|
|
for k, v := range condt {
|
|
|
|
if !isString(v) { // Pre-check value type.
|
|
|
|
// All values must be of type string.
|
2016-11-16 03:14:23 +01:00
|
|
|
return parsedPolicy, fmt.Errorf("Unknown type %s of conditional field value %s found in POST policy form", reflect.TypeOf(condt).String(), condt)
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
// {"acl": "public-read" } is an alternate way to indicate - [ "eq", "$acl", "public-read" ]
|
|
|
|
// In this case we will just collapse this into "eq" for all use cases.
|
2016-12-03 02:00:33 +01:00
|
|
|
parsedPolicy.Conditions.Policies["$"+strings.ToLower(k)] = struct {
|
2015-10-02 08:51:17 +02:00
|
|
|
Operator string
|
|
|
|
Value string
|
|
|
|
}{
|
2017-01-18 21:24:34 +01:00
|
|
|
Operator: policyCondEqual,
|
2015-10-02 08:51:17 +02:00
|
|
|
Value: toString(v),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case []interface{}: // Handle array types.
|
|
|
|
if len(condt) != 3 { // Return error if we have insufficient elements.
|
2016-11-16 03:14:23 +01:00
|
|
|
return parsedPolicy, fmt.Errorf("Malformed conditional fields %s of type %s found in POST policy form", condt, reflect.TypeOf(condt).String())
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
2016-12-03 02:00:33 +01:00
|
|
|
switch toLowerString(condt[0]) {
|
2017-01-18 21:24:34 +01:00
|
|
|
case policyCondEqual, policyCondStartsWith:
|
2015-10-02 08:51:17 +02:00
|
|
|
for _, v := range condt { // Pre-check all values for type.
|
|
|
|
if !isString(v) {
|
|
|
|
// All values must be of type string.
|
2016-11-16 03:14:23 +01:00
|
|
|
return parsedPolicy, fmt.Errorf("Unknown type %s of conditional field value %s found in POST policy form", reflect.TypeOf(condt).String(), condt)
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
}
|
2016-12-03 02:00:33 +01:00
|
|
|
operator, matchType, value := toLowerString(condt[0]), toLowerString(condt[1]), toString(condt[2])
|
2015-10-02 08:51:17 +02:00
|
|
|
parsedPolicy.Conditions.Policies[matchType] = struct {
|
|
|
|
Operator string
|
|
|
|
Value string
|
|
|
|
}{
|
|
|
|
Operator: operator,
|
|
|
|
Value: value,
|
|
|
|
}
|
2017-01-18 21:24:34 +01:00
|
|
|
case policyCondContentLength:
|
2016-12-01 03:30:59 +01:00
|
|
|
min, err := toInteger(condt[1])
|
|
|
|
if err != nil {
|
|
|
|
return parsedPolicy, err
|
|
|
|
}
|
|
|
|
|
|
|
|
max, err := toInteger(condt[2])
|
|
|
|
if err != nil {
|
|
|
|
return parsedPolicy, err
|
|
|
|
}
|
|
|
|
|
2016-11-21 13:15:26 +01:00
|
|
|
parsedPolicy.Conditions.ContentLengthRange = contentLengthRange{
|
2016-12-01 03:30:59 +01:00
|
|
|
Min: min,
|
|
|
|
Max: max,
|
2016-11-21 13:15:26 +01:00
|
|
|
Valid: true,
|
|
|
|
}
|
2015-10-02 08:51:17 +02:00
|
|
|
default:
|
|
|
|
// Condition should be valid.
|
2016-11-16 03:14:23 +01:00
|
|
|
return parsedPolicy, fmt.Errorf("Unknown type %s of conditional field value %s found in POST policy form",
|
|
|
|
reflect.TypeOf(condt).String(), condt)
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
default:
|
2016-11-16 03:14:23 +01:00
|
|
|
return parsedPolicy, fmt.Errorf("Unknown field %s of type %s found in POST policy form",
|
|
|
|
condt, reflect.TypeOf(condt).String())
|
2015-10-02 08:51:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return parsedPolicy, nil
|
|
|
|
}
|
2016-02-16 02:42:39 +01:00
|
|
|
|
2016-12-03 02:00:33 +01:00
|
|
|
// checkPolicyCond returns a boolean to indicate if a condition is satisified according
|
|
|
|
// to the passed operator
|
|
|
|
func checkPolicyCond(op string, input1, input2 string) bool {
|
|
|
|
switch op {
|
2017-01-18 21:24:34 +01:00
|
|
|
case policyCondEqual:
|
2016-12-03 02:00:33 +01:00
|
|
|
return input1 == input2
|
2017-01-18 21:24:34 +01:00
|
|
|
case policyCondStartsWith:
|
2016-12-03 02:00:33 +01:00
|
|
|
return strings.HasPrefix(input1, input2)
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2016-03-13 01:08:15 +01:00
|
|
|
// checkPostPolicy - apply policy conditions and validate input values.
|
2016-12-03 02:00:33 +01:00
|
|
|
// (http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html)
|
2017-03-13 22:41:13 +01:00
|
|
|
func checkPostPolicy(formValues http.Header, postPolicyForm PostPolicyForm) APIErrorCode {
|
2016-12-03 02:00:33 +01:00
|
|
|
// Check if policy document expiry date is still not reached
|
2017-03-18 19:28:41 +01:00
|
|
|
if !postPolicyForm.Expiration.After(UTCNow()) {
|
2016-03-31 05:04:51 +02:00
|
|
|
return ErrPolicyAlreadyExpired
|
2016-02-16 02:42:39 +01:00
|
|
|
}
|
2016-12-03 02:00:33 +01:00
|
|
|
|
|
|
|
// Flag to indicate if all policies conditions are satisfied
|
|
|
|
condPassed := true
|
|
|
|
|
|
|
|
// Iterate over policy conditions and check them against received form fields
|
|
|
|
for cond, v := range postPolicyForm.Conditions.Policies {
|
|
|
|
// Form fields names are in canonical format, convert conditions names
|
|
|
|
// to canonical for simplification purpose, so `$key` will become `Key`
|
|
|
|
formCanonicalName := http.CanonicalHeaderKey(strings.TrimPrefix(cond, "$"))
|
|
|
|
// Operator for the current policy condition
|
|
|
|
op := v.Operator
|
|
|
|
// If the current policy condition is known
|
|
|
|
if startsWithSupported, condFound := startsWithConds[cond]; condFound {
|
|
|
|
// Check if the current condition supports starts-with operator
|
2017-01-18 21:24:34 +01:00
|
|
|
if op == policyCondStartsWith && !startsWithSupported {
|
2016-12-03 02:00:33 +01:00
|
|
|
return ErrAccessDenied
|
|
|
|
}
|
|
|
|
// Check if current policy condition is satisfied
|
2017-03-13 22:41:13 +01:00
|
|
|
condPassed = checkPolicyCond(op, formValues.Get(formCanonicalName), v.Value)
|
2016-12-03 02:00:33 +01:00
|
|
|
} else {
|
|
|
|
// This covers all conditions X-Amz-Meta-* and X-Amz-*
|
|
|
|
if strings.HasPrefix(cond, "$x-amz-meta-") || strings.HasPrefix(cond, "$x-amz-") {
|
|
|
|
// Check if policy condition is satisfied
|
2017-03-13 22:41:13 +01:00
|
|
|
condPassed = checkPolicyCond(op, formValues.Get(formCanonicalName), v.Value)
|
2016-12-03 02:00:33 +01:00
|
|
|
}
|
2016-02-16 02:42:39 +01:00
|
|
|
}
|
2016-12-03 02:39:21 +01:00
|
|
|
// Check if current policy condition is satisfied, quit immediately otherwise
|
2016-12-03 02:00:33 +01:00
|
|
|
if !condPassed {
|
2016-07-28 02:51:55 +02:00
|
|
|
return ErrAccessDenied
|
2016-02-16 02:42:39 +01:00
|
|
|
}
|
|
|
|
}
|
2016-12-03 02:00:33 +01:00
|
|
|
|
2016-03-31 05:04:51 +02:00
|
|
|
return ErrNone
|
2016-02-16 02:42:39 +01:00
|
|
|
}
|