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
📄 header_rules.go // Copyright (C) MongoDB, Inc. 2017-present. // // 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 // // Based on github.com/aws/aws-sdk-go by Amazon.com, Inc. with code from: // - github.com/aws/aws-sdk-go/blob/v1.44.225/aws/signer/v4/header_rules.go // See THIRD-PARTY-NOTICES for original license terms package v4 // 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 } // 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) }	1.43 KB	2025-05-25 12:27
📄 request.go // Copyright (C) MongoDB, Inc. 2017-present. // // 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 // // Based on github.com/aws/aws-sdk-go by Amazon.com, Inc. with code from: // - github.com/aws/aws-sdk-go/blob/v1.44.225/aws/request/request.go // See THIRD-PARTY-NOTICES for original license terms package v4 import ( "net/http" "strings" ) // Returns host from request func getHost(r *http.Request) string { if r.Host != "" { return r.Host } if r.URL == nil { return "" } return r.URL.Host } // Hostname returns u.Host, without any port number. // // If Host is an IPv6 literal with a port number, Hostname returns the // IPv6 literal without the square brackets. IPv6 literals may include // a zone identifier. // // Copied from the Go 1.8 standard library (net/url) func stripPort(hostport string) string { colon := strings.IndexByte(hostport, ':') if colon == -1 { return hostport } if i := strings.IndexByte(hostport, ']'); i != -1 { return strings.TrimPrefix(hostport[:i], "[") } return hostport[:colon] } // Port returns the port part of u.Host, without the leading colon. // If u.Host doesn't contain a port, Port returns an empty string. // // Copied from the Go 1.8 standard library (net/url) func portOnly(hostport string) string { colon := strings.IndexByte(hostport, ':') if colon == -1 { return "" } if i := strings.Index(hostport, "]:"); i != -1 { return hostport[i+len("]:"):] } if strings.Contains(hostport, "]") { return "" } return hostport[colon+len(":"):] } // Returns true if the specified URI is using the standard port // (i.e. port 80 for HTTP URIs or 443 for HTTPS URIs) func isDefaultPort(scheme, port string) bool { if port == "" { return true } lowerCaseScheme := strings.ToLower(scheme) if (lowerCaseScheme == "http" && port == "80") \|\| (lowerCaseScheme == "https" && port == "443") { return true } return false }	2.02 KB	2025-05-25 12:27
📄 uri_path.go // Copyright (C) MongoDB, Inc. 2017-present. // // 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 // // Based on github.com/aws/aws-sdk-go by Amazon.com, Inc. with code from: // - github.com/aws/aws-sdk-go/blob/v1.44.225/aws/signer/v4/uri_path.go // - github.com/aws/aws-sdk-go/blob/v1.44.225/private/protocol/rest/build.go // See THIRD-PARTY-NOTICES for original license terms package v4 import ( "bytes" "fmt" "net/url" "strings" ) // Whether the byte value can be sent without escaping in AWS URLs var noEscape [256]bool func init() { for i := 0; i < len(noEscape); i++ { // AWS expects every character except these to be escaped noEscape[i] = (i >= 'A' && i <= 'Z') \|\| (i >= 'a' && i <= 'z') \|\| (i >= '0' && i <= '9') \|\| i == '-' \|\| i == '.' \|\| i == '_' \|\| i == '~' } } 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 } // EscapePath escapes part of a URL path in Amazon style func EscapePath(path string, encodeSep bool) string { var buf bytes.Buffer for i := 0; i < len(path); i++ { c := path[i] if noEscape[c] \|\| (c == '/' && !encodeSep) { buf.WriteByte(c) } else { fmt.Fprintf(&buf, "%%%02X", c) } } return buf.String() }	1.5 KB	2025-05-25 12:27
📄 v4.go // Copyright (C) MongoDB, Inc. 2017-present. // // 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 // // Based on github.com/aws/aws-sdk-go by Amazon.com, Inc. with code from: // - github.com/aws/aws-sdk-go/blob/v1.44.225/aws/signer/v4/v4.go // See THIRD-PARTY-NOTICES for original license terms package v4 import ( "crypto/hmac" "crypto/sha256" "encoding/hex" "fmt" "io" "io/ioutil" "net/http" "net/url" "sort" "strings" "time" "go.mongodb.org/mongo-driver/internal/aws" "go.mongodb.org/mongo-driver/internal/aws/credentials" ) const ( authorizationHeader = "Authorization" authHeaderSignatureElem = "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{}{}, }, }, } // 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 } // NewSigner returns a Signer pointer configured with the credentials provided. func NewSigner(credentials credentials.Credentials) Signer { v4 := &Signer{ Credentials: credentials, } return v4 } type signingCtx struct { ServiceName string Region string Request http.Request Body io.ReadSeeker Query url.Values Time time.Time SignedHeaderVals http.Header credValues credentials.Value bodyDigest string signedHeaders string canonicalHeaders string canonicalString string credentialString string stringToSign string signature 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, signTime) } func (v4 Signer) signWithBody(r http.Request, body io.ReadSeeker, service, region string, signTime time.Time) (http.Header, error) { ctx := &signingCtx{ Request: r, Body: body, Query: r.URL.Query(), Time: signTime, ServiceName: service, Region: region, } for key := range ctx.Query { sort.Strings(ctx.Query[key]) } if ctx.isRequestSigned() { ctx.Time = time.Now() } var err error ctx.credValues, err = v4.Credentials.GetWithContext(r.Context()) if err != nil { return http.Header{}, err } ctx.sanitizeHostForHeader() ctx.assignAmzQueryValues() if err := ctx.build(); err != nil { return nil, err } var reader io.ReadCloser if body != nil { var ok bool if reader, ok = body.(io.ReadCloser); !ok { reader = ioutil.NopCloser(body) } } r.Body = reader return ctx.SignedHeaderVals, nil } // sanitizeHostForHeader removes default port from host and updates request.Host func (ctx signingCtx) sanitizeHostForHeader() { r := ctx.Request host := getHost(r) port := portOnly(host) if port != "" && isDefaultPort(r.URL.Scheme, port) { r.Host = stripPort(host) } } func (ctx signingCtx) assignAmzQueryValues() { if ctx.credValues.SessionToken != "" { ctx.Request.Header.Set("X-Amz-Security-Token", ctx.credValues.SessionToken) } } func (ctx signingCtx) build() error { ctx.buildTime() // no depends ctx.buildCredentialString() // no depends if err := ctx.buildBodyDigest(); err != nil { return err } unsignedHeaders := ctx.Request.Header 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 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 } func (ctx signingCtx) buildTime() { ctx.Request.Header.Set("X-Amz-Date", formatTime(ctx.Time)) } func (ctx signingCtx) buildCredentialString() { ctx.credentialString = buildSigningScope(ctx.Region, ctx.ServiceName, ctx.Time) } func (ctx signingCtx) buildCanonicalHeaders(r rule, header http.Header) { headers := make([]string, 0, len(header)+1) 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, ";") 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) uri = 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 == "" { 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) } } ctx.bodyDigest = hash return nil } // isRequestSigned returns if the request is currently signed or presigned func (ctx *signingCtx) isRequestSigned() bool { return ctx.Request.Header.Get("Authorization") != "" } 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, io.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, io.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 { // revive:disable:empty-block // Trim trailing spaces for j = len(str) - 1; j >= 0 && str[j] == ' '; j-- { } // Trim leading spaces for k = 0; k < j && str[k] == ' '; k++ { } // revive:enable:empty-block 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 { keyDate := hmacSHA256([]byte("AWS4"+secretKey), []byte(formatShortTime(dt))) keyRegion := hmacSHA256(keyDate, []byte(region)) keyService := hmacSHA256(keyRegion, []byte(service)) signingKey := hmacSHA256(keyService, []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) }	11.19 KB	2025-05-25 12:27
📄 v4_test.go // Copyright (C) MongoDB, Inc. 2017-present. // // 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 // // Based on github.com/aws/aws-sdk-go by Amazon.com, Inc. with code from: // - github.com/aws/aws-sdk-go/blob/v1.44.225/aws/signer/v4/v4_test.go // See THIRD-PARTY-NOTICES for original license terms package v4 import ( "bytes" "io" "io/ioutil" "net/http" "net/http/httptest" "reflect" "strconv" "strings" "testing" "time" "go.mongodb.org/mongo-driver/internal/aws" "go.mongodb.org/mongo-driver/internal/aws/credentials" "go.mongodb.org/mongo-driver/internal/credproviders" ) 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(body string) (http.Request, io.ReadSeeker) { reader := strings.NewReader(body) return buildRequestWithBodyReader("dynamodb", "us-east-1", 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: newTestStaticCredentials(), } } func newTestStaticCredentials() credentials.Credentials { return credentials.NewCredentials(&credproviders.StaticProvider{Value: credentials.Value{ AccessKeyID: "AKID", SecretAccessKey: "SECRET", SessionToken: "SESSION", }}) } func TestSignRequest(t testing.T) { req, body := buildRequest("{}") signer := buildSigner() _, err := signer.Sign(req, body, "dynamodb", "us-east-1", epochTime()) if err != nil { t.Errorf("Expected no err, got %v", err) } 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 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 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("hello") req.Header.Set("X-Amz-Content-Sha256", "PRECOMPUTED") signer := buildSigner() _, err := signer.Sign(req, body, "dynamodb", "us-east-1", time.Now()) if err != nil { t.Errorf("Expected no err, got %v", err) } hash := req.Header.Get("X-Amz-Content-Sha256") if e, a := "PRECOMPUTED", hash; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestSignWithRequestBody(t testing.T) { creds := newTestStaticCredentials() 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 := newTestStaticCredentials() 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("{}") 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(), } 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 := newTestStaticCredentials() req, seekerBody := buildRequest("{}") 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("expect request body to not be origBody") } if req.Body == nil { t.Errorf("expect request body to be changed but was nil") } } func TestRequestHost(t testing.T) { req, body := buildRequest("{}") 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(), } 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(), } 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 BenchmarkSignRequest(b testing.B) { signer := buildSigner() req, body := buildRequestReaderSeeker("dynamodb", "us-east-1", "{}") for i := 0; i < b.N; i++ { _, err := signer.Sign(req, body, "dynamodb", "us-east-1", time.Now()) if err != nil { b.Errorf("Expected no err, got %v", err) } } } 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() }	11.57 KB	2025-05-25 12:27

Terminal