Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 functional_1_5_test.go //go:build go1.5 // +build go1.5 package v4_test import ( "fmt" "net/http" "testing" "time" "github.com/aws/aws-sdk-go/aws/signer/v4" "github.com/aws/aws-sdk-go/awstesting/unit" ) func TestStandaloneSign(t testing.T) { creds := unit.Session.Config.Credentials signer := v4.NewSigner(creds) for _, c := range standaloneSignCases { host := fmt.Sprintf("https://%s.%s.%s.amazonaws.com", c.SubDomain, c.Region, c.Service) req, err := http.NewRequest("GET", host, nil) if err != nil { t.Errorf("expected no error, but received %v", err) } // URL.EscapedPath() will be used by the signer to get the // escaped form of the request's URI path. req.URL.Path = c.OrigURI req.URL.RawQuery = c.OrigQuery _, err = signer.Sign(req, nil, c.Service, c.Region, time.Unix(0, 0)) if err != nil { t.Errorf("expected no error, but received %v", err) } actual := req.Header.Get("Authorization") if e, a := c.ExpSig, actual; e != a { t.Errorf("expected %v, but received %v", e, a) } if e, a := c.OrigURI, req.URL.Path; e != a { t.Errorf("expected %v, but received %v", e, a) } if e, a := c.EscapedURI, req.URL.EscapedPath(); e != a { t.Errorf("expected %v, but received %v", e, a) } } } func TestStandaloneSign_RawPath(t testing.T) { creds := unit.Session.Config.Credentials signer := v4.NewSigner(creds) for _, c := range standaloneSignCases { host := fmt.Sprintf("https://%s.%s.%s.amazonaws.com", c.SubDomain, c.Region, c.Service) req, err := http.NewRequest("GET", host, nil) if err != nil { t.Errorf("expected no error, but received %v", err) } // URL.EscapedPath() will be used by the signer to get the // escaped form of the request's URI path. req.URL.Path = c.OrigURI req.URL.RawPath = c.EscapedURI req.URL.RawQuery = c.OrigQuery _, err = signer.Sign(req, nil, c.Service, c.Region, time.Unix(0, 0)) if err != nil { t.Errorf("expected no error, but received %v", err) } actual := req.Header.Get("Authorization") if e, a := c.ExpSig, actual; e != a { t.Errorf("expected %v, but received %v", e, a) } if e, a := c.OrigURI, req.URL.Path; e != a { t.Errorf("expected %v, but received %v", e, a) } if e, a := c.EscapedURI, req.URL.EscapedPath(); e != a { t.Errorf("expected %v, but received %v", e, a) } } }	2.27 KB	2025-05-25 12:27
📄 functional_test.go package v4_test import ( "net/http" "net/url" "reflect" "strings" "testing" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/aws/signer/v4" "github.com/aws/aws-sdk-go/awstesting/unit" "github.com/aws/aws-sdk-go/service/s3" ) var standaloneSignCases = []struct { OrigURI string OrigQuery string Region, Service, SubDomain string ExpSig string EscapedURI string }{ { OrigURI: `/logs-/_search`, OrigQuery: `pretty=true`, Region: "us-west-2", Service: "es", SubDomain: "hostname-clusterkey", EscapedURI: `/logs-%2A/_search`, ExpSig: `AWS4-HMAC-SHA256 Credential=AKID/19700101/us-west-2/es/aws4_request, SignedHeaders=host;x-amz-date;x-amz-security-token, Signature=79d0760751907af16f64a537c1242416dacf51204a7dd5284492d15577973b91`, }, } func epochTime() time.Time { return time.Unix(0, 0) } func TestPresignHandler(t testing.T) { svc := s3.New(unit.Session) svc.Handlers.Sign.SwapNamed(request.NamedHandler{ Name: v4.SignRequestHandler.Name, Fn: func(r request.Request) { v4.SignSDKRequestWithCurrentTime(r, epochTime) }, }) req, _ := svc.PutObjectRequest(&s3.PutObjectInput{ Bucket: aws.String("bucket"), Key: aws.String("key"), ContentDisposition: aws.String("a+b c$d"), ACL: aws.String("public-read"), }) req.Time = epochTime() urlstr, err := req.Presign(5 time.Minute) if err != nil { t.Fatalf("expect no error, got %v", err) } expectedHost := "bucket.s3.mock-region.amazonaws.com" expectedDate := "19700101T000000Z" expectedHeaders := "content-disposition;host;x-amz-acl" expectedSig := "2d76a414208c0eac2a23ef9c834db9635ecd5a0fbb447a00ad191f82d854f55b" expectedCred := "AKID/19700101/mock-region/s3/aws4_request" u, _ := url.Parse(urlstr) urlQ := u.Query() if e, a := expectedHost, u.Host; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedSig, urlQ.Get("X-Amz-Signature"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedCred, urlQ.Get("X-Amz-Credential"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedHeaders, urlQ.Get("X-Amz-SignedHeaders"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedDate, urlQ.Get("X-Amz-Date"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "300", urlQ.Get("X-Amz-Expires"); e != a { t.Errorf("expect %v, got %v", e, a) } if a := urlQ.Get("X-Amz-Content-Sha256"); len(a) != 0 { t.Errorf("expect no content sha256 got %v", a) } if e, a := "+", urlstr; strings.Contains(a, e) { // + encoded as %20 t.Errorf("expect %v not to be in %v", e, a) } } func TestPresignRequest(t testing.T) { svc := s3.New(unit.Session) svc.Handlers.Sign.SwapNamed(request.NamedHandler{ Name: v4.SignRequestHandler.Name, Fn: func(r request.Request) { v4.SignSDKRequestWithCurrentTime(r, epochTime) }, }) req, _ := svc.PutObjectRequest(&s3.PutObjectInput{ Bucket: aws.String("bucket"), Key: aws.String("key"), ContentDisposition: aws.String("a+b c$d"), ACL: aws.String("public-read"), }) req.Time = epochTime() urlstr, headers, err := req.PresignRequest(5 * time.Minute) if err != nil { t.Fatalf("expect no error, got %v", err) } expectedHost := "bucket.s3.mock-region.amazonaws.com" expectedDate := "19700101T000000Z" expectedHeaders := "content-disposition;host;x-amz-acl" expectedSig := "2d76a414208c0eac2a23ef9c834db9635ecd5a0fbb447a00ad191f82d854f55b" expectedCred := "AKID/19700101/mock-region/s3/aws4_request" expectedHeaderMap := http.Header{ "x-amz-acl": []string{"public-read"}, "content-disposition": []string{"a+b c$d"}, } u, _ := url.Parse(urlstr) urlQ := u.Query() if e, a := expectedHost, u.Host; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedSig, urlQ.Get("X-Amz-Signature"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedCred, urlQ.Get("X-Amz-Credential"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedHeaders, urlQ.Get("X-Amz-SignedHeaders"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedDate, urlQ.Get("X-Amz-Date"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedHeaderMap, headers; !reflect.DeepEqual(e, a) { t.Errorf("expect %v, got %v", e, a) } if e, a := "300", urlQ.Get("X-Amz-Expires"); e != a { t.Errorf("expect %v, got %v", e, a) } if a := urlQ.Get("X-Amz-Content-Sha256"); len(a) != 0 { t.Errorf("expect no content sha256 got %v", a) } if e, a := "+", urlstr; strings.Contains(a, e) { // + encoded as %20 t.Errorf("expect %v not to be in %v", e, a) } } func TestStandaloneSign_CustomURIEscape(t testing.T) { var expectSig = `AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/es/aws4_request, SignedHeaders=host;x-amz-date;x-amz-security-token, Signature=6601e883cc6d23871fd6c2a394c5677ea2b8c82b04a6446786d64cd74f520967` creds := unit.Session.Config.Credentials signer := v4.NewSigner(creds, func(s v4.Signer) { s.DisableURIPathEscaping = true }) host := "https://subdomain.us-east-1.es.amazonaws.com" req, err := http.NewRequest("GET", host, nil) if err != nil { t.Fatalf("expect no error, got %v", err) } req.URL.Path = `/log-/_search` req.URL.Opaque = "//subdomain.us-east-1.es.amazonaws.com/log-%2A/_search" _, err = signer.Sign(req, nil, "es", "us-east-1", epochTime()) if err != nil { t.Fatalf("expect no error, got %v", err) } actual := req.Header.Get("Authorization") if e, a := expectSig, actual; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestStandaloneSign_WithPort(t testing.T) { cases := []struct { description string url string expectedSig string }{ { "default HTTPS port", "https://estest.us-east-1.es.amazonaws.com:443/_search", "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/es/aws4_request, SignedHeaders=host;x-amz-date;x-amz-security-token, Signature=e573fc9aa3a156b720976419319be98fb2824a3abc2ddd895ecb1d1611c6a82d", }, { "default HTTP port", "http://example.com:80/_search", "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/es/aws4_request, SignedHeaders=host;x-amz-date;x-amz-security-token, Signature=54ebe60c4ae03a40948b849e13c333523235f38002e2807059c64a9a8c7cb951", }, { "non-standard HTTP port", "http://example.com:9200/_search", "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/es/aws4_request, SignedHeaders=host;x-amz-date;x-amz-security-token, Signature=cd9d926a460f8d3b58b57beadbd87666dc667e014c0afaa4cea37b2867f51b4f", }, { "non-standard HTTPS port", "https://example.com:9200/_search", "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/es/aws4_request, SignedHeaders=host;x-amz-date;x-amz-security-token, Signature=cd9d926a460f8d3b58b57beadbd87666dc667e014c0afaa4cea37b2867f51b4f", }, } for _, c := range cases { signer := v4.NewSigner(unit.Session.Config.Credentials) req, _ := http.NewRequest("GET", c.url, nil) _, err := signer.Sign(req, nil, "es", "us-east-1", epochTime()) if err != nil { t.Fatalf("expect no error, got %v", err) } actual := req.Header.Get("Authorization") if e, a := c.expectedSig, actual; e != a { t.Errorf("%s, expect %v, got %v", c.description, e, a) } } } func TestStandalonePresign_WithPort(t testing.T) { cases := []struct { description string url string expectedSig string }{ { "default HTTPS port", "https://estest.us-east-1.es.amazonaws.com:443/_search", "0abcf61a351063441296febf4b485734d780634fba8cf1e7d9769315c35255d6", }, { "default HTTP port", "http://example.com:80/_search", "fce9976dd6c849c21adfa6d3f3e9eefc651d0e4a2ccd740d43efddcccfdc8179", }, { "non-standard HTTP port", "http://example.com:9200/_search", "f33c25a81c735e42bef35ed5e9f720c43940562e3e616ff0777bf6dde75249b0", }, { "non-standard HTTPS port", "https://example.com:9200/_search", "f33c25a81c735e42bef35ed5e9f720c43940562e3e616ff0777bf6dde75249b0", }, } for _, c := range cases { signer := v4.NewSigner(unit.Session.Config.Credentials) req, _ := http.NewRequest("GET", c.url, nil) _, err := signer.Presign(req, nil, "es", "us-east-1", 5time.Minute, epochTime()) if err != nil { t.Fatalf("expect no error, got %v", err) } actual := req.URL.Query().Get("X-Amz-Signature") if e, a := c.expectedSig, actual; e != a { t.Errorf("%s, expect %v, got %v", c.description, e, a) } } }	8.41 KB	2025-05-25 12:27
📄 header_rules.go package v4 import ( "github.com/aws/aws-sdk-go/internal/strings" ) // validator houses a set of rule needed for validation of a // string value type rules []rule // rule interface allows for more flexible rules and just simply // checks whether or not a value adheres to that rule type rule interface { IsValid(value string) bool } // IsValid will iterate through all rules and see if any rules // apply to the value and supports nested rules func (r rules) IsValid(value string) bool { for _, rule := range r { if rule.IsValid(value) { return true } } return false } // mapRule generic rule for maps type mapRule map[string]struct{} // IsValid for the map rule satisfies whether it exists in the map func (m mapRule) IsValid(value string) bool { _, ok := m[value] return ok } // allowList is a generic rule for allow listing type allowList struct { rule } // IsValid for allow list checks if the value is within the allow list func (w allowList) IsValid(value string) bool { return w.rule.IsValid(value) } // excludeList is a generic rule for exclude listing type excludeList struct { rule } // IsValid for exclude list checks if the value is within the exclude list func (b excludeList) IsValid(value string) bool { return !b.rule.IsValid(value) } type patterns []string // IsValid for patterns checks each pattern and returns if a match has // been found func (p patterns) IsValid(value string) bool { for _, pattern := range p { if strings.HasPrefixFold(value, pattern) { return true } } return false } // inclusiveRules rules allow for rules to depend on one another type inclusiveRules []rule // IsValid will return true if all rules are true func (r inclusiveRules) IsValid(value string) bool { for _, rule := range r { if !rule.IsValid(value) { return false } } return true }	1.79 KB	2025-05-25 12:27
📄 header_rules_test.go package v4 import ( "testing" ) func TestRuleCheckWhitelist(t testing.T) { w := allowList{ mapRule{ "Cache-Control": struct{}{}, }, } if !w.IsValid("Cache-Control") { t.Error("expected true value") } if w.IsValid("Cache-") { t.Error("expected false value") } } func TestRuleCheckBlacklist(t testing.T) { b := excludeList{ mapRule{ "Cache-Control": struct{}{}, }, } if b.IsValid("Cache-Control") { t.Error("expected false value") } if !b.IsValid("Cache-") { t.Error("expected true value") } } func TestRuleCheckPattern(t testing.T) { p := patterns{"X-Amz-Meta-"} if !p.IsValid("X-Amz-Meta-") { t.Error("expected true value") } if !p.IsValid("X-Amz-Meta-Star") { t.Error("expected true value") } if p.IsValid("Cache-") { t.Error("expected false value") } } func TestRuleComplexWhitelist(t testing.T) { w := rules{ allowList{ mapRule{ "Cache-Control": struct{}{}, }, }, patterns{"X-Amz-Meta-"}, } r := rules{ inclusiveRules{patterns{"X-Amz-"}, excludeList{w}}, } if !r.IsValid("X-Amz-Blah") { t.Error("expected true value") } if r.IsValid("X-Amz-Meta-") { t.Error("expected false value") } if r.IsValid("X-Amz-Meta-Star") { t.Error("expected false value") } if r.IsValid("Cache-Control") { t.Error("expected false value") } }	1.29 KB	2025-05-25 12:27
📄 headers_test.go //go:build go1.7 // +build go1.7 package v4 import "testing" func TestAllowedQueryHoisting(t testing.T) { cases := map[string]struct { Header string ExpectHoist bool }{ "object-lock": { Header: "X-Amz-Object-Lock-Mode", ExpectHoist: false, }, "s3 metadata": { Header: "X-Amz-Meta-SomeName", ExpectHoist: false, }, "another header": { Header: "X-Amz-SomeOtherHeader", ExpectHoist: true, }, "non X-AMZ header": { Header: "X-SomeOtherHeader", ExpectHoist: false, }, } for name, c := range cases { t.Run(name, func(t testing.T) { if e, a := c.ExpectHoist, allowedQueryHoisting.IsValid(c.Header); e != a { t.Errorf("expect hoist %v, was %v", e, a) } }) } }	746 B	2025-05-25 12:27
📄 options.go package v4 // WithUnsignedPayload will enable and set the UnsignedPayload field to // true of the signer. func WithUnsignedPayload(v4 *Signer) { v4.UnsignedPayload = true }	175 B	2025-05-25 12:27
📄 request_context_go1.5.go //go:build !go1.7 // +build !go1.7 package v4 import ( "net/http" "github.com/aws/aws-sdk-go/aws" ) func requestContext(r *http.Request) aws.Context { return aws.BackgroundContext() }	191 B	2025-05-25 12:27
📄 request_context_go1.7.go //go:build go1.7 // +build go1.7 package v4 import ( "net/http" "github.com/aws/aws-sdk-go/aws" ) func requestContext(r *http.Request) aws.Context { return r.Context() }	177 B	2025-05-25 12:27
📄 stream.go package v4 import ( "encoding/hex" "strings" "time" "github.com/aws/aws-sdk-go/aws/credentials" ) type credentialValueProvider interface { Get() (credentials.Value, error) } // StreamSigner implements signing of event stream encoded payloads type StreamSigner struct { region string service string credentials credentialValueProvider prevSig []byte } // NewStreamSigner creates a SigV4 signer used to sign Event Stream encoded messages func NewStreamSigner(region, service string, seedSignature []byte, credentials credentials.Credentials) StreamSigner { return &StreamSigner{ region: region, service: service, credentials: credentials, prevSig: seedSignature, } } // GetSignature takes an event stream encoded headers and payload and returns a signature func (s *StreamSigner) GetSignature(headers, payload []byte, date time.Time) ([]byte, error) { credValue, err := s.credentials.Get() if err != nil { return nil, err } sigKey := deriveSigningKey(s.region, s.service, credValue.SecretAccessKey, date) keyPath := buildSigningScope(s.region, s.service, date) stringToSign := buildEventStreamStringToSign(headers, payload, s.prevSig, keyPath, date) signature := hmacSHA256(sigKey, []byte(stringToSign)) s.prevSig = signature return signature, nil } func buildEventStreamStringToSign(headers, payload, prevSig []byte, scope string, date time.Time) string { return strings.Join([]string{ "AWS4-HMAC-SHA256-PAYLOAD", formatTime(date), scope, hex.EncodeToString(prevSig), hex.EncodeToString(hashSHA256(headers)), hex.EncodeToString(hashSHA256(payload)), }, "\n") }	1.6 KB	2025-05-25 12:27
📄 stream_test.go //go:build go1.7 // +build go1.7 package v4 import ( "encoding/hex" "fmt" "strings" "testing" "time" "github.com/aws/aws-sdk-go/aws/credentials" ) type periodicBadCredentials struct { call int credentials credentials.Credentials } func (p periodicBadCredentials) Get() (credentials.Value, error) { defer func() { p.call++ }() if p.call%2 == 0 { return credentials.Value{}, fmt.Errorf("credentials error") } return p.credentials.Get() } type chunk struct { headers, payload []byte } func mustDecodeHex(b []byte, err error) []byte { if err != nil { panic(err) } return b } func TestStreamingChunkSigner(t testing.T) { const ( region = "us-east-1" service = "transcribe" seedSignature = "9d9ab996c81f32c9d4e6fc166c92584f3741d1cb5ce325cd11a77d1f962c8de2" ) staticCredentials := credentials.NewStaticCredentials("AKIDEXAMPLE", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY", "") currentTime := time.Date(2019, 1, 27, 22, 37, 54, 0, time.UTC) cases := map[string]struct { credentials credentialValueProvider chunks []chunk expectedSignatures map[int]string expectedErrors map[int]string }{ "signature calculation": { credentials: staticCredentials, chunks: []chunk{ {headers: []byte("headers"), payload: []byte("payload")}, {headers: []byte("more headers"), payload: []byte("more payload")}, }, expectedSignatures: map[int]string{ 0: "681a7eaa82891536f24af7ec7e9219ee251ccd9bac2f1b981eab7c5ec8579115", 1: "07633d9d4ab4d81634a2164934d1f648c7cbc6839a8cf0773d818127a267e4d6", }, }, "signature calculation errors": { credentials: &periodicBadCredentials{credentials: staticCredentials}, chunks: []chunk{ {headers: []byte("headers"), payload: []byte("payload")}, {headers: []byte("headers"), payload: []byte("payload")}, {headers: []byte("more headers"), payload: []byte("more payload")}, {headers: []byte("more headers"), payload: []byte("more payload")}, }, expectedSignatures: map[int]string{ 1: "681a7eaa82891536f24af7ec7e9219ee251ccd9bac2f1b981eab7c5ec8579115", 3: "07633d9d4ab4d81634a2164934d1f648c7cbc6839a8cf0773d818127a267e4d6", }, expectedErrors: map[int]string{ 0: "credentials error", 2: "credentials error", }, }, } for name, tt := range cases { t.Run(name, func(t testing.T) { chunkSigner := &StreamSigner{ region: region, service: service, credentials: tt.credentials, prevSig: mustDecodeHex(hex.DecodeString(seedSignature)), } for i, chunk := range tt.chunks { var expectedError string if len(tt.expectedErrors) != 0 { _, ok := tt.expectedErrors[i] if ok { expectedError = tt.expectedErrors[i] } } signature, err := chunkSigner.GetSignature(chunk.headers, chunk.payload, currentTime) if err == nil && len(expectedError) > 0 { t.Errorf("expected error, but got nil") continue } else if err != nil && len(expectedError) == 0 { t.Errorf("expected no error, but got %v", err) continue } else if err != nil && len(expectedError) > 0 && !strings.Contains(err.Error(), expectedError) { t.Errorf("expected %v, but got %v", expectedError, err) continue } else if len(expectedError) > 0 { continue } expectedSignature, ok := tt.expectedSignatures[i] if !ok { t.Fatalf("expected signature not provided for test case") } if e, a := expectedSignature, hex.EncodeToString(signature); e != a { t.Errorf("expected %v, got %v", e, a) } } }) } }	3.51 KB	2025-05-25 12:27
📄 uri_path.go //go:build go1.5 // +build go1.5 package v4 import ( "net/url" "strings" ) func getURIPath(u *url.URL) string { var uri string if len(u.Opaque) > 0 { uri = "/" + strings.Join(strings.Split(u.Opaque, "/")[3:], "/") } else { uri = u.EscapedPath() } if len(uri) == 0 { uri = "/" } return uri }	312 B	2025-05-25 12:27
📄 v4.go // Package v4 implements signing for AWS V4 signer // // Provides request signing for request that need to be signed with // AWS V4 Signatures. // // # Standalone Signer // // Generally using the signer outside of the SDK should not require any additional // logic when using Go v1.5 or higher. The signer does this by taking advantage // of the URL.EscapedPath method. If your request URI requires additional escaping // you may need to use the URL.Opaque to define what the raw URI should be sent // to the service as. // // The signer will first check the URL.Opaque field, and use its value if set. // The signer does require the URL.Opaque field to be set in the form of: // // "//<hostname>/<path>" // // // e.g. // "//example.com/some/path" // // The leading "//" and hostname are required or the URL.Opaque escaping will // not work correctly. // // If URL.Opaque is not set the signer will fallback to the URL.EscapedPath() // method and using the returned value. If you're using Go v1.4 you must set // URL.Opaque if the URI path needs escaping. If URL.Opaque is not set with // Go v1.5 the signer will fallback to URL.Path. // // AWS v4 signature validation requires that the canonical string's URI path // element must be the URI escaped form of the HTTP request's path. // http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html // // The Go HTTP client will perform escaping automatically on the request. Some // of these escaping may cause signature validation errors because the HTTP // request differs from the URI path or query that the signature was generated. // https://golang.org/pkg/net/url/#URL.EscapedPath // // Because of this, it is recommended that when using the signer outside of the // SDK that explicitly escaping the request prior to being signed is preferable, // and will help prevent signature validation errors. This can be done by setting // the URL.Opaque or URL.RawPath. The SDK will use URL.Opaque first and then // call URL.EscapedPath() if Opaque is not set. // // If signing a request intended for HTTP2 server, and you're using Go 1.6.2 // through 1.7.4 you should use the URL.RawPath as the pre-escaped form of the // request URL. https://github.com/golang/go/issues/16847 points to a bug in // Go pre 1.8 that fails to make HTTP2 requests using absolute URL in the HTTP // message. URL.Opaque generally will force Go to make requests with absolute URL. // URL.RawPath does not do this, but RawPath must be a valid escaping of Path // or url.EscapedPath will ignore the RawPath escaping. // // Test `TestStandaloneSign` provides a complete example of using the signer // outside of the SDK and pre-escaping the URI path. package v4 import ( "crypto/hmac" "crypto/sha256" "encoding/hex" "fmt" "io" "io/ioutil" "net/http" "net/url" "sort" "strconv" "strings" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/internal/sdkio" "github.com/aws/aws-sdk-go/private/protocol/rest" ) const ( authorizationHeader = "Authorization" authHeaderSignatureElem = "Signature=" signatureQueryKey = "X-Amz-Signature" authHeaderPrefix = "AWS4-HMAC-SHA256" timeFormat = "20060102T150405Z" shortTimeFormat = "20060102" awsV4Request = "aws4_request" // emptyStringSHA256 is a SHA256 of an empty string emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855` ) var ignoredHeaders = rules{ excludeList{ mapRule{ authorizationHeader: struct{}{}, "User-Agent": struct{}{}, "X-Amzn-Trace-Id": struct{}{}, }, }, } // requiredSignedHeaders is a allow list for build canonical headers. var requiredSignedHeaders = rules{ allowList{ mapRule{ "Cache-Control": struct{}{}, "Content-Disposition": struct{}{}, "Content-Encoding": struct{}{}, "Content-Language": struct{}{}, "Content-Md5": struct{}{}, "Content-Type": struct{}{}, "Expires": struct{}{}, "If-Match": struct{}{}, "If-Modified-Since": struct{}{}, "If-None-Match": struct{}{}, "If-Unmodified-Since": struct{}{}, "Range": struct{}{}, "X-Amz-Acl": struct{}{}, "X-Amz-Copy-Source": struct{}{}, "X-Amz-Copy-Source-If-Match": struct{}{}, "X-Amz-Copy-Source-If-Modified-Since": struct{}{}, "X-Amz-Copy-Source-If-None-Match": struct{}{}, "X-Amz-Copy-Source-If-Unmodified-Since": struct{}{}, "X-Amz-Copy-Source-Range": struct{}{}, "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm": struct{}{}, "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key": struct{}{}, "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5": struct{}{}, "X-Amz-Expected-Bucket-Owner": struct{}{}, "X-Amz-Grant-Full-control": struct{}{}, "X-Amz-Grant-Read": struct{}{}, "X-Amz-Grant-Read-Acp": struct{}{}, "X-Amz-Grant-Write": struct{}{}, "X-Amz-Grant-Write-Acp": struct{}{}, "X-Amz-Metadata-Directive": struct{}{}, "X-Amz-Mfa": struct{}{}, "X-Amz-Request-Payer": struct{}{}, "X-Amz-Server-Side-Encryption": struct{}{}, "X-Amz-Server-Side-Encryption-Aws-Kms-Key-Id": struct{}{}, "X-Amz-Server-Side-Encryption-Context": struct{}{}, "X-Amz-Server-Side-Encryption-Customer-Algorithm": struct{}{}, "X-Amz-Server-Side-Encryption-Customer-Key": struct{}{}, "X-Amz-Server-Side-Encryption-Customer-Key-Md5": struct{}{}, "X-Amz-Storage-Class": struct{}{}, "X-Amz-Tagging": struct{}{}, "X-Amz-Website-Redirect-Location": struct{}{}, "X-Amz-Content-Sha256": struct{}{}, }, }, patterns{"X-Amz-Meta-"}, patterns{"X-Amz-Object-Lock-"}, } // allowedHoisting is a allow list for build query headers. The boolean value // represents whether or not it is a pattern. var allowedQueryHoisting = inclusiveRules{ excludeList{requiredSignedHeaders}, patterns{"X-Amz-"}, } // Signer applies AWS v4 signing to given request. Use this to sign requests // that need to be signed with AWS V4 Signatures. type Signer struct { // The authentication credentials the request will be signed against. // This value must be set to sign requests. Credentials credentials.Credentials // Sets the log level the signer should use when reporting information to // the logger. If the logger is nil nothing will be logged. See // aws.LogLevelType for more information on available logging levels // // By default nothing will be logged. Debug aws.LogLevelType // The logger loging information will be written to. If there the logger // is nil, nothing will be logged. Logger aws.Logger // Disables the Signer's moving HTTP header key/value pairs from the HTTP // request header to the request's query string. This is most commonly used // with pre-signed requests preventing headers from being added to the // request's query string. DisableHeaderHoisting bool // Disables the automatic escaping of the URI path of the request for the // siganture's canonical string's path. For services that do not need additional // escaping then use this to disable the signer escaping the path. // // S3 is an example of a service that does not need additional escaping. // // http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html DisableURIPathEscaping bool // Disables the automatical setting of the HTTP request's Body field with the // io.ReadSeeker passed in to the signer. This is useful if you're using a // custom wrapper around the body for the io.ReadSeeker and want to preserve // the Body value on the Request.Body. // // This does run the risk of signing a request with a body that will not be // sent in the request. Need to ensure that the underlying data of the Body // values are the same. DisableRequestBodyOverwrite bool // currentTimeFn returns the time value which represents the current time. // This value should only be used for testing. If it is nil the default // time.Now will be used. currentTimeFn func() time.Time // UnsignedPayload will prevent signing of the payload. This will only // work for services that have support for this. UnsignedPayload bool } // NewSigner returns a Signer pointer configured with the credentials and optional // option values provided. If not options are provided the Signer will use its // default configuration. func NewSigner(credentials credentials.Credentials, options ...func(Signer)) Signer { v4 := &Signer{ Credentials: credentials, } for _, option := range options { option(v4) } return v4 } type signingCtx struct { ServiceName string Region string Request http.Request Body io.ReadSeeker Query url.Values Time time.Time ExpireTime time.Duration SignedHeaderVals http.Header DisableURIPathEscaping bool credValues credentials.Value isPresign bool unsignedPayload bool bodyDigest string signedHeaders string canonicalHeaders string canonicalString string credentialString string stringToSign string signature string authorization string } // Sign signs AWS v4 requests with the provided body, service name, region the // request is made to, and time the request is signed at. The signTime allows // you to specify that a request is signed for the future, and cannot be // used until then. // // Returns a list of HTTP headers that were included in the signature or an // error if signing the request failed. Generally for signed requests this value // is not needed as the full request context will be captured by the http.Request // value. It is included for reference though. // // Sign will set the request's Body to be the `body` parameter passed in. If // the body is not already an io.ReadCloser, it will be wrapped within one. If // a `nil` body parameter passed to Sign, the request's Body field will be // also set to nil. Its important to note that this functionality will not // change the request's ContentLength of the request. // // Sign differs from Presign in that it will sign the request using HTTP // header values. This type of signing is intended for http.Request values that // will not be shared, or are shared in a way the header values on the request // will not be lost. // // The requests body is an io.ReadSeeker so the SHA256 of the body can be // generated. To bypass the signer computing the hash you can set the // "X-Amz-Content-Sha256" header with a precomputed value. The signer will // only compute the hash if the request header value is empty. func (v4 Signer) Sign(r http.Request, body io.ReadSeeker, service, region string, signTime time.Time) (http.Header, error) { return v4.signWithBody(r, body, service, region, 0, false, signTime) } // Presign signs AWS v4 requests with the provided body, service name, region // the request is made to, and time the request is signed at. The signTime // allows you to specify that a request is signed for the future, and cannot // be used until then. // // Returns a list of HTTP headers that were included in the signature or an // error if signing the request failed. For presigned requests these headers // and their values must be included on the HTTP request when it is made. This // is helpful to know what header values need to be shared with the party the // presigned request will be distributed to. // // Presign differs from Sign in that it will sign the request using query string // instead of header values. This allows you to share the Presigned Request's // URL with third parties, or distribute it throughout your system with minimal // dependencies. // // Presign also takes an exp value which is the duration the // signed request will be valid after the signing time. This is allows you to // set when the request will expire. // // The requests body is an io.ReadSeeker so the SHA256 of the body can be // generated. To bypass the signer computing the hash you can set the // "X-Amz-Content-Sha256" header with a precomputed value. The signer will // only compute the hash if the request header value is empty. // // Presigning a S3 request will not compute the body's SHA256 hash by default. // This is done due to the general use case for S3 presigned URLs is to share // PUT/GET capabilities. If you would like to include the body's SHA256 in the // presigned request's signature you can set the "X-Amz-Content-Sha256" // HTTP header and that will be included in the request's signature. func (v4 Signer) Presign(r http.Request, body io.ReadSeeker, service, region string, exp time.Duration, signTime time.Time) (http.Header, error) { return v4.signWithBody(r, body, service, region, exp, true, signTime) } func (v4 Signer) signWithBody(r http.Request, body io.ReadSeeker, service, region string, exp time.Duration, isPresign bool, signTime time.Time) (http.Header, error) { currentTimeFn := v4.currentTimeFn if currentTimeFn == nil { currentTimeFn = time.Now } ctx := &signingCtx{ Request: r, Body: body, Query: r.URL.Query(), Time: signTime, ExpireTime: exp, isPresign: isPresign, ServiceName: service, Region: region, DisableURIPathEscaping: v4.DisableURIPathEscaping, unsignedPayload: v4.UnsignedPayload, } for key := range ctx.Query { sort.Strings(ctx.Query[key]) } if ctx.isRequestSigned() { ctx.Time = currentTimeFn() ctx.handlePresignRemoval() } var err error ctx.credValues, err = v4.Credentials.GetWithContext(requestContext(r)) if err != nil { return http.Header{}, err } ctx.sanitizeHostForHeader() ctx.assignAmzQueryValues() if err := ctx.build(v4.DisableHeaderHoisting); err != nil { return nil, err } // If the request is not presigned the body should be attached to it. This // prevents the confusion of wanting to send a signed request without // the body the request was signed for attached. if !(v4.DisableRequestBodyOverwrite \|\| ctx.isPresign) { var reader io.ReadCloser if body != nil { var ok bool if reader, ok = body.(io.ReadCloser); !ok { reader = ioutil.NopCloser(body) } } r.Body = reader } if v4.Debug.Matches(aws.LogDebugWithSigning) { v4.logSigningInfo(ctx) } return ctx.SignedHeaderVals, nil } func (ctx signingCtx) sanitizeHostForHeader() { request.SanitizeHostForHeader(ctx.Request) } func (ctx signingCtx) handlePresignRemoval() { if !ctx.isPresign { return } // The credentials have expired for this request. The current signing // is invalid, and needs to be request because the request will fail. ctx.removePresign() // Update the request's query string to ensure the values stays in // sync in the case retrieving the new credentials fails. ctx.Request.URL.RawQuery = ctx.Query.Encode() } func (ctx signingCtx) assignAmzQueryValues() { if ctx.isPresign { ctx.Query.Set("X-Amz-Algorithm", authHeaderPrefix) if ctx.credValues.SessionToken != "" { ctx.Query.Set("X-Amz-Security-Token", ctx.credValues.SessionToken) } else { ctx.Query.Del("X-Amz-Security-Token") } return } if ctx.credValues.SessionToken != "" { ctx.Request.Header.Set("X-Amz-Security-Token", ctx.credValues.SessionToken) } } // SignRequestHandler is a named request handler the SDK will use to sign // service client request with using the V4 signature. var SignRequestHandler = request.NamedHandler{ Name: "v4.SignRequestHandler", Fn: SignSDKRequest, } // SignSDKRequest signs an AWS request with the V4 signature. This // request handler should only be used with the SDK's built in service client's // API operation requests. // // This function should not be used on its own, but in conjunction with // an AWS service client's API operation call. To sign a standalone request // not created by a service client's API operation method use the "Sign" or // "Presign" functions of the "Signer" type. // // If the credentials of the request's config are set to // credentials.AnonymousCredentials the request will not be signed. func SignSDKRequest(req request.Request) { SignSDKRequestWithCurrentTime(req, time.Now) } // BuildNamedHandler will build a generic handler for signing. func BuildNamedHandler(name string, opts ...func(Signer)) request.NamedHandler { return request.NamedHandler{ Name: name, Fn: func(req request.Request) { SignSDKRequestWithCurrentTime(req, time.Now, opts...) }, } } // SignSDKRequestWithCurrentTime will sign the SDK's request using the time // function passed in. Behaves the same as SignSDKRequest with the exception // the request is signed with the value returned by the current time function. func SignSDKRequestWithCurrentTime(req request.Request, curTimeFn func() time.Time, opts ...func(Signer)) { // If the request does not need to be signed ignore the signing of the // request if the AnonymousCredentials object is used. if req.Config.Credentials == credentials.AnonymousCredentials { return } region := req.ClientInfo.SigningRegion if region == "" { region = aws.StringValue(req.Config.Region) } name := req.ClientInfo.SigningName if name == "" { name = req.ClientInfo.ServiceName } v4 := NewSigner(req.Config.Credentials, func(v4 Signer) { v4.Debug = req.Config.LogLevel.Value() v4.Logger = req.Config.Logger v4.DisableHeaderHoisting = req.NotHoist v4.currentTimeFn = curTimeFn if name == "s3" { // S3 service should not have any escaping applied v4.DisableURIPathEscaping = true } // Prevents setting the HTTPRequest's Body. Since the Body could be // wrapped in a custom io.Closer that we do not want to be stompped // on top of by the signer. v4.DisableRequestBodyOverwrite = true }) for _, opt := range opts { opt(v4) } curTime := curTimeFn() signedHeaders, err := v4.signWithBody(req.HTTPRequest, req.GetBody(), name, region, req.ExpireTime, req.ExpireTime > 0, curTime, ) if err != nil { req.Error = err req.SignedHeaderVals = nil return } req.SignedHeaderVals = signedHeaders req.LastSignedAt = curTime } const logSignInfoMsg = `DEBUG: Request Signature: ---[ CANONICAL STRING ]----------------------------- %s ---[ STRING TO SIGN ]-------------------------------- %s%s -----------------------------------------------------` const logSignedURLMsg = ` ---[ SIGNED URL ]------------------------------------ %s` func (v4 Signer) logSigningInfo(ctx signingCtx) { signedURLMsg := "" if ctx.isPresign { signedURLMsg = fmt.Sprintf(logSignedURLMsg, ctx.Request.URL.String()) } msg := fmt.Sprintf(logSignInfoMsg, ctx.canonicalString, ctx.stringToSign, signedURLMsg) v4.Logger.Log(msg) } func (ctx signingCtx) build(disableHeaderHoisting bool) error { ctx.buildTime() // no depends ctx.buildCredentialString() // no depends if err := ctx.buildBodyDigest(); err != nil { return err } unsignedHeaders := ctx.Request.Header if ctx.isPresign { if !disableHeaderHoisting { urlValues := url.Values{} urlValues, unsignedHeaders = buildQuery(allowedQueryHoisting, unsignedHeaders) // no depends for k := range urlValues { ctx.Query[k] = urlValues[k] } } } ctx.buildCanonicalHeaders(ignoredHeaders, unsignedHeaders) ctx.buildCanonicalString() // depends on canon headers / signed headers ctx.buildStringToSign() // depends on canon string ctx.buildSignature() // depends on string to sign if ctx.isPresign { ctx.Request.URL.RawQuery += "&" + signatureQueryKey + "=" + ctx.signature } else { parts := []string{ authHeaderPrefix + " Credential=" + ctx.credValues.AccessKeyID + "/" + ctx.credentialString, "SignedHeaders=" + ctx.signedHeaders, authHeaderSignatureElem + ctx.signature, } ctx.Request.Header.Set(authorizationHeader, strings.Join(parts, ", ")) } return nil } // GetSignedRequestSignature attempts to extract the signature of the request. // Returning an error if the request is unsigned, or unable to extract the // signature. func GetSignedRequestSignature(r http.Request) ([]byte, error) { if auth := r.Header.Get(authorizationHeader); len(auth) != 0 { ps := strings.Split(auth, ", ") for _, p := range ps { if idx := strings.Index(p, authHeaderSignatureElem); idx >= 0 { sig := p[len(authHeaderSignatureElem):] if len(sig) == 0 { return nil, fmt.Errorf("invalid request signature authorization header") } return hex.DecodeString(sig) } } } if sig := r.URL.Query().Get("X-Amz-Signature"); len(sig) != 0 { return hex.DecodeString(sig) } return nil, fmt.Errorf("request not signed") } func (ctx signingCtx) buildTime() { if ctx.isPresign { duration := int64(ctx.ExpireTime / time.Second) ctx.Query.Set("X-Amz-Date", formatTime(ctx.Time)) ctx.Query.Set("X-Amz-Expires", strconv.FormatInt(duration, 10)) } else { ctx.Request.Header.Set("X-Amz-Date", formatTime(ctx.Time)) } } func (ctx signingCtx) buildCredentialString() { ctx.credentialString = buildSigningScope(ctx.Region, ctx.ServiceName, ctx.Time) if ctx.isPresign { ctx.Query.Set("X-Amz-Credential", ctx.credValues.AccessKeyID+"/"+ctx.credentialString) } } func buildQuery(r rule, header http.Header) (url.Values, http.Header) { query := url.Values{} unsignedHeaders := http.Header{} for k, h := range header { if r.IsValid(k) { query[k] = h } else { unsignedHeaders[k] = h } } return query, unsignedHeaders } func (ctx signingCtx) buildCanonicalHeaders(r rule, header http.Header) { var headers []string headers = append(headers, "host") for k, v := range header { if !r.IsValid(k) { continue // ignored header } if ctx.SignedHeaderVals == nil { ctx.SignedHeaderVals = make(http.Header) } lowerCaseKey := strings.ToLower(k) if _, ok := ctx.SignedHeaderVals[lowerCaseKey]; ok { // include additional values ctx.SignedHeaderVals[lowerCaseKey] = append(ctx.SignedHeaderVals[lowerCaseKey], v...) continue } headers = append(headers, lowerCaseKey) ctx.SignedHeaderVals[lowerCaseKey] = v } sort.Strings(headers) ctx.signedHeaders = strings.Join(headers, ";") if ctx.isPresign { ctx.Query.Set("X-Amz-SignedHeaders", ctx.signedHeaders) } headerItems := make([]string, len(headers)) for i, k := range headers { if k == "host" { if ctx.Request.Host != "" { headerItems[i] = "host:" + ctx.Request.Host } else { headerItems[i] = "host:" + ctx.Request.URL.Host } } else { headerValues := make([]string, len(ctx.SignedHeaderVals[k])) for i, v := range ctx.SignedHeaderVals[k] { headerValues[i] = strings.TrimSpace(v) } headerItems[i] = k + ":" + strings.Join(headerValues, ",") } } stripExcessSpaces(headerItems) ctx.canonicalHeaders = strings.Join(headerItems, "\n") } func (ctx signingCtx) buildCanonicalString() { ctx.Request.URL.RawQuery = strings.Replace(ctx.Query.Encode(), "+", "%20", -1) uri := getURIPath(ctx.Request.URL) if !ctx.DisableURIPathEscaping { uri = rest.EscapePath(uri, false) } ctx.canonicalString = strings.Join([]string{ ctx.Request.Method, uri, ctx.Request.URL.RawQuery, ctx.canonicalHeaders + "\n", ctx.signedHeaders, ctx.bodyDigest, }, "\n") } func (ctx signingCtx) buildStringToSign() { ctx.stringToSign = strings.Join([]string{ authHeaderPrefix, formatTime(ctx.Time), ctx.credentialString, hex.EncodeToString(hashSHA256([]byte(ctx.canonicalString))), }, "\n") } func (ctx signingCtx) buildSignature() { creds := deriveSigningKey(ctx.Region, ctx.ServiceName, ctx.credValues.SecretAccessKey, ctx.Time) signature := hmacSHA256(creds, []byte(ctx.stringToSign)) ctx.signature = hex.EncodeToString(signature) } func (ctx signingCtx) buildBodyDigest() error { hash := ctx.Request.Header.Get("X-Amz-Content-Sha256") if hash == "" { includeSHA256Header := ctx.unsignedPayload \|\| ctx.ServiceName == "s3" \|\| ctx.ServiceName == "s3-object-lambda" \|\| ctx.ServiceName == "glacier" \|\| ctx.ServiceName == "s3-outposts" s3Presign := ctx.isPresign && (ctx.ServiceName == "s3" \|\| ctx.ServiceName == "s3-object-lambda") if ctx.unsignedPayload \|\| s3Presign { hash = "UNSIGNED-PAYLOAD" includeSHA256Header = !s3Presign } else if ctx.Body == nil { hash = emptyStringSHA256 } else { if !aws.IsReaderSeekable(ctx.Body) { return fmt.Errorf("cannot use unseekable request body %T, for signed request with body", ctx.Body) } hashBytes, err := makeSha256Reader(ctx.Body) if err != nil { return err } hash = hex.EncodeToString(hashBytes) } if includeSHA256Header { ctx.Request.Header.Set("X-Amz-Content-Sha256", hash) } } ctx.bodyDigest = hash return nil } // isRequestSigned returns if the request is currently signed or presigned func (ctx signingCtx) isRequestSigned() bool { if ctx.isPresign && ctx.Query.Get("X-Amz-Signature") != "" { return true } if ctx.Request.Header.Get("Authorization") != "" { return true } return false } // unsign removes signing flags for both signed and presigned requests. func (ctx signingCtx) removePresign() { ctx.Query.Del("X-Amz-Algorithm") ctx.Query.Del("X-Amz-Signature") ctx.Query.Del("X-Amz-Security-Token") ctx.Query.Del("X-Amz-Date") ctx.Query.Del("X-Amz-Expires") ctx.Query.Del("X-Amz-Credential") ctx.Query.Del("X-Amz-SignedHeaders") } func hmacSHA256(key []byte, data []byte) []byte { hash := hmac.New(sha256.New, key) hash.Write(data) return hash.Sum(nil) } func hashSHA256(data []byte) []byte { hash := sha256.New() hash.Write(data) return hash.Sum(nil) } func makeSha256Reader(reader io.ReadSeeker) (hashBytes []byte, err error) { hash := sha256.New() start, err := reader.Seek(0, sdkio.SeekCurrent) if err != nil { return nil, err } defer func() { // ensure error is return if unable to seek back to start of payload. _, err = reader.Seek(start, sdkio.SeekStart) }() // Use CopyN to avoid allocating the 32KB buffer in io.Copy for bodies // smaller than 32KB. Fall back to io.Copy if we fail to determine the size. size, err := aws.SeekerLen(reader) if err != nil { io.Copy(hash, reader) } else { io.CopyN(hash, reader, size) } return hash.Sum(nil), nil } const doubleSpace = " " // stripExcessSpaces will rewrite the passed in slice's string values to not // contain multiple side-by-side spaces. func stripExcessSpaces(vals []string) { var j, k, l, m, spaces int for i, str := range vals { // Trim trailing spaces for j = len(str) - 1; j >= 0 && str[j] == ' '; j-- { } // Trim leading spaces for k = 0; k < j && str[k] == ' '; k++ { } str = str[k : j+1] // Strip multiple spaces. j = strings.Index(str, doubleSpace) if j < 0 { vals[i] = str continue } buf := []byte(str) for k, m, l = j, j, len(buf); k < l; k++ { if buf[k] == ' ' { if spaces == 0 { // First space. buf[m] = buf[k] m++ } spaces++ } else { // End of multiple spaces. spaces = 0 buf[m] = buf[k] m++ } } vals[i] = string(buf[:m]) } } func buildSigningScope(region, service string, dt time.Time) string { return strings.Join([]string{ formatShortTime(dt), region, service, awsV4Request, }, "/") } func deriveSigningKey(region, service, secretKey string, dt time.Time) []byte { kDate := hmacSHA256([]byte("AWS4"+secretKey), []byte(formatShortTime(dt))) kRegion := hmacSHA256(kDate, []byte(region)) kService := hmacSHA256(kRegion, []byte(service)) signingKey := hmacSHA256(kService, []byte(awsV4Request)) return signingKey } func formatShortTime(dt time.Time) string { return dt.UTC().Format(shortTimeFormat) } func formatTime(dt time.Time) string { return dt.UTC().Format(timeFormat) }	28.01 KB	2025-05-25 12:27
📄 v4_test.go package v4 import ( "bytes" "io" "io/ioutil" "net/http" "net/http/httptest" "reflect" "strconv" "strings" "testing" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/awstesting" ) func epochTime() time.Time { return time.Unix(0, 0) } func TestStripExcessHeaders(t testing.T) { vals := []string{ "", "123", "1 2 3", "1 2 3 ", " 1 2 3", "1 2 3", "1 23", "1 2 3", "1 2 ", " 1 2 ", "12 3", "12 3 1", "12 3 1", "12 3 1abc123", } expected := []string{ "", "123", "1 2 3", "1 2 3", "1 2 3", "1 2 3", "1 23", "1 2 3", "1 2", "1 2", "12 3", "12 3 1", "12 3 1", "12 3 1abc123", } stripExcessSpaces(vals) for i := 0; i < len(vals); i++ { if e, a := expected[i], vals[i]; e != a { t.Errorf("%d, expect %v, got %v", i, e, a) } } } func buildRequest(serviceName, region, body string) (http.Request, io.ReadSeeker) { reader := strings.NewReader(body) return buildRequestWithBodyReader(serviceName, region, reader) } func buildRequestReaderSeeker(serviceName, region, body string) (http.Request, io.ReadSeeker) { reader := &readerSeekerWrapper{strings.NewReader(body)} return buildRequestWithBodyReader(serviceName, region, reader) } func buildRequestWithBodyReader(serviceName, region string, body io.Reader) (http.Request, io.ReadSeeker) { var bodyLen int type lenner interface { Len() int } if lr, ok := body.(lenner); ok { bodyLen = lr.Len() } endpoint := "https://" + serviceName + "." + region + ".amazonaws.com" req, _ := http.NewRequest("POST", endpoint, body) req.URL.Opaque = "//example.org/bucket/key-._~,!@#$%^&()" req.Header.Set("X-Amz-Target", "prefix.Operation") req.Header.Set("Content-Type", "application/x-amz-json-1.0") if bodyLen > 0 { req.Header.Set("Content-Length", strconv.Itoa(bodyLen)) } req.Header.Set("X-Amz-Meta-Other-Header", "some-value=!@#$%^& (+)") req.Header.Add("X-Amz-Meta-Other-Header_With_Underscore", "some-value=!@#$%^&* (+)") req.Header.Add("X-amz-Meta-Other-Header_With_Underscore", "some-value=!@#$%^&* (+)") var seeker io.ReadSeeker if sr, ok := body.(io.ReadSeeker); ok { seeker = sr } else { seeker = aws.ReadSeekCloser(body) } return req, seeker } func buildSigner() Signer { return Signer{ Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"), } } func removeWS(text string) string { text = strings.Replace(text, " ", "", -1) text = strings.Replace(text, "\n", "", -1) text = strings.Replace(text, "\t", "", -1) return text } func assertEqual(t testing.T, expected, given string) { if removeWS(expected) != removeWS(given) { t.Errorf("\nExpected: %s\nGiven: %s", expected, given) } } func TestPresignRequest(t testing.T) { req, body := buildRequest("dynamodb", "us-east-1", "{}") signer := buildSigner() signer.Presign(req, body, "dynamodb", "us-east-1", 300time.Second, epochTime()) expectedDate := "19700101T000000Z" expectedHeaders := "content-length;content-type;host;x-amz-meta-other-header;x-amz-meta-other-header_with_underscore" expectedSig := "122f0b9e091e4ba84286097e2b3404a1f1f4c4aad479adda95b7dff0ccbe5581" expectedCred := "AKID/19700101/us-east-1/dynamodb/aws4_request" expectedTarget := "prefix.Operation" q := req.URL.Query() if e, a := expectedSig, q.Get("X-Amz-Signature"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedCred, q.Get("X-Amz-Credential"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedHeaders, q.Get("X-Amz-SignedHeaders"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedDate, q.Get("X-Amz-Date"); e != a { t.Errorf("expect %v, got %v", e, a) } if a := q.Get("X-Amz-Meta-Other-Header"); len(a) != 0 { t.Errorf("expect %v to be empty", a) } if e, a := expectedTarget, q.Get("X-Amz-Target"); e != a { t.Errorf("expect %v, got %v", e, a) } } func TestPresignBodyWithArrayRequest(t testing.T) { req, body := buildRequest("dynamodb", "us-east-1", "{}") req.URL.RawQuery = "Foo=z&Foo=o&Foo=m&Foo=a" signer := buildSigner() signer.Presign(req, body, "dynamodb", "us-east-1", 300time.Second, epochTime()) expectedDate := "19700101T000000Z" expectedHeaders := "content-length;content-type;host;x-amz-meta-other-header;x-amz-meta-other-header_with_underscore" expectedSig := "e3ac55addee8711b76c6d608d762cff285fe8b627a057f8b5ec9268cf82c08b1" expectedCred := "AKID/19700101/us-east-1/dynamodb/aws4_request" expectedTarget := "prefix.Operation" q := req.URL.Query() if e, a := expectedSig, q.Get("X-Amz-Signature"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedCred, q.Get("X-Amz-Credential"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedHeaders, q.Get("X-Amz-SignedHeaders"); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := expectedDate, q.Get("X-Amz-Date"); e != a { t.Errorf("expect %v, got %v", e, a) } if a := q.Get("X-Amz-Meta-Other-Header"); len(a) != 0 { t.Errorf("expect %v to be empty, was not", a) } if e, a := expectedTarget, q.Get("X-Amz-Target"); e != a { t.Errorf("expect %v, got %v", e, a) } } func TestSignRequest(t testing.T) { req, body := buildRequest("dynamodb", "us-east-1", "{}") signer := buildSigner() signer.Sign(req, body, "dynamodb", "us-east-1", epochTime()) expectedDate := "19700101T000000Z" expectedSig := "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/dynamodb/aws4_request, SignedHeaders=content-length;content-type;host;x-amz-date;x-amz-meta-other-header;x-amz-meta-other-header_with_underscore;x-amz-security-token;x-amz-target, Signature=a518299330494908a70222cec6899f6f32f297f8595f6df1776d998936652ad9" q := req.Header if e, a := expectedSig, q.Get("Authorization"); e != a { t.Errorf("expect\n%v\nactual\n%v\n", e, a) } if e, a := expectedDate, q.Get("X-Amz-Date"); e != a { t.Errorf("expect\n%v\nactual\n%v\n", e, a) } } func TestSignBodyS3(t testing.T) { req, body := buildRequest("s3", "us-east-1", "hello") signer := buildSigner() signer.Sign(req, body, "s3", "us-east-1", time.Now()) hash := req.Header.Get("X-Amz-Content-Sha256") if e, a := "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestSignBodyGlacier(t testing.T) { req, body := buildRequest("glacier", "us-east-1", "hello") signer := buildSigner() signer.Sign(req, body, "glacier", "us-east-1", time.Now()) hash := req.Header.Get("X-Amz-Content-Sha256") if e, a := "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestPresign_SignedPayload(t testing.T) { req, body := buildRequest("glacier", "us-east-1", "hello") signer := buildSigner() signer.Presign(req, body, "glacier", "us-east-1", 5time.Minute, time.Now()) hash := req.Header.Get("X-Amz-Content-Sha256") if e, a := "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestPresign_UnsignedPayload(t testing.T) { req, body := buildRequest("service-name", "us-east-1", "hello") signer := buildSigner() signer.UnsignedPayload = true signer.Presign(req, body, "service-name", "us-east-1", 5time.Minute, time.Now()) hash := req.Header.Get("X-Amz-Content-Sha256") if e, a := "UNSIGNED-PAYLOAD", hash; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestPresign_UnsignedPayload_S3(t testing.T) { req, body := buildRequest("s3", "us-east-1", "hello") signer := buildSigner() signer.Presign(req, body, "s3", "us-east-1", 5time.Minute, time.Now()) if a := req.Header.Get("X-Amz-Content-Sha256"); len(a) != 0 { t.Errorf("expect no content sha256 got %v", a) } } func TestSignUnseekableBody(t testing.T) { req, body := buildRequestWithBodyReader("mock-service", "mock-region", bytes.NewBuffer([]byte("hello"))) signer := buildSigner() _, err := signer.Sign(req, body, "mock-service", "mock-region", time.Now()) if err == nil { t.Fatalf("expect error signing request") } if e, a := "unseekable request body", err.Error(); !strings.Contains(a, e) { t.Errorf("expect %q to be in %q", e, a) } } func TestSignUnsignedPayloadUnseekableBody(t testing.T) { req, body := buildRequestWithBodyReader("mock-service", "mock-region", bytes.NewBuffer([]byte("hello"))) signer := buildSigner() signer.UnsignedPayload = true _, err := signer.Sign(req, body, "mock-service", "mock-region", time.Now()) if err != nil { t.Fatalf("expect no error, got %v", err) } hash := req.Header.Get("X-Amz-Content-Sha256") if e, a := "UNSIGNED-PAYLOAD", hash; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestSignPreComputedHashUnseekableBody(t testing.T) { req, body := buildRequestWithBodyReader("mock-service", "mock-region", bytes.NewBuffer([]byte("hello"))) signer := buildSigner() req.Header.Set("X-Amz-Content-Sha256", "some-content-sha256") _, err := signer.Sign(req, body, "mock-service", "mock-region", time.Now()) if err != nil { t.Fatalf("expect no error, got %v", err) } hash := req.Header.Get("X-Amz-Content-Sha256") if e, a := "some-content-sha256", hash; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestSignPrecomputedBodyChecksum(t testing.T) { req, body := buildRequest("dynamodb", "us-east-1", "hello") req.Header.Set("X-Amz-Content-Sha256", "PRECOMPUTED") signer := buildSigner() signer.Sign(req, body, "dynamodb", "us-east-1", time.Now()) hash := req.Header.Get("X-Amz-Content-Sha256") if e, a := "PRECOMPUTED", hash; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestAnonymousCredentials(t testing.T) { svc := awstesting.NewClient(&aws.Config{Credentials: credentials.AnonymousCredentials}) r := svc.NewRequest( &request.Operation{ Name: "BatchGetItem", HTTPMethod: "POST", HTTPPath: "/", }, nil, nil, ) SignSDKRequest(r) urlQ := r.HTTPRequest.URL.Query() if a := urlQ.Get("X-Amz-Signature"); len(a) != 0 { t.Errorf("expect %v to be empty, was not", a) } if a := urlQ.Get("X-Amz-Credential"); len(a) != 0 { t.Errorf("expect %v to be empty, was not", a) } if a := urlQ.Get("X-Amz-SignedHeaders"); len(a) != 0 { t.Errorf("expect %v to be empty, was not", a) } if a := urlQ.Get("X-Amz-Date"); len(a) != 0 { t.Errorf("expect %v to be empty, was not", a) } hQ := r.HTTPRequest.Header if a := hQ.Get("Authorization"); len(a) != 0 { t.Errorf("expect %v to be empty, was not", a) } if a := hQ.Get("X-Amz-Date"); len(a) != 0 { t.Errorf("expect %v to be empty, was not", a) } } func TestIgnoreResignRequestWithValidCreds(t testing.T) { svc := awstesting.NewClient(&aws.Config{ Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"), Region: aws.String("us-west-2"), }) r := svc.NewRequest( &request.Operation{ Name: "BatchGetItem", HTTPMethod: "POST", HTTPPath: "/", }, nil, nil, ) SignSDKRequest(r) sig := r.HTTPRequest.Header.Get("Authorization") SignSDKRequestWithCurrentTime(r, func() time.Time { // Simulate one second has passed so that signature's date changes // when it is resigned. return time.Now().Add(1 * time.Second) }) if e, a := sig, r.HTTPRequest.Header.Get("Authorization"); e == a { t.Errorf("expect %v to be %v, but was not", e, a) } } func TestIgnorePreResignRequestWithValidCreds(t testing.T) { svc := awstesting.NewClient(&aws.Config{ Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"), Region: aws.String("us-west-2"), }) r := svc.NewRequest( &request.Operation{ Name: "BatchGetItem", HTTPMethod: "POST", HTTPPath: "/", }, nil, nil, ) r.ExpireTime = time.Minute 10 SignSDKRequest(r) sig := r.HTTPRequest.URL.Query().Get("X-Amz-Signature") SignSDKRequestWithCurrentTime(r, func() time.Time { // Simulate one second has passed so that signature's date changes // when it is resigned. return time.Now().Add(1 * time.Second) }) if e, a := sig, r.HTTPRequest.URL.Query().Get("X-Amz-Signature"); e == a { t.Errorf("expect %v to be %v, but was not", e, a) } } func TestResignRequestExpiredCreds(t testing.T) { creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION") svc := awstesting.NewClient(&aws.Config{Credentials: creds}) r := svc.NewRequest( &request.Operation{ Name: "BatchGetItem", HTTPMethod: "POST", HTTPPath: "/", }, nil, nil, ) SignSDKRequest(r) querySig := r.HTTPRequest.Header.Get("Authorization") var origSignedHeaders string for _, p := range strings.Split(querySig, ", ") { if strings.HasPrefix(p, "SignedHeaders=") { origSignedHeaders = p[len("SignedHeaders="):] break } } if a := origSignedHeaders; len(a) == 0 { t.Errorf("expect not to be empty, but was") } if e, a := origSignedHeaders, "authorization"; strings.Contains(a, e) { t.Errorf("expect %v to not be in %v, but was", e, a) } origSignedAt := r.LastSignedAt creds.Expire() SignSDKRequestWithCurrentTime(r, func() time.Time { // Simulate one second has passed so that signature's date changes // when it is resigned. return time.Now().Add(1 time.Second) }) updatedQuerySig := r.HTTPRequest.Header.Get("Authorization") if e, a := querySig, updatedQuerySig; e == a { t.Errorf("expect %v to be %v, was not", e, a) } var updatedSignedHeaders string for _, p := range strings.Split(updatedQuerySig, ", ") { if strings.HasPrefix(p, "SignedHeaders=") { updatedSignedHeaders = p[len("SignedHeaders="):] break } } if a := updatedSignedHeaders; len(a) == 0 { t.Errorf("expect not to be empty, but was") } if e, a := updatedQuerySig, "authorization"; strings.Contains(a, e) { t.Errorf("expect %v to not be in %v, but was", e, a) } if e, a := origSignedAt, r.LastSignedAt; e == a { t.Errorf("expect %v to be %v, was not", e, a) } } func TestPreResignRequestExpiredCreds(t testing.T) { provider := &credentials.StaticProvider{Value: credentials.Value{ AccessKeyID: "AKID", SecretAccessKey: "SECRET", SessionToken: "SESSION", }} creds := credentials.NewCredentials(provider) svc := awstesting.NewClient(&aws.Config{Credentials: creds}) r := svc.NewRequest( &request.Operation{ Name: "BatchGetItem", HTTPMethod: "POST", HTTPPath: "/", }, nil, nil, ) r.ExpireTime = time.Minute 10 SignSDKRequest(r) querySig := r.HTTPRequest.URL.Query().Get("X-Amz-Signature") signedHeaders := r.HTTPRequest.URL.Query().Get("X-Amz-SignedHeaders") if a := signedHeaders; len(a) == 0 { t.Errorf("expect not to be empty, but was") } origSignedAt := r.LastSignedAt creds.Expire() SignSDKRequestWithCurrentTime(r, func() time.Time { // Simulate the request occurred 15 minutes in the past return time.Now().Add(-48 * time.Hour) }) if e, a := querySig, r.HTTPRequest.URL.Query().Get("X-Amz-Signature"); e == a { t.Errorf("expect %v to be %v, was not", e, a) } resignedHeaders := r.HTTPRequest.URL.Query().Get("X-Amz-SignedHeaders") if e, a := signedHeaders, resignedHeaders; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := signedHeaders, "x-amz-signedHeaders"; strings.Contains(a, e) { t.Errorf("expect %v to not be in %v, but was", e, a) } if e, a := origSignedAt, r.LastSignedAt; e == a { t.Errorf("expect %v to be %v, was not", e, a) } } func TestResignRequestExpiredRequest(t testing.T) { creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION") svc := awstesting.NewClient(&aws.Config{Credentials: creds}) r := svc.NewRequest( &request.Operation{ Name: "BatchGetItem", HTTPMethod: "POST", HTTPPath: "/", }, nil, nil, ) SignSDKRequest(r) querySig := r.HTTPRequest.Header.Get("Authorization") origSignedAt := r.LastSignedAt SignSDKRequestWithCurrentTime(r, func() time.Time { // Simulate the request occurred 15 minutes in the past return time.Now().Add(15 time.Minute) }) if e, a := querySig, r.HTTPRequest.Header.Get("Authorization"); e == a { t.Errorf("expect %v to be %v, was not", e, a) } if e, a := origSignedAt, r.LastSignedAt; e == a { t.Errorf("expect %v to be %v, was not", e, a) } } func TestSignWithRequestBody(t testing.T) { creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION") signer := NewSigner(creds) expectBody := []byte("abc123") server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { b, err := ioutil.ReadAll(r.Body) r.Body.Close() if err != nil { t.Errorf("expect no error, got %v", err) } if e, a := expectBody, b; !reflect.DeepEqual(e, a) { t.Errorf("expect %v, got %v", e, a) } w.WriteHeader(http.StatusOK) })) defer server.Close() req, err := http.NewRequest("POST", server.URL, nil) if err != nil { t.Errorf("expect not no error, got %v", err) } _, err = signer.Sign(req, bytes.NewReader(expectBody), "service", "region", time.Now()) if err != nil { t.Errorf("expect not no error, got %v", err) } resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("expect not no error, got %v", err) } if e, a := http.StatusOK, resp.StatusCode; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestSignWithRequestBody_Overwrite(t testing.T) { creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION") signer := NewSigner(creds) var expectBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { b, err := ioutil.ReadAll(r.Body) r.Body.Close() if err != nil { t.Errorf("expect not no error, got %v", err) } if e, a := len(expectBody), len(b); e != a { t.Errorf("expect %v, got %v", e, a) } w.WriteHeader(http.StatusOK) })) defer server.Close() req, err := http.NewRequest("GET", server.URL, strings.NewReader("invalid body")) if err != nil { t.Errorf("expect not no error, got %v", err) } _, err = signer.Sign(req, nil, "service", "region", time.Now()) req.ContentLength = 0 if err != nil { t.Errorf("expect not no error, got %v", err) } resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("expect not no error, got %v", err) } if e, a := http.StatusOK, resp.StatusCode; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestBuildCanonicalRequest(t testing.T) { req, body := buildRequest("dynamodb", "us-east-1", "{}") req.URL.RawQuery = "Foo=z&Foo=o&Foo=m&Foo=a" ctx := &signingCtx{ ServiceName: "dynamodb", Region: "us-east-1", Request: req, Body: body, Query: req.URL.Query(), Time: time.Now(), ExpireTime: 5 time.Second, } ctx.buildCanonicalString() expected := "https://example.org/bucket/key-._~,!@#$%^&()?Foo=z&Foo=o&Foo=m&Foo=a" if e, a := expected, ctx.Request.URL.String(); e != a { t.Errorf("expect %v, got %v", e, a) } } func TestSignWithBody_ReplaceRequestBody(t testing.T) { creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION") req, seekerBody := buildRequest("dynamodb", "us-east-1", "{}") req.Body = ioutil.NopCloser(bytes.NewReader([]byte{})) s := NewSigner(creds) origBody := req.Body _, err := s.Sign(req, seekerBody, "dynamodb", "us-east-1", time.Now()) if err != nil { t.Fatalf("expect no error, got %v", err) } if req.Body == origBody { t.Errorf("expeect request body to not be origBody") } if req.Body == nil { t.Errorf("expect request body to be changed but was nil") } } func TestSignWithBody_NoReplaceRequestBody(t testing.T) { creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION") req, seekerBody := buildRequest("dynamodb", "us-east-1", "{}") req.Body = ioutil.NopCloser(bytes.NewReader([]byte{})) s := NewSigner(creds, func(signer Signer) { signer.DisableRequestBodyOverwrite = true }) origBody := req.Body _, err := s.Sign(req, seekerBody, "dynamodb", "us-east-1", time.Now()) if err != nil { t.Fatalf("expect no error, got %v", err) } if req.Body != origBody { t.Errorf("expect request body to not be chagned") } } func TestRequestHost(t testing.T) { req, body := buildRequest("dynamodb", "us-east-1", "{}") req.URL.RawQuery = "Foo=z&Foo=o&Foo=m&Foo=a" req.Host = "myhost" ctx := &signingCtx{ ServiceName: "dynamodb", Region: "us-east-1", Request: req, Body: body, Query: req.URL.Query(), Time: time.Now(), ExpireTime: 5 time.Second, } ctx.buildCanonicalHeaders(ignoredHeaders, ctx.Request.Header) if !strings.Contains(ctx.canonicalHeaders, "host:"+req.Host) { t.Errorf("canonical host header invalid") } } func TestSign_buildCanonicalHeaders(t testing.T) { serviceName := "mockAPI" region := "mock-region" endpoint := "https://" + serviceName + "." + region + ".amazonaws.com" req, err := http.NewRequest("POST", endpoint, nil) if err != nil { t.Fatalf("failed to create request, %v", err) } req.Header.Set("FooInnerSpace", " inner space ") req.Header.Set("FooLeadingSpace", " leading-space") req.Header.Add("FooMultipleSpace", "no-space") req.Header.Add("FooMultipleSpace", "\ttab-space") req.Header.Add("FooMultipleSpace", "trailing-space ") req.Header.Set("FooNoSpace", "no-space") req.Header.Set("FooTabSpace", "\ttab-space\t") req.Header.Set("FooTrailingSpace", "trailing-space ") req.Header.Set("FooWrappedSpace", " wrapped-space ") ctx := &signingCtx{ ServiceName: serviceName, Region: region, Request: req, Body: nil, Query: req.URL.Query(), Time: time.Now(), ExpireTime: 5 time.Second, } ctx.buildCanonicalHeaders(ignoredHeaders, ctx.Request.Header) expectCanonicalHeaders := strings.Join([]string{ `fooinnerspace:inner space`, `fooleadingspace:leading-space`, `foomultiplespace:no-space,tab-space,trailing-space`, `foonospace:no-space`, `footabspace:tab-space`, `footrailingspace:trailing-space`, `foowrappedspace:wrapped-space`, `host:mockAPI.mock-region.amazonaws.com`, }, "\n") if e, a := expectCanonicalHeaders, ctx.canonicalHeaders; e != a { t.Errorf("expect:\n%s\n\nactual:\n%s", e, a) } } func BenchmarkPresignRequest(b testing.B) { signer := buildSigner() req, body := buildRequestReaderSeeker("dynamodb", "us-east-1", "{}") for i := 0; i < b.N; i++ { signer.Presign(req, body, "dynamodb", "us-east-1", 300time.Second, time.Now()) } } func BenchmarkSignRequest(b testing.B) { signer := buildSigner() req, body := buildRequestReaderSeeker("dynamodb", "us-east-1", "{}") for i := 0; i < b.N; i++ { signer.Sign(req, body, "dynamodb", "us-east-1", time.Now()) } } var stripExcessSpaceCases = []string{ `AWS4-HMAC-SHA256 Credential=AKIDFAKEIDFAKEID/20160628/us-west-2/s3/aws4_request, SignedHeaders=host;x-amz-date, Signature=1234567890abcdef1234567890abcdef1234567890abcdef`, `123 321 123 321`, ` 123 321 123 321 `, ` 123 321 123 321 `, "123", "1 2 3", " 1 2 3", "1 2 3", "1 23", "1 2 3", "1 2 ", " 1 2 ", "12 3", "12 3 1", "12 3 1", "12 3 1abc123", } func BenchmarkStripExcessSpaces(b testing.B) { for i := 0; i < b.N; i++ { // Make sure to start with a copy of the cases cases := append([]string{}, stripExcessSpaceCases...) stripExcessSpaces(cases) } } // readerSeekerWrapper mimics the interface provided by request.offsetReader type readerSeekerWrapper struct { r strings.Reader } func (r readerSeekerWrapper) Read(p []byte) (n int, err error) { return r.r.Read(p) } func (r readerSeekerWrapper) Seek(offset int64, whence int) (int64, error) { return r.r.Seek(offset, whence) } func (r readerSeekerWrapper) Len() int { return r.r.Len() }	23.29 KB	2025-05-25 12:27

Terminal