3

我想做一个预签名的 POST 以将文件上传到 AWS S3 存储桶- 这将如何在 Go 中完成？

请注意，这与使用 PUT 进行预签名上传不同。

4

4 回答 4

5

因此，为了帮助其他人，我将自己回答这个问题，并提供一些代码来帮助可能有同样问题的其他人。

可在此处找到用于呈现预签名 POST 表单的 Google App Engine 示例网络应用程序。

我创建的一个小型库在 Go 中执行预签名的 POST。

简而言之，对公开读取的 Amazon S3 存储桶执行预签名 POST，您需要：

1. 将 S3 存储桶配置为只允许公开下载。

仅允许公共读取的示例存储桶策略。

{
    "Version": "2012-10-17",
    "Id": "akjsdhakshfjlashdf",
    "Statement": [
        {
            "Sid": "kjahsdkajhsdkjasda",
            "Effect": "Allow",
            "Principal": {
                "AWS": "*"
            },
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::BUCKETNAMEHERE/*"
        }
    ]
}

2. 为允许上传的 HTTP POST 创建一个策略。

AWS S3 文档

示例 POST 策略模板，具有将特定密钥上传到特定存储桶并允许公开读取访问权限的过期时间。

{ "expiration": "%s",
    "conditions": [
        {"bucket": "%s"},
        ["starts-with", "$key", "%s"],
        {"acl": "public-read"},

        {"x-amz-credential": "%s"},
        {"x-amz-algorithm": "AWS4-HMAC-SHA256"},
        {"x-amz-date": "%s" }
    ]
}

3. 使用 S3 存储桶所有者的凭证生成并签署策略。

AWS 文档

  • 为到期、存储桶、密钥、凭据和日期填写正确的值。
  • base64 对策略进行编码。
  • HMAC-SHA256 获取签名的策略。
  • 十六进制编码签名。

4.构造和POST多部分表单数据

AWS S3 文档

现在，您将生成一个 HTML 表单并自动获取正确的多部分表单数据请求，如上述链接中所述。

我想在 Go 中手动完成，所以这里是如何做到的。

无论哪种方式，您都需要提供在第 2 步和第 3 步中创建的 POST 策略中指定的所有部分。除了强制性字段（不在策略中）之外，您也不能在请求中包含其他字段。

还指定了字段的顺序，它们都是 HTTP POST 请求中的多部分字段。

func Upload(url string, fields Fields) error {
    var b bytes.Buffer
    w := multipart.NewWriter(&b)
    for _, f := range fields {
            fw, err := w.CreateFormField(f.Key)
            if err != nil {
                    return err
            }
            if _, err := fw.Write([]byte(f.Value)); err != nil {
                    return err
            }
    }
    w.Close()

    req, err := http.NewRequest("POST", url, &b)
    if err != nil {
            return err
    }
    req.Header.Set("Content-Type", w.FormDataContentType())

    client := &http.Client{}
    res, err := client.Do(req)
    if err != nil {
            return err
    }
    if res.StatusCode != http.StatusOK {
            err = fmt.Errorf("bad status: %s", res.Status)
    }
    return nil
}
于 2015-09-08T09:10:47.447 回答
4

这是来自https://github.com/minio/minio-go的另一种方法 ，您可能希望以一种完整的编程方式生成预签名的帖子策略。

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/minio/minio-go"
)

func main() {
    policy := minio.NewPostPolicy()
    policy.SetKey("myobject")
    policy.SetBucket("mybucket")
    policy.SetExpires(time.Now().UTC().AddDate(0, 0, 10)) // expires in 10 days
    config := minio.Config{
        AccessKeyID:     "YOUR-ACCESS-KEY-HERE",
        SecretAccessKey: "YOUR-PASSWORD-HERE",
        Endpoint:        "https://s3.amazonaws.com",
    }
    s3Client, err := minio.New(config)
    if err != nil {
        log.Fatalln(err)
    }
    m, err := s3Client.PresignedPostPolicy(policy)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("curl ")
    for k, v := range m {
        fmt.Printf("-F %s=%s ", k, v)
    }
    fmt.Printf("-F file=@/etc/bashrc ")
    fmt.Printf(config.Endpoint + "/mybucket\n")
}

步骤1：

    policy := minio.NewPostPolicy()
    policy.SetKey("myobject")
    policy.SetBucket("mybucket")
    policy.SetExpires(time.Now().UTC().AddDate(0, 0, 10)) // expires in 10 days

实例化一个新的策略结构，这个策略结构实现了以下方法。

func NewPostPolicy() *PostPolicy
func (p *PostPolicy) SetBucket(bucket string) error
func (p *PostPolicy) SetContentLength(min, max int) error
func (p *PostPolicy) SetContentType(contentType string) error
func (p *PostPolicy) SetExpires(t time.Time) error
func (p *PostPolicy) SetKey(key string) error
func (p *PostPolicy) SetKeyStartsWith(keyStartsWith string) error
func (p PostPolicy) String() string

第2步：

    m, err := s3Client.PresignedPostPolicy(policy)
    if err != nil {
        fmt.Println(err)
        return
    }

现在 PresignedPostPolicy() 采用该PostPolicy结构并返回一个“键/值”映射，该映射可用于您的 HTML 表单或 curl 命令将数据上传到 s3。

于 2015-11-07T00:38:56.647 回答
2

乍一看，POST 似乎与附加的策略和签名一起工作——专为基于浏览器的上传而设计。有关详细信息，请参阅AWS 文档。

具体来说，您需要生成一个策略并签名——然后将它们包含在 HTML 表单中，从而包含 POST 请求——以及其他所需信息。或者让浏览器为你做这件事。

在 HTML 表单 POST 上传的情况下，您只需对策略字符串进行签名。要发布到的最终 URL 可能因表单内容而异：https://bucket.s3.amazonaws.com/<depends-on-form-content>. 因此，您不能预先签署该 URL，因为您不知道它是什么。

这与您将文件放入的签名 URL 不同。您可以签名，因为您知道完整的 URL：https://bucket.s3.amazonaws.com/known-key

您可以使用适当的策略和参数构建 POST 请求，然后通过 POST 上传。但是，您需要知道表单的内容才能事先知道 URL。在这种情况下，您也可以使用预签名的 PUT URL。

至少一目了然……

于 2015-09-05T01:39:00.540 回答
0

尝试使用@murrekatt 提供的解决方案时遇到此问题并遇到“InvalidAccessKeyId”错误。

后来我发现这个问题是因为我在 lambda 中生成了预签名的 POST，而不包括x-amz-security-token在表单数据和策略中。

所以这是我在@murrekatt 和 boto3 库的帮助下写的：

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "time"

    "github.com/aws/aws-sdk-go-v2/aws"
)

type PresignedPOST struct {
    URL           string `json:"url"`
    Key           string `json:"key"`
    Policy        string `json:"policy"`
    Credential    string `json:"credential"`
    SecurityToken string `json:"securityToken,omitempty"`
    Signature     string `json:"signature"`
    Date          string `json:"date"`
}

func NewPresignedPost(input *NewPresignedPostInput) (*PresignedPOST, error) {

    // expiration time
    expirationTime := time.Now().Add(time.Second * time.Duration(input.ExpiresIn)).UTC()
    dateString := expirationTime.Format("20060102")

    // credentials string
    creds := fmt.Sprintf("%s/%s/%s/s3/aws4_request", input.Credentials.AccessKeyID, dateString, input.Region)

    // policy
    policyDoc, err := createPolicyDocument(expirationTime, input.Bucket, input.Key, creds, &input.Credentials.SessionToken, input.Conditions)
    if err != nil {
        return nil, err
    }

    // create signature
    signature := createSignature(input.Credentials.SecretAccessKey, input.Region, dateString, policyDoc)

    // url
    url := fmt.Sprintf("https://%s.s3.amazonaws.com/", input.Bucket)

    // expiration time
    dateTimeString := expirationTime.Format("20060102T150405Z")

    // post
    post := &PresignedPOST{
        Key:           input.Key,
        Policy:        policyDoc,
        Signature:     signature,
        URL:           url,
        Credential:    creds,
        SecurityToken: input.Credentials.SessionToken,
        Date:          dateTimeString,
    }

    return post, nil
}

type NewPresignedPostInput struct {
    // Key name
    Key string

    // Creds
    Credentials aws.Credentials

    // Region
    Region string

    // The name of the bucket to presign the post to
    Bucket string

    // Expiration -  The number of seconds the presigned post is valid for.
    ExpiresIn int64

    // A list of conditions to include in the policy. Each element can be either a list or a structure.
    // For example:
    // [
    //      {"acl": "public-read"}, ["content-length-range", 2, 5], ["starts-with", "$success_action_redirect", ""]
    // ]
    Conditions []interface{}
}

// helpers
func createPolicyDocument(expirationTime time.Time, bucket string, key string, credentialString string, securityToken *string, extraConditions []interface{}) (string, error) {

    doc := map[string]interface{}{}
    doc["expiration"] = expirationTime.Format("2006-01-02T15:04:05.000Z")

    // conditions
    conditions := []interface{}{}
    conditions = append(conditions, map[string]string{
        "bucket": bucket,
    })

    conditions = append(conditions, []string{
        "starts-with", "$key", key,
    })

    conditions = append(conditions, map[string]string{
        "x-amz-credential": credentialString,
    })

    if securityToken != nil {
        conditions = append(conditions, map[string]string{
            "x-amz-security-token": *securityToken,
        })
    }

    conditions = append(conditions, map[string]string{
        "x-amz-algorithm": "AWS4-HMAC-SHA256",
    })

    conditions = append(conditions, map[string]string{
        "x-amz-date": expirationTime.Format("20060102T150405Z"),
    })

    // other conditions
    conditions = append(conditions, extraConditions...)

    doc["conditions"] = conditions

    // base64 encoded json string
    jsonBytes, err := json.Marshal(doc)
    if err != nil {
        return "", err
    }

    return base64.StdEncoding.EncodeToString(jsonBytes), nil
}

func createSignature(secretKey string, region string, dateString string, stringToSign string) string {

    // Helper to make the HMAC-SHA256.
    makeHmac := func(key []byte, data []byte) []byte {
        hash := hmac.New(sha256.New, key)
        hash.Write(data)
        return hash.Sum(nil)
    }

    h1 := makeHmac([]byte("AWS4"+secretKey), []byte(dateString))
    h2 := makeHmac(h1, []byte(region))
    h3 := makeHmac(h2, []byte("s3"))
    h4 := makeHmac(h3, []byte("aws4_request"))
    signature := makeHmac(h4, []byte(stringToSign))
    return hex.EncodeToString(signature)
}

用法

// credentials
conf, _ := config.LoadDefaultConfig(c.Context)
awsCreds, _ := conf.Credentials.Retrieve(c.Context)

// generate presigned post
post, err := s3util.NewPresignedPost(&s3util.NewPresignedPostInput{
    Key:         <file-name>,
    Credentials: awsCreds,
    Region:      <region>,
    Bucket:      <bucket-name>,
    ExpiresIn:   <expiration>,
    Conditions: []interface{}{
        []interface{}{"content-length-range", 1, <size-limit>},
    },
})

然后在前端，在 POST 表单数据中使用返回的 json

key:                    <key>
X-Amz-Credential:       <credential>
X-Amz-Security-Token:   <securityToken>     // if provided
X-Amz-Algorithm:        AWS4-HMAC-SHA256
X-Amz-Date:             <date>
Policy:                 <policy>
X-Amz-Signature:        <signature>
file:                   <file>
于 2021-06-02T22:12:53.787 回答