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
📄 acme.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package acme provides an implementation of the // Automatic Certificate Management Environment (ACME) spec, // most famously used by Let's Encrypt. // // The initial implementation of this package was based on an early version // of the spec. The current implementation supports only the modern // RFC 8555 but some of the old API surface remains for compatibility. // While code using the old API will still compile, it will return an error. // Note the deprecation comments to update your code. // // See https://tools.ietf.org/html/rfc8555 for the spec. // // Most common scenarios will want to use autocert subdirectory instead, // which provides automatic access to certificates from Let's Encrypt // and any other ACME-based CA. package acme import ( "context" "crypto" "crypto/ecdsa" "crypto/elliptic" "crypto/rand" "crypto/sha256" "crypto/tls" "crypto/x509" "crypto/x509/pkix" "encoding/asn1" "encoding/base64" "encoding/hex" "encoding/json" "encoding/pem" "errors" "fmt" "math/big" "net/http" "strings" "sync" "time" ) const ( // LetsEncryptURL is the Directory endpoint of Let's Encrypt CA. LetsEncryptURL = "https://acme-v02.api.letsencrypt.org/directory" // ALPNProto is the ALPN protocol name used by a CA server when validating // tls-alpn-01 challenges. // // Package users must ensure their servers can negotiate the ACME ALPN in // order for tls-alpn-01 challenge verifications to succeed. // See the crypto/tls package's Config.NextProtos field. ALPNProto = "acme-tls/1" ) // idPeACMEIdentifier is the OID for the ACME extension for the TLS-ALPN challenge. // https://tools.ietf.org/html/draft-ietf-acme-tls-alpn-05#section-5.1 var idPeACMEIdentifier = asn1.ObjectIdentifier{1, 3, 6, 1, 5, 5, 7, 1, 31} const ( maxChainLen = 5 // max depth and breadth of a certificate chain maxCertSize = 1 << 20 // max size of a certificate, in DER bytes // Used for decoding certs from application/pem-certificate-chain response, // the default when in RFC mode. maxCertChainSize = maxCertSize * maxChainLen // Max number of collected nonces kept in memory. // Expect usual peak of 1 or 2. maxNonces = 100 ) // Client is an ACME client. // // The only required field is Key. An example of creating a client with a new key // is as follows: // // key, err := rsa.GenerateKey(rand.Reader, 2048) // if err != nil { // log.Fatal(err) // } // client := &Client{Key: key} type Client struct { // Key is the account key used to register with a CA and sign requests. // Key.Public() must return a rsa.PublicKey or ecdsa.PublicKey. // // The following algorithms are supported: // RS256, ES256, ES384 and ES512. // See RFC 7518 for more details about the algorithms. Key crypto.Signer // HTTPClient optionally specifies an HTTP client to use // instead of http.DefaultClient. HTTPClient http.Client // DirectoryURL points to the CA directory endpoint. // If empty, LetsEncryptURL is used. // Mutating this value after a successful call of Client's Discover method // will have no effect. DirectoryURL string // RetryBackoff computes the duration after which the nth retry of a failed request // should occur. The value of n for the first call on failure is 1. // The values of r and resp are the request and response of the last failed attempt. // If the returned value is negative or zero, no more retries are done and an error // is returned to the caller of the original method. // // Requests which result in a 4xx client error are not retried, // except for 400 Bad Request due to "bad nonce" errors and 429 Too Many Requests. // // If RetryBackoff is nil, a truncated exponential backoff algorithm // with the ceiling of 10 seconds is used, where each subsequent retry n // is done after either ("Retry-After" + jitter) or (2^n seconds + jitter), // preferring the former if "Retry-After" header is found in the resp. // The jitter is a random value up to 1 second. RetryBackoff func(n int, r http.Request, resp http.Response) time.Duration // UserAgent is prepended to the User-Agent header sent to the ACME server, // which by default is this package's name and version. // // Reusable libraries and tools in particular should set this value to be // identifiable by the server, in case they are causing issues. UserAgent string cacheMu sync.Mutex dir Directory // cached result of Client's Discover method // KID is the key identifier provided by the CA. If not provided it will be // retrieved from the CA by making a call to the registration endpoint. KID KeyID noncesMu sync.Mutex nonces map[string]struct{} // nonces collected from previous responses } // accountKID returns a key ID associated with c.Key, the account identity // provided by the CA during RFC based registration. // It assumes c.Discover has already been called. // // accountKID requires at most one network roundtrip. // It caches only successful result. // // When in pre-RFC mode or when c.getRegRFC responds with an error, accountKID // returns noKeyID. func (c Client) accountKID(ctx context.Context) KeyID { c.cacheMu.Lock() defer c.cacheMu.Unlock() if c.KID != noKeyID { return c.KID } a, err := c.getRegRFC(ctx) if err != nil { return noKeyID } c.KID = KeyID(a.URI) return c.KID } var errPreRFC = errors.New("acme: server does not support the RFC 8555 version of ACME") // Discover performs ACME server discovery using c.DirectoryURL. // // It caches successful result. So, subsequent calls will not result in // a network round-trip. This also means mutating c.DirectoryURL after successful call // of this method will have no effect. func (c Client) Discover(ctx context.Context) (Directory, error) { c.cacheMu.Lock() defer c.cacheMu.Unlock() if c.dir != nil { return c.dir, nil } res, err := c.get(ctx, c.directoryURL(), wantStatus(http.StatusOK)) if err != nil { return Directory{}, err } defer res.Body.Close() c.addNonce(res.Header) var v struct { Reg string `json:"newAccount"` Authz string `json:"newAuthz"` Order string `json:"newOrder"` Revoke string `json:"revokeCert"` Nonce string `json:"newNonce"` KeyChange string `json:"keyChange"` Meta struct { Terms string `json:"termsOfService"` Website string `json:"website"` CAA []string `json:"caaIdentities"` ExternalAcct bool `json:"externalAccountRequired"` } } if err := json.NewDecoder(res.Body).Decode(&v); err != nil { return Directory{}, err } if v.Order == "" { return Directory{}, errPreRFC } c.dir = &Directory{ RegURL: v.Reg, AuthzURL: v.Authz, OrderURL: v.Order, RevokeURL: v.Revoke, NonceURL: v.Nonce, KeyChangeURL: v.KeyChange, Terms: v.Meta.Terms, Website: v.Meta.Website, CAA: v.Meta.CAA, ExternalAccountRequired: v.Meta.ExternalAcct, } return c.dir, nil } func (c Client) directoryURL() string { if c.DirectoryURL != "" { return c.DirectoryURL } return LetsEncryptURL } // CreateCert was part of the old version of ACME. It is incompatible with RFC 8555. // // Deprecated: this was for the pre-RFC 8555 version of ACME. Callers should use CreateOrderCert. func (c Client) CreateCert(ctx context.Context, csr []byte, exp time.Duration, bundle bool) (der [][]byte, certURL string, err error) { return nil, "", errPreRFC } // FetchCert retrieves already issued certificate from the given url, in DER format. // It retries the request until the certificate is successfully retrieved, // context is cancelled by the caller or an error response is received. // // If the bundle argument is true, the returned value also contains the CA (issuer) // certificate chain. // // FetchCert returns an error if the CA's response or chain was unreasonably large. // Callers are encouraged to parse the returned value to ensure the certificate is valid // and has expected features. func (c Client) FetchCert(ctx context.Context, url string, bundle bool) ([][]byte, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } return c.fetchCertRFC(ctx, url, bundle) } // RevokeCert revokes a previously issued certificate cert, provided in DER format. // // The key argument, used to sign the request, must be authorized // to revoke the certificate. It's up to the CA to decide which keys are authorized. // For instance, the key pair of the certificate may be authorized. // If the key is nil, c.Key is used instead. func (c Client) RevokeCert(ctx context.Context, key crypto.Signer, cert []byte, reason CRLReasonCode) error { if _, err := c.Discover(ctx); err != nil { return err } return c.revokeCertRFC(ctx, key, cert, reason) } // AcceptTOS always returns true to indicate the acceptance of a CA's Terms of Service // during account registration. See Register method of Client for more details. func AcceptTOS(tosURL string) bool { return true } // Register creates a new account with the CA using c.Key. // It returns the registered account. The account acct is not modified. // // The registration may require the caller to agree to the CA's Terms of Service (TOS). // If so, and the account has not indicated the acceptance of the terms (see Account for details), // Register calls prompt with a TOS URL provided by the CA. Prompt should report // whether the caller agrees to the terms. To always accept the terms, the caller can use AcceptTOS. // // When interfacing with an RFC-compliant CA, non-RFC 8555 fields of acct are ignored // and prompt is called if Directory's Terms field is non-zero. // Also see Error's Instance field for when a CA requires already registered accounts to agree // to an updated Terms of Service. func (c Client) Register(ctx context.Context, acct Account, prompt func(tosURL string) bool) (Account, error) { if c.Key == nil { return nil, errors.New("acme: client.Key must be set to Register") } if _, err := c.Discover(ctx); err != nil { return nil, err } return c.registerRFC(ctx, acct, prompt) } // GetReg retrieves an existing account associated with c.Key. // // The url argument is a legacy artifact of the pre-RFC 8555 API // and is ignored. func (c Client) GetReg(ctx context.Context, url string) (Account, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } return c.getRegRFC(ctx) } // UpdateReg updates an existing registration. // It returns an updated account copy. The provided account is not modified. // // The account's URI is ignored and the account URL associated with // c.Key is used instead. func (c Client) UpdateReg(ctx context.Context, acct Account) (Account, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } return c.updateRegRFC(ctx, acct) } // AccountKeyRollover attempts to transition a client's account key to a new key. // On success client's Key is updated which is not concurrency safe. // On failure an error will be returned. // The new key is already registered with the ACME provider if the following is true: // - error is of type acme.Error // - StatusCode should be 409 (Conflict) // - Location header will have the KID of the associated account // // More about account key rollover can be found at // https://tools.ietf.org/html/rfc8555#section-7.3.5. func (c Client) AccountKeyRollover(ctx context.Context, newKey crypto.Signer) error { return c.accountKeyRollover(ctx, newKey) } // Authorize performs the initial step in the pre-authorization flow, // as opposed to order-based flow. // The caller will then need to choose from and perform a set of returned // challenges using c.Accept in order to successfully complete authorization. // // Once complete, the caller can use AuthorizeOrder which the CA // should provision with the already satisfied authorization. // For pre-RFC CAs, the caller can proceed directly to requesting a certificate // using CreateCert method. // // If an authorization has been previously granted, the CA may return // a valid authorization which has its Status field set to StatusValid. // // More about pre-authorization can be found at // https://tools.ietf.org/html/rfc8555#section-7.4.1. func (c Client) Authorize(ctx context.Context, domain string) (Authorization, error) { return c.authorize(ctx, "dns", domain) } // AuthorizeIP is the same as Authorize but requests IP address authorization. // Clients which successfully obtain such authorization may request to issue // a certificate for IP addresses. // // See the ACME spec extension for more details about IP address identifiers: // https://tools.ietf.org/html/draft-ietf-acme-ip. func (c Client) AuthorizeIP(ctx context.Context, ipaddr string) (Authorization, error) { return c.authorize(ctx, "ip", ipaddr) } func (c Client) authorize(ctx context.Context, typ, val string) (Authorization, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } type authzID struct { Type string `json:"type"` Value string `json:"value"` } req := struct { Resource string `json:"resource"` Identifier authzID `json:"identifier"` }{ Resource: "new-authz", Identifier: authzID{Type: typ, Value: val}, } res, err := c.post(ctx, nil, c.dir.AuthzURL, req, wantStatus(http.StatusCreated)) if err != nil { return nil, err } defer res.Body.Close() var v wireAuthz if err := json.NewDecoder(res.Body).Decode(&v); err != nil { return nil, fmt.Errorf("acme: invalid response: %v", err) } if v.Status != StatusPending && v.Status != StatusValid { return nil, fmt.Errorf("acme: unexpected status: %s", v.Status) } return v.authorization(res.Header.Get("Location")), nil } // GetAuthorization retrieves an authorization identified by the given URL. // // If a caller needs to poll an authorization until its status is final, // see the WaitAuthorization method. func (c Client) GetAuthorization(ctx context.Context, url string) (Authorization, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } res, err := c.postAsGet(ctx, url, wantStatus(http.StatusOK)) if err != nil { return nil, err } defer res.Body.Close() var v wireAuthz if err := json.NewDecoder(res.Body).Decode(&v); err != nil { return nil, fmt.Errorf("acme: invalid response: %v", err) } return v.authorization(url), nil } // RevokeAuthorization relinquishes an existing authorization identified // by the given URL. // The url argument is an Authorization.URI value. // // If successful, the caller will be required to obtain a new authorization // using the Authorize or AuthorizeOrder methods before being able to request // a new certificate for the domain associated with the authorization. // // It does not revoke existing certificates. func (c Client) RevokeAuthorization(ctx context.Context, url string) error { if _, err := c.Discover(ctx); err != nil { return err } req := struct { Resource string `json:"resource"` Status string `json:"status"` Delete bool `json:"delete"` }{ Resource: "authz", Status: "deactivated", Delete: true, } res, err := c.post(ctx, nil, url, req, wantStatus(http.StatusOK)) if err != nil { return err } defer res.Body.Close() return nil } // WaitAuthorization polls an authorization at the given URL // until it is in one of the final states, StatusValid or StatusInvalid, // the ACME CA responded with a 4xx error code, or the context is done. // // It returns a non-nil Authorization only if its Status is StatusValid. // In all other cases WaitAuthorization returns an error. // If the Status is StatusInvalid, the returned error is of type AuthorizationError. func (c Client) WaitAuthorization(ctx context.Context, url string) (Authorization, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } for { res, err := c.postAsGet(ctx, url, wantStatus(http.StatusOK, http.StatusAccepted)) if err != nil { return nil, err } var raw wireAuthz err = json.NewDecoder(res.Body).Decode(&raw) res.Body.Close() switch { case err != nil: // Skip and retry. case raw.Status == StatusValid: return raw.authorization(url), nil case raw.Status == StatusInvalid: return nil, raw.error(url) } // Exponential backoff is implemented in c.get above. // This is just to prevent continuously hitting the CA // while waiting for a final authorization status. d := retryAfter(res.Header.Get("Retry-After")) if d == 0 { // Given that the fastest challenges TLS-SNI and HTTP-01 // require a CA to make at least 1 network round trip // and most likely persist a challenge state, // this default delay seems reasonable. d = time.Second } t := time.NewTimer(d) select { case <-ctx.Done(): t.Stop() return nil, ctx.Err() case <-t.C: // Retry. } } } // GetChallenge retrieves the current status of an challenge. // // A client typically polls a challenge status using this method. func (c Client) GetChallenge(ctx context.Context, url string) (Challenge, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } res, err := c.postAsGet(ctx, url, wantStatus(http.StatusOK, http.StatusAccepted)) if err != nil { return nil, err } defer res.Body.Close() v := wireChallenge{URI: url} if err := json.NewDecoder(res.Body).Decode(&v); err != nil { return nil, fmt.Errorf("acme: invalid response: %v", err) } return v.challenge(), nil } // Accept informs the server that the client accepts one of its challenges // previously obtained with c.Authorize. // // The server will then perform the validation asynchronously. func (c Client) Accept(ctx context.Context, chal Challenge) (Challenge, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } res, err := c.post(ctx, nil, chal.URI, json.RawMessage("{}"), wantStatus( http.StatusOK, // according to the spec http.StatusAccepted, // Let's Encrypt: see https://goo.gl/WsJ7VT (acme-divergences.md) )) if err != nil { return nil, err } defer res.Body.Close() var v wireChallenge if err := json.NewDecoder(res.Body).Decode(&v); err != nil { return nil, fmt.Errorf("acme: invalid response: %v", err) } return v.challenge(), nil } // DNS01ChallengeRecord returns a DNS record value for a dns-01 challenge response. // A TXT record containing the returned value must be provisioned under // "_acme-challenge" name of the domain being validated. // // The token argument is a Challenge.Token value. func (c Client) DNS01ChallengeRecord(token string) (string, error) { ka, err := keyAuth(c.Key.Public(), token) if err != nil { return "", err } b := sha256.Sum256([]byte(ka)) return base64.RawURLEncoding.EncodeToString(b[:]), nil } // HTTP01ChallengeResponse returns the response for an http-01 challenge. // Servers should respond with the value to HTTP requests at the URL path // provided by HTTP01ChallengePath to validate the challenge and prove control // over a domain name. // // The token argument is a Challenge.Token value. func (c Client) HTTP01ChallengeResponse(token string) (string, error) { return keyAuth(c.Key.Public(), token) } // HTTP01ChallengePath returns the URL path at which the response for an http-01 challenge // should be provided by the servers. // The response value can be obtained with HTTP01ChallengeResponse. // // The token argument is a Challenge.Token value. func (c Client) HTTP01ChallengePath(token string) string { return "/.well-known/acme-challenge/" + token } // TLSSNI01ChallengeCert creates a certificate for TLS-SNI-01 challenge response. // // Deprecated: This challenge type is unused in both draft-02 and RFC versions of the ACME spec. func (c Client) TLSSNI01ChallengeCert(token string, opt ...CertOption) (cert tls.Certificate, name string, err error) { ka, err := keyAuth(c.Key.Public(), token) if err != nil { return tls.Certificate{}, "", err } b := sha256.Sum256([]byte(ka)) h := hex.EncodeToString(b[:]) name = fmt.Sprintf("%s.%s.acme.invalid", h[:32], h[32:]) cert, err = tlsChallengeCert([]string{name}, opt) if err != nil { return tls.Certificate{}, "", err } return cert, name, nil } // TLSSNI02ChallengeCert creates a certificate for TLS-SNI-02 challenge response. // // Deprecated: This challenge type is unused in both draft-02 and RFC versions of the ACME spec. func (c Client) TLSSNI02ChallengeCert(token string, opt ...CertOption) (cert tls.Certificate, name string, err error) { b := sha256.Sum256([]byte(token)) h := hex.EncodeToString(b[:]) sanA := fmt.Sprintf("%s.%s.token.acme.invalid", h[:32], h[32:]) ka, err := keyAuth(c.Key.Public(), token) if err != nil { return tls.Certificate{}, "", err } b = sha256.Sum256([]byte(ka)) h = hex.EncodeToString(b[:]) sanB := fmt.Sprintf("%s.%s.ka.acme.invalid", h[:32], h[32:]) cert, err = tlsChallengeCert([]string{sanA, sanB}, opt) if err != nil { return tls.Certificate{}, "", err } return cert, sanA, nil } // TLSALPN01ChallengeCert creates a certificate for TLS-ALPN-01 challenge response. // Servers can present the certificate to validate the challenge and prove control // over a domain name. For more details on TLS-ALPN-01 see // https://tools.ietf.org/html/draft-shoemaker-acme-tls-alpn-00#section-3 // // The token argument is a Challenge.Token value. // If a WithKey option is provided, its private part signs the returned cert, // and the public part is used to specify the signee. // If no WithKey option is provided, a new ECDSA key is generated using P-256 curve. // // The returned certificate is valid for the next 24 hours and must be presented only when // the server name in the TLS ClientHello matches the domain, and the special acme-tls/1 ALPN protocol // has been specified. func (c Client) TLSALPN01ChallengeCert(token, domain string, opt ...CertOption) (cert tls.Certificate, err error) { ka, err := keyAuth(c.Key.Public(), token) if err != nil { return tls.Certificate{}, err } shasum := sha256.Sum256([]byte(ka)) extValue, err := asn1.Marshal(shasum[:]) if err != nil { return tls.Certificate{}, err } acmeExtension := pkix.Extension{ Id: idPeACMEIdentifier, Critical: true, Value: extValue, } tmpl := defaultTLSChallengeCertTemplate() var newOpt []CertOption for _, o := range opt { switch o := o.(type) { case certOptTemplate: t := (x509.Certificate)(o) // shallow copy is ok tmpl = &t default: newOpt = append(newOpt, o) } } tmpl.ExtraExtensions = append(tmpl.ExtraExtensions, acmeExtension) newOpt = append(newOpt, WithTemplate(tmpl)) return tlsChallengeCert([]string{domain}, newOpt) } // popNonce returns a nonce value previously stored with c.addNonce // or fetches a fresh one from c.dir.NonceURL. // If NonceURL is empty, it first tries c.directoryURL() and, failing that, // the provided url. func (c Client) popNonce(ctx context.Context, url string) (string, error) { c.noncesMu.Lock() defer c.noncesMu.Unlock() if len(c.nonces) == 0 { if c.dir != nil && c.dir.NonceURL != "" { return c.fetchNonce(ctx, c.dir.NonceURL) } dirURL := c.directoryURL() v, err := c.fetchNonce(ctx, dirURL) if err != nil && url != dirURL { v, err = c.fetchNonce(ctx, url) } return v, err } var nonce string for nonce = range c.nonces { delete(c.nonces, nonce) break } return nonce, nil } // clearNonces clears any stored nonces func (c Client) clearNonces() { c.noncesMu.Lock() defer c.noncesMu.Unlock() c.nonces = make(map[string]struct{}) } // addNonce stores a nonce value found in h (if any) for future use. func (c Client) addNonce(h http.Header) { v := nonceFromHeader(h) if v == "" { return } c.noncesMu.Lock() defer c.noncesMu.Unlock() if len(c.nonces) >= maxNonces { return } if c.nonces == nil { c.nonces = make(map[string]struct{}) } c.nonces[v] = struct{}{} } func (c Client) fetchNonce(ctx context.Context, url string) (string, error) { r, err := http.NewRequest("HEAD", url, nil) if err != nil { return "", err } resp, err := c.doNoRetry(ctx, r) if err != nil { return "", err } defer resp.Body.Close() nonce := nonceFromHeader(resp.Header) if nonce == "" { if resp.StatusCode > 299 { return "", responseError(resp) } return "", errors.New("acme: nonce not found") } return nonce, nil } func nonceFromHeader(h http.Header) string { return h.Get("Replay-Nonce") } // linkHeader returns URI-Reference values of all Link headers // with relation-type rel. // See https://tools.ietf.org/html/rfc5988#section-5 for details. func linkHeader(h http.Header, rel string) []string { var links []string for _, v := range h["Link"] { parts := strings.Split(v, ";") for _, p := range parts { p = strings.TrimSpace(p) if !strings.HasPrefix(p, "rel=") { continue } if v := strings.Trim(p[4:], `"`); v == rel { links = append(links, strings.Trim(parts[0], "<>")) } } } return links } // keyAuth generates a key authorization string for a given token. func keyAuth(pub crypto.PublicKey, token string) (string, error) { th, err := JWKThumbprint(pub) if err != nil { return "", err } return fmt.Sprintf("%s.%s", token, th), nil } // defaultTLSChallengeCertTemplate is a template used to create challenge certs for TLS challenges. func defaultTLSChallengeCertTemplate() x509.Certificate { return &x509.Certificate{ SerialNumber: big.NewInt(1), NotBefore: time.Now(), NotAfter: time.Now().Add(24 * time.Hour), BasicConstraintsValid: true, KeyUsage: x509.KeyUsageKeyEncipherment \| x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, } } // tlsChallengeCert creates a temporary certificate for TLS-SNI challenges // with the given SANs and auto-generated public/private key pair. // The Subject Common Name is set to the first SAN to aid debugging. // To create a cert with a custom key pair, specify WithKey option. func tlsChallengeCert(san []string, opt []CertOption) (tls.Certificate, error) { var key crypto.Signer tmpl := defaultTLSChallengeCertTemplate() for _, o := range opt { switch o := o.(type) { case certOptKey: if key != nil { return tls.Certificate{}, errors.New("acme: duplicate key option") } key = o.key case certOptTemplate: t := (x509.Certificate)(o) // shallow copy is ok tmpl = &t default: // package's fault, if we let this happen: panic(fmt.Sprintf("unsupported option type %T", o)) } } if key == nil { var err error if key, err = ecdsa.GenerateKey(elliptic.P256(), rand.Reader); err != nil { return tls.Certificate{}, err } } tmpl.DNSNames = san if len(san) > 0 { tmpl.Subject.CommonName = san[0] } der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, key.Public(), key) if err != nil { return tls.Certificate{}, err } return tls.Certificate{ Certificate: [][]byte{der}, PrivateKey: key, }, nil } // encodePEM returns b encoded as PEM with block of type typ. func encodePEM(typ string, b []byte) []byte { pb := &pem.Block{Type: typ, Bytes: b} return pem.EncodeToMemory(pb) } // timeNow is time.Now, except in tests which can mess with it. var timeNow = time.Now	26.82 KB	2025-05-25 12:27
📄 acme_test.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package acme import ( "bytes" "context" "crypto/rand" "crypto/rsa" "crypto/tls" "crypto/x509" "crypto/x509/pkix" "encoding/base64" "encoding/hex" "encoding/json" "fmt" "io" "math/big" "net/http" "net/http/httptest" "reflect" "sort" "strings" "testing" "time" ) // newTestClient creates a client with a non-nil Directory so that it skips // the discovery which is otherwise done on the first call of almost every // exported method. func newTestClient() Client { return &Client{ Key: testKeyEC, dir: &Directory{}, // skip discovery } } // Decodes a JWS-encoded request and unmarshals the decoded JSON into a provided // interface. func decodeJWSRequest(t testing.T, v interface{}, r io.Reader) { // Decode request var req struct{ Payload string } if err := json.NewDecoder(r).Decode(&req); err != nil { t.Fatal(err) } payload, err := base64.RawURLEncoding.DecodeString(req.Payload) if err != nil { t.Fatal(err) } err = json.Unmarshal(payload, v) if err != nil { t.Fatal(err) } } type jwsHead struct { Alg string Nonce string URL string `json:"url"` KID string `json:"kid"` JWK map[string]string `json:"jwk"` } func decodeJWSHead(r io.Reader) (jwsHead, error) { var req struct{ Protected string } if err := json.NewDecoder(r).Decode(&req); err != nil { return nil, err } b, err := base64.RawURLEncoding.DecodeString(req.Protected) if err != nil { return nil, err } var head jwsHead if err := json.Unmarshal(b, &head); err != nil { return nil, err } return &head, nil } func TestRegisterWithoutKey(t testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { if r.Method == "HEAD" { w.Header().Set("Replay-Nonce", "test-nonce") return } w.WriteHeader(http.StatusCreated) fmt.Fprint(w, `{}`) })) defer ts.Close() // First verify that using a complete client results in success. c := Client{ Key: testKeyEC, DirectoryURL: ts.URL, dir: &Directory{RegURL: ts.URL}, } if _, err := c.Register(context.Background(), &Account{}, AcceptTOS); err != nil { t.Fatalf("c.Register() = %v; want success with a complete test client", err) } c.Key = nil if _, err := c.Register(context.Background(), &Account{}, AcceptTOS); err == nil { t.Error("c.Register() from client without key succeeded, wanted error") } } func TestAuthorize(t testing.T) { tt := []struct{ typ, value string }{ {"dns", "example.com"}, {"ip", "1.2.3.4"}, } for _, test := range tt { t.Run(test.typ, func(t testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { if r.Method == "HEAD" { w.Header().Set("Replay-Nonce", "test-nonce") return } if r.Method != "POST" { t.Errorf("r.Method = %q; want POST", r.Method) } var j struct { Resource string Identifier struct { Type string Value string } } decodeJWSRequest(t, &j, r.Body) // Test request if j.Resource != "new-authz" { t.Errorf("j.Resource = %q; want new-authz", j.Resource) } if j.Identifier.Type != test.typ { t.Errorf("j.Identifier.Type = %q; want %q", j.Identifier.Type, test.typ) } if j.Identifier.Value != test.value { t.Errorf("j.Identifier.Value = %q; want %q", j.Identifier.Value, test.value) } w.Header().Set("Location", "https://ca.tld/acme/auth/1") w.WriteHeader(http.StatusCreated) fmt.Fprintf(w, `{ "identifier": {"type":%q,"value":%q}, "status":"pending", "challenges":[ { "type":"http-01", "status":"pending", "uri":"https://ca.tld/acme/challenge/publickey/id1", "token":"token1" }, { "type":"tls-sni-01", "status":"pending", "uri":"https://ca.tld/acme/challenge/publickey/id2", "token":"token2" } ], "combinations":[[0],[1]] }`, test.typ, test.value) })) defer ts.Close() var ( auth Authorization err error ) cl := Client{ Key: testKeyEC, DirectoryURL: ts.URL, dir: &Directory{AuthzURL: ts.URL}, } switch test.typ { case "dns": auth, err = cl.Authorize(context.Background(), test.value) case "ip": auth, err = cl.AuthorizeIP(context.Background(), test.value) default: t.Fatalf("unknown identifier type: %q", test.typ) } if err != nil { t.Fatal(err) } if auth.URI != "https://ca.tld/acme/auth/1" { t.Errorf("URI = %q; want https://ca.tld/acme/auth/1", auth.URI) } if auth.Status != "pending" { t.Errorf("Status = %q; want pending", auth.Status) } if auth.Identifier.Type != test.typ { t.Errorf("Identifier.Type = %q; want %q", auth.Identifier.Type, test.typ) } if auth.Identifier.Value != test.value { t.Errorf("Identifier.Value = %q; want %q", auth.Identifier.Value, test.value) } if n := len(auth.Challenges); n != 2 { t.Fatalf("len(auth.Challenges) = %d; want 2", n) } c := auth.Challenges[0] if c.Type != "http-01" { t.Errorf("c.Type = %q; want http-01", c.Type) } if c.URI != "https://ca.tld/acme/challenge/publickey/id1" { t.Errorf("c.URI = %q; want https://ca.tld/acme/challenge/publickey/id1", c.URI) } if c.Token != "token1" { t.Errorf("c.Token = %q; want token1", c.Token) } c = auth.Challenges[1] if c.Type != "tls-sni-01" { t.Errorf("c.Type = %q; want tls-sni-01", c.Type) } if c.URI != "https://ca.tld/acme/challenge/publickey/id2" { t.Errorf("c.URI = %q; want https://ca.tld/acme/challenge/publickey/id2", c.URI) } if c.Token != "token2" { t.Errorf("c.Token = %q; want token2", c.Token) } combs := [][]int{{0}, {1}} if !reflect.DeepEqual(auth.Combinations, combs) { t.Errorf("auth.Combinations: %+v\nwant: %+v\n", auth.Combinations, combs) } }) } } func TestAuthorizeValid(t testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { if r.Method == "HEAD" { w.Header().Set("Replay-Nonce", "nonce") return } w.WriteHeader(http.StatusCreated) w.Write([]byte(`{"status":"valid"}`)) })) defer ts.Close() client := Client{ Key: testKey, DirectoryURL: ts.URL, dir: &Directory{AuthzURL: ts.URL}, } _, err := client.Authorize(context.Background(), "example.com") if err != nil { t.Errorf("err = %v", err) } } func TestWaitAuthorization(t testing.T) { t.Run("wait loop", func(t testing.T) { var count int authz, err := runWaitAuthorization(context.Background(), t, func(w http.ResponseWriter, r http.Request) { count++ w.Header().Set("Retry-After", "0") if count > 1 { fmt.Fprintf(w, `{"status":"valid"}`) return } fmt.Fprintf(w, `{"status":"pending"}`) }) if err != nil { t.Fatalf("non-nil error: %v", err) } if authz == nil { t.Fatal("authz is nil") } }) t.Run("invalid status", func(t testing.T) { _, err := runWaitAuthorization(context.Background(), t, func(w http.ResponseWriter, r http.Request) { fmt.Fprintf(w, `{"status":"invalid"}`) }) if _, ok := err.(AuthorizationError); !ok { t.Errorf("err is %v (%T); want non-nil AuthorizationError", err, err) } }) t.Run("invalid status with error returns the authorization error", func(t testing.T) { _, err := runWaitAuthorization(context.Background(), t, func(w http.ResponseWriter, r http.Request) { fmt.Fprintf(w, `{ "type": "dns-01", "status": "invalid", "error": { "type": "urn:ietf:params:acme:error:caa", "detail": "CAA record for <domain> prevents issuance", "status": 403 }, "url": "https://acme-v02.api.letsencrypt.org/acme/chall-v3/xxx/xxx", "token": "xxx", "validationRecord": [ { "hostname": "<domain>" } ] }`) }) want := &AuthorizationError{ Errors: []error{ (&wireError{ Status: 403, Type: "urn:ietf:params:acme:error:caa", Detail: "CAA record for <domain> prevents issuance", }).error(nil), }, } _, ok := err.(AuthorizationError) if !ok { t.Errorf("err is %T; want non-nil AuthorizationError", err) } if err.Error() != want.Error() { t.Errorf("err is %v; want %v", err, want) } }) t.Run("non-retriable error", func(t testing.T) { const code = http.StatusBadRequest _, err := runWaitAuthorization(context.Background(), t, func(w http.ResponseWriter, r http.Request) { w.WriteHeader(code) }) res, ok := err.(Error) if !ok { t.Fatalf("err is %v (%T); want a non-nil Error", err, err) } if res.StatusCode != code { t.Errorf("res.StatusCode = %d; want %d", res.StatusCode, code) } }) for _, code := range []int{http.StatusTooManyRequests, http.StatusInternalServerError} { t.Run(fmt.Sprintf("retriable %d error", code), func(t testing.T) { var count int authz, err := runWaitAuthorization(context.Background(), t, func(w http.ResponseWriter, r http.Request) { count++ w.Header().Set("Retry-After", "0") if count > 1 { fmt.Fprintf(w, `{"status":"valid"}`) return } w.WriteHeader(code) }) if err != nil { t.Fatalf("non-nil error: %v", err) } if authz == nil { t.Fatal("authz is nil") } }) } t.Run("context cancel", func(t testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() _, err := runWaitAuthorization(ctx, t, func(w http.ResponseWriter, r http.Request) { w.Header().Set("Retry-After", "60") fmt.Fprintf(w, `{"status":"pending"}`) time.AfterFunc(1time.Millisecond, cancel) }) if err == nil { t.Error("err is nil") } }) } func runWaitAuthorization(ctx context.Context, t testing.T, h http.HandlerFunc) (Authorization, error) { t.Helper() ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { w.Header().Set("Replay-Nonce", fmt.Sprintf("bad-test-nonce-%v", time.Now().UnixNano())) h(w, r) })) defer ts.Close() client := &Client{ Key: testKey, DirectoryURL: ts.URL, dir: &Directory{}, KID: "some-key-id", // set to avoid lookup attempt } return client.WaitAuthorization(ctx, ts.URL) } func TestRevokeAuthorization(t testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { if r.Method == "HEAD" { w.Header().Set("Replay-Nonce", "nonce") return } switch r.URL.Path { case "/1": var req struct { Resource string Status string Delete bool } decodeJWSRequest(t, &req, r.Body) if req.Resource != "authz" { t.Errorf("req.Resource = %q; want authz", req.Resource) } if req.Status != "deactivated" { t.Errorf("req.Status = %q; want deactivated", req.Status) } if !req.Delete { t.Errorf("req.Delete is false") } case "/2": w.WriteHeader(http.StatusBadRequest) } })) defer ts.Close() client := &Client{ Key: testKey, DirectoryURL: ts.URL, // don't dial outside of localhost dir: &Directory{}, // don't do discovery } ctx := context.Background() if err := client.RevokeAuthorization(ctx, ts.URL+"/1"); err != nil { t.Errorf("err = %v", err) } if client.RevokeAuthorization(ctx, ts.URL+"/2") == nil { t.Error("nil error") } } func TestFetchCertCancel(t testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { <-r.Context().Done() w.Header().Set("Retry-After", "0") w.WriteHeader(http.StatusBadRequest) })) defer ts.Close() ctx, cancel := context.WithCancel(context.Background()) done := make(chan struct{}) var err error go func() { cl := newTestClient() _, err = cl.FetchCert(ctx, ts.URL, false) close(done) }() cancel() <-done if err != context.Canceled { t.Errorf("err = %v; want %v", err, context.Canceled) } } func TestFetchCertDepth(t testing.T) { var count byte var ts httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { count++ if count > maxChainLen+1 { t.Errorf("count = %d; want at most %d", count, maxChainLen+1) w.WriteHeader(http.StatusInternalServerError) } w.Header().Set("Link", fmt.Sprintf("<%s>;rel=up", ts.URL)) w.Write([]byte{count}) })) defer ts.Close() cl := newTestClient() _, err := cl.FetchCert(context.Background(), ts.URL, true) if err == nil { t.Errorf("err is nil") } } func TestFetchCertBreadth(t testing.T) { var ts httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { for i := 0; i < maxChainLen+1; i++ { w.Header().Add("Link", fmt.Sprintf("<%s>;rel=up", ts.URL)) } w.Write([]byte{1}) })) defer ts.Close() cl := newTestClient() _, err := cl.FetchCert(context.Background(), ts.URL, true) if err == nil { t.Errorf("err is nil") } } func TestFetchCertSize(t testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { b := bytes.Repeat([]byte{1}, maxCertSize+1) w.Write(b) })) defer ts.Close() cl := newTestClient() _, err := cl.FetchCert(context.Background(), ts.URL, false) if err == nil { t.Errorf("err is nil") } } func TestNonce_add(t testing.T) { var c Client c.addNonce(http.Header{"Replay-Nonce": {"nonce"}}) c.addNonce(http.Header{"Replay-Nonce": {}}) c.addNonce(http.Header{"Replay-Nonce": {"nonce"}}) nonces := map[string]struct{}{"nonce": {}} if !reflect.DeepEqual(c.nonces, nonces) { t.Errorf("c.nonces = %q; want %q", c.nonces, nonces) } } func TestNonce_addMax(t testing.T) { c := &Client{nonces: make(map[string]struct{})} for i := 0; i < maxNonces; i++ { c.nonces[fmt.Sprintf("%d", i)] = struct{}{} } c.addNonce(http.Header{"Replay-Nonce": {"nonce"}}) if n := len(c.nonces); n != maxNonces { t.Errorf("len(c.nonces) = %d; want %d", n, maxNonces) } } func TestNonce_fetch(t testing.T) { tests := []struct { code int nonce string }{ {http.StatusOK, "nonce1"}, {http.StatusBadRequest, "nonce2"}, {http.StatusOK, ""}, } var i int ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { if r.Method != "HEAD" { t.Errorf("%d: r.Method = %q; want HEAD", i, r.Method) } w.Header().Set("Replay-Nonce", tests[i].nonce) w.WriteHeader(tests[i].code) })) defer ts.Close() for ; i < len(tests); i++ { test := tests[i] c := newTestClient() n, err := c.fetchNonce(context.Background(), ts.URL) if n != test.nonce { t.Errorf("%d: n=%q; want %q", i, n, test.nonce) } switch { case err == nil && test.nonce == "": t.Errorf("%d: n=%q, err=%v; want non-nil error", i, n, err) case err != nil && test.nonce != "": t.Errorf("%d: n=%q, err=%v; want %q", i, n, err, test.nonce) } } } func TestNonce_fetchError(t testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { w.WriteHeader(http.StatusTooManyRequests) })) defer ts.Close() c := newTestClient() _, err := c.fetchNonce(context.Background(), ts.URL) e, ok := err.(Error) if !ok { t.Fatalf("err is %T; want Error", err) } if e.StatusCode != http.StatusTooManyRequests { t.Errorf("e.StatusCode = %d; want %d", e.StatusCode, http.StatusTooManyRequests) } } func TestNonce_popWhenEmpty(t testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { if r.Method != "HEAD" { t.Errorf("r.Method = %q; want HEAD", r.Method) } switch r.URL.Path { case "/dir-with-nonce": w.Header().Set("Replay-Nonce", "dirnonce") case "/new-nonce": w.Header().Set("Replay-Nonce", "newnonce") case "/dir-no-nonce", "/empty": // No nonce in the header. default: t.Errorf("Unknown URL: %s", r.URL) } })) defer ts.Close() ctx := context.Background() tt := []struct { dirURL, popURL, nonce string wantOK bool }{ {ts.URL + "/dir-with-nonce", ts.URL + "/new-nonce", "dirnonce", true}, {ts.URL + "/dir-no-nonce", ts.URL + "/new-nonce", "newnonce", true}, {ts.URL + "/dir-no-nonce", ts.URL + "/empty", "", false}, } for _, test := range tt { t.Run(fmt.Sprintf("nonce:%s wantOK:%v", test.nonce, test.wantOK), func(t testing.T) { c := Client{DirectoryURL: test.dirURL} v, err := c.popNonce(ctx, test.popURL) if !test.wantOK { if err == nil { t.Fatalf("c.popNonce(%q) returned nil error", test.popURL) } return } if err != nil { t.Fatalf("c.popNonce(%q): %v", test.popURL, err) } if v != test.nonce { t.Errorf("c.popNonce(%q) = %q; want %q", test.popURL, v, test.nonce) } }) } } func TestLinkHeader(t testing.T) { h := http.Header{"Link": { `<https://example.com/acme/new-authz>;rel="next"`, `<https://example.com/acme/recover-reg>; rel=recover`, `<https://example.com/acme/terms>; foo=bar; rel="terms-of-service"`, `<dup>;rel="next"`, }} tests := []struct { rel string out []string }{ {"next", []string{"https://example.com/acme/new-authz", "dup"}}, {"recover", []string{"https://example.com/acme/recover-reg"}}, {"terms-of-service", []string{"https://example.com/acme/terms"}}, {"empty", nil}, } for i, test := range tests { if v := linkHeader(h, test.rel); !reflect.DeepEqual(v, test.out) { t.Errorf("%d: linkHeader(%q): %v; want %v", i, test.rel, v, test.out) } } } func TestTLSSNI01ChallengeCert(t testing.T) { const ( token = "evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA" // echo -n <token.testKeyECThumbprint> \| shasum -a 256 san = "dbbd5eefe7b4d06eb9d1d9f5acb4c7cd.a27d320e4b30332f0b6cb441734ad7b0.acme.invalid" ) tlscert, name, err := newTestClient().TLSSNI01ChallengeCert(token) if err != nil { t.Fatal(err) } if n := len(tlscert.Certificate); n != 1 { t.Fatalf("len(tlscert.Certificate) = %d; want 1", n) } cert, err := x509.ParseCertificate(tlscert.Certificate[0]) if err != nil { t.Fatal(err) } if len(cert.DNSNames) != 1 \|\| cert.DNSNames[0] != san { t.Fatalf("cert.DNSNames = %v; want %q", cert.DNSNames, san) } if cert.DNSNames[0] != name { t.Errorf("cert.DNSNames[0] != name: %q vs %q", cert.DNSNames[0], name) } if cn := cert.Subject.CommonName; cn != san { t.Errorf("cert.Subject.CommonName = %q; want %q", cn, san) } } func TestTLSSNI02ChallengeCert(t testing.T) { const ( token = "evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA" // echo -n evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA \| shasum -a 256 sanA = "7ea0aaa69214e71e02cebb18bb867736.09b730209baabf60e43d4999979ff139.token.acme.invalid" // echo -n <token.testKeyECThumbprint> \| shasum -a 256 sanB = "dbbd5eefe7b4d06eb9d1d9f5acb4c7cd.a27d320e4b30332f0b6cb441734ad7b0.ka.acme.invalid" ) tlscert, name, err := newTestClient().TLSSNI02ChallengeCert(token) if err != nil { t.Fatal(err) } if n := len(tlscert.Certificate); n != 1 { t.Fatalf("len(tlscert.Certificate) = %d; want 1", n) } cert, err := x509.ParseCertificate(tlscert.Certificate[0]) if err != nil { t.Fatal(err) } names := []string{sanA, sanB} if !reflect.DeepEqual(cert.DNSNames, names) { t.Fatalf("cert.DNSNames = %v;\nwant %v", cert.DNSNames, names) } sort.Strings(cert.DNSNames) i := sort.SearchStrings(cert.DNSNames, name) if i >= len(cert.DNSNames) \|\| cert.DNSNames[i] != name { t.Errorf("%v doesn't have %q", cert.DNSNames, name) } if cn := cert.Subject.CommonName; cn != sanA { t.Errorf("CommonName = %q; want %q", cn, sanA) } } func TestTLSALPN01ChallengeCert(t testing.T) { const ( token = "evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA" keyAuth = "evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA." + testKeyECThumbprint // echo -n <token.testKeyECThumbprint> \| shasum -a 256 h = "0420dbbd5eefe7b4d06eb9d1d9f5acb4c7cda27d320e4b30332f0b6cb441734ad7b0" domain = "example.com" ) extValue, err := hex.DecodeString(h) if err != nil { t.Fatal(err) } tlscert, err := newTestClient().TLSALPN01ChallengeCert(token, domain) if err != nil { t.Fatal(err) } if n := len(tlscert.Certificate); n != 1 { t.Fatalf("len(tlscert.Certificate) = %d; want 1", n) } cert, err := x509.ParseCertificate(tlscert.Certificate[0]) if err != nil { t.Fatal(err) } names := []string{domain} if !reflect.DeepEqual(cert.DNSNames, names) { t.Fatalf("cert.DNSNames = %v;\nwant %v", cert.DNSNames, names) } if cn := cert.Subject.CommonName; cn != domain { t.Errorf("CommonName = %q; want %q", cn, domain) } acmeExts := []pkix.Extension{} for _, ext := range cert.Extensions { if idPeACMEIdentifier.Equal(ext.Id) { acmeExts = append(acmeExts, ext) } } if len(acmeExts) != 1 { t.Errorf("acmeExts = %v; want exactly one", acmeExts) } if !acmeExts[0].Critical { t.Errorf("acmeExt.Critical = %v; want true", acmeExts[0].Critical) } if bytes.Compare(acmeExts[0].Value, extValue) != 0 { t.Errorf("acmeExt.Value = %v; want %v", acmeExts[0].Value, extValue) } } func TestTLSChallengeCertOpt(t testing.T) { key, err := rsa.GenerateKey(rand.Reader, 512) if err != nil { t.Fatal(err) } tmpl := &x509.Certificate{ SerialNumber: big.NewInt(2), Subject: pkix.Name{Organization: []string{"Test"}}, DNSNames: []string{"should-be-overwritten"}, } opts := []CertOption{WithKey(key), WithTemplate(tmpl)} client := newTestClient() cert1, _, err := client.TLSSNI01ChallengeCert("token", opts...) if err != nil { t.Fatal(err) } cert2, _, err := client.TLSSNI02ChallengeCert("token", opts...) if err != nil { t.Fatal(err) } for i, tlscert := range []tls.Certificate{cert1, cert2} { // verify generated cert private key tlskey, ok := tlscert.PrivateKey.(rsa.PrivateKey) if !ok { t.Errorf("%d: tlscert.PrivateKey is %T; want rsa.PrivateKey", i, tlscert.PrivateKey) continue } if tlskey.D.Cmp(key.D) != 0 { t.Errorf("%d: tlskey.D = %v; want %v", i, tlskey.D, key.D) } // verify generated cert public key x509Cert, err := x509.ParseCertificate(tlscert.Certificate[0]) if err != nil { t.Errorf("%d: %v", i, err) continue } tlspub, ok := x509Cert.PublicKey.(rsa.PublicKey) if !ok { t.Errorf("%d: x509Cert.PublicKey is %T; want rsa.PublicKey", i, x509Cert.PublicKey) continue } if tlspub.N.Cmp(key.N) != 0 { t.Errorf("%d: tlspub.N = %v; want %v", i, tlspub.N, key.N) } // verify template option sn := big.NewInt(2) if x509Cert.SerialNumber.Cmp(sn) != 0 { t.Errorf("%d: SerialNumber = %v; want %v", i, x509Cert.SerialNumber, sn) } org := []string{"Test"} if !reflect.DeepEqual(x509Cert.Subject.Organization, org) { t.Errorf("%d: Subject.Organization = %+v; want %+v", i, x509Cert.Subject.Organization, org) } for _, v := range x509Cert.DNSNames { if !strings.HasSuffix(v, ".acme.invalid") { t.Errorf("%d: invalid DNSNames element: %q", i, v) } } } } func TestHTTP01Challenge(t testing.T) { const ( token = "xxx" // thumbprint is precomputed for testKeyEC in jws_test.go value = token + "." + testKeyECThumbprint urlpath = "/.well-known/acme-challenge/" + token ) client := newTestClient() val, err := client.HTTP01ChallengeResponse(token) if err != nil { t.Fatal(err) } if val != value { t.Errorf("val = %q; want %q", val, value) } if path := client.HTTP01ChallengePath(token); path != urlpath { t.Errorf("path = %q; want %q", path, urlpath) } } func TestDNS01ChallengeRecord(t testing.T) { // echo -n xxx.<testKeyECThumbprint> \| \ // openssl dgst -binary -sha256 \| \ // base64 \| tr -d '=' \| tr '/+' '_-' const value = "8DERMexQ5VcdJ_prpPiA0mVdp7imgbCgjsG4SqqNMIo" val, err := newTestClient().DNS01ChallengeRecord("xxx") if err != nil { t.Fatal(err) } if val != value { t.Errorf("val = %q; want %q", val, value) } }	23.35 KB	2025-05-25 12:27
📁 autocert	-	2025-05-25 12:27
📄 http.go // Copyright 2018 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package acme import ( "bytes" "context" "crypto" "crypto/rand" "encoding/json" "errors" "fmt" "io" "math/big" "net/http" "runtime/debug" "strconv" "strings" "time" ) // retryTimer encapsulates common logic for retrying unsuccessful requests. // It is not safe for concurrent use. type retryTimer struct { // backoffFn provides backoff delay sequence for retries. // See Client.RetryBackoff doc comment. backoffFn func(n int, r http.Request, res http.Response) time.Duration // n is the current retry attempt. n int } func (t retryTimer) inc() { t.n++ } // backoff pauses the current goroutine as described in Client.RetryBackoff. func (t retryTimer) backoff(ctx context.Context, r http.Request, res http.Response) error { d := t.backoffFn(t.n, r, res) if d <= 0 { return fmt.Errorf("acme: no more retries for %s; tried %d time(s)", r.URL, t.n) } wakeup := time.NewTimer(d) defer wakeup.Stop() select { case <-ctx.Done(): return ctx.Err() case <-wakeup.C: return nil } } func (c Client) retryTimer() retryTimer { f := c.RetryBackoff if f == nil { f = defaultBackoff } return &retryTimer{backoffFn: f} } // defaultBackoff provides default Client.RetryBackoff implementation // using a truncated exponential backoff algorithm, // as described in Client.RetryBackoff. // // The n argument is always bounded between 1 and 30. // The returned value is always greater than 0. func defaultBackoff(n int, r http.Request, res http.Response) time.Duration { const max = 10 * time.Second var jitter time.Duration if x, err := rand.Int(rand.Reader, big.NewInt(1000)); err == nil { // Set the minimum to 1ms to avoid a case where // an invalid Retry-After value is parsed into 0 below, // resulting in the 0 returned value which would unintentionally // stop the retries. jitter = (1 + time.Duration(x.Int64())) * time.Millisecond } if v, ok := res.Header["Retry-After"]; ok { return retryAfter(v[0]) + jitter } if n < 1 { n = 1 } if n > 30 { n = 30 } d := time.Duration(1<<uint(n-1))time.Second + jitter if d > max { return max } return d } // retryAfter parses a Retry-After HTTP header value, // trying to convert v into an int (seconds) or use http.ParseTime otherwise. // It returns zero value if v cannot be parsed. func retryAfter(v string) time.Duration { if i, err := strconv.Atoi(v); err == nil { return time.Duration(i) time.Second } t, err := http.ParseTime(v) if err != nil { return 0 } return t.Sub(timeNow()) } // resOkay is a function that reports whether the provided response is okay. // It is expected to keep the response body unread. type resOkay func(http.Response) bool // wantStatus returns a function which reports whether the code // matches the status code of a response. func wantStatus(codes ...int) resOkay { return func(res http.Response) bool { for _, code := range codes { if code == res.StatusCode { return true } } return false } } // get issues an unsigned GET request to the specified URL. // It returns a non-error value only when ok reports true. // // get retries unsuccessful attempts according to c.RetryBackoff // until the context is done or a non-retriable error is received. func (c Client) get(ctx context.Context, url string, ok resOkay) (http.Response, error) { retry := c.retryTimer() for { req, err := http.NewRequest("GET", url, nil) if err != nil { return nil, err } res, err := c.doNoRetry(ctx, req) switch { case err != nil: return nil, err case ok(res): return res, nil case isRetriable(res.StatusCode): retry.inc() resErr := responseError(res) res.Body.Close() // Ignore the error value from retry.backoff // and return the one from last retry, as received from the CA. if retry.backoff(ctx, req, res) != nil { return nil, resErr } default: defer res.Body.Close() return nil, responseError(res) } } } // postAsGet is POST-as-GET, a replacement for GET in RFC 8555 // as described in https://tools.ietf.org/html/rfc8555#section-6.3. // It makes a POST request in KID form with zero JWS payload. // See nopayload doc comments in jws.go. func (c Client) postAsGet(ctx context.Context, url string, ok resOkay) (http.Response, error) { return c.post(ctx, nil, url, noPayload, ok) } // post issues a signed POST request in JWS format using the provided key // to the specified URL. If key is nil, c.Key is used instead. // It returns a non-error value only when ok reports true. // // post retries unsuccessful attempts according to c.RetryBackoff // until the context is done or a non-retriable error is received. // It uses postNoRetry to make individual requests. func (c Client) post(ctx context.Context, key crypto.Signer, url string, body interface{}, ok resOkay) (http.Response, error) { retry := c.retryTimer() for { res, req, err := c.postNoRetry(ctx, key, url, body) if err != nil { return nil, err } if ok(res) { return res, nil } resErr := responseError(res) res.Body.Close() switch { // Check for bad nonce before isRetriable because it may have been returned // with an unretriable response code such as 400 Bad Request. case isBadNonce(resErr): // Consider any previously stored nonce values to be invalid. c.clearNonces() case !isRetriable(res.StatusCode): return nil, resErr } retry.inc() // Ignore the error value from retry.backoff // and return the one from last retry, as received from the CA. if err := retry.backoff(ctx, req, res); err != nil { return nil, resErr } } } // postNoRetry signs the body with the given key and POSTs it to the provided url. // It is used by c.post to retry unsuccessful attempts. // The body argument must be JSON-serializable. // // If key argument is nil, c.Key is used to sign the request. // If key argument is nil and c.accountKID returns a non-zero keyID, // the request is sent in KID form. Otherwise, JWK form is used. // // In practice, when interfacing with RFC-compliant CAs most requests are sent in KID form // and JWK is used only when KID is unavailable: new account endpoint and certificate // revocation requests authenticated by a cert key. // See jwsEncodeJSON for other details. func (c Client) postNoRetry(ctx context.Context, key crypto.Signer, url string, body interface{}) (http.Response, http.Request, error) { kid := noKeyID if key == nil { if c.Key == nil { return nil, nil, errors.New("acme: Client.Key must be populated to make POST requests") } key = c.Key kid = c.accountKID(ctx) } nonce, err := c.popNonce(ctx, url) if err != nil { return nil, nil, err } b, err := jwsEncodeJSON(body, key, kid, nonce, url) if err != nil { return nil, nil, err } req, err := http.NewRequest("POST", url, bytes.NewReader(b)) if err != nil { return nil, nil, err } req.Header.Set("Content-Type", "application/jose+json") res, err := c.doNoRetry(ctx, req) if err != nil { return nil, nil, err } c.addNonce(res.Header) return res, req, nil } // doNoRetry issues a request req, replacing its context (if any) with ctx. func (c Client) doNoRetry(ctx context.Context, req http.Request) (http.Response, error) { req.Header.Set("User-Agent", c.userAgent()) res, err := c.httpClient().Do(req.WithContext(ctx)) if err != nil { select { case <-ctx.Done(): // Prefer the unadorned context error. // (The acme package had tests assuming this, previously from ctxhttp's // behavior, predating net/http supporting contexts natively) // TODO(bradfitz): reconsider this in the future. But for now this // requires no test updates. return nil, ctx.Err() default: return nil, err } } return res, nil } func (c Client) httpClient() http.Client { if c.HTTPClient != nil { return c.HTTPClient } return http.DefaultClient } // packageVersion is the version of the module that contains this package, for // sending as part of the User-Agent header. var packageVersion string func init() { // Set packageVersion if the binary was built in modules mode and x/crypto // was not replaced with a different module. info, ok := debug.ReadBuildInfo() if !ok { return } for _, m := range info.Deps { if m.Path != "golang.org/x/crypto" { continue } if m.Replace == nil { packageVersion = m.Version } break } } // userAgent returns the User-Agent header value. It includes the package name, // the module version (if available), and the c.UserAgent value (if set). func (c Client) userAgent() string { ua := "golang.org/x/crypto/acme" if packageVersion != "" { ua += "@" + packageVersion } if c.UserAgent != "" { ua = c.UserAgent + " " + ua } return ua } // isBadNonce reports whether err is an ACME "badnonce" error. func isBadNonce(err error) bool { // According to the spec badNonce is urn:ietf:params:acme:error:badNonce. // However, ACME servers in the wild return their versions of the error. // See https://tools.ietf.org/html/draft-ietf-acme-acme-02#section-5.4 // and https://github.com/letsencrypt/boulder/blob/0e07eacb/docs/acme-divergences.md#section-66. ae, ok := err.(Error) return ok && strings.HasSuffix(strings.ToLower(ae.ProblemType), ":badnonce") } // isRetriable reports whether a request can be retried // based on the response status code. // // Note that a "bad nonce" error is returned with a non-retriable 400 Bad Request code. // Callers should parse the response and check with isBadNonce. func isRetriable(code int) bool { return code <= 399 \|\| code >= 500 \|\| code == http.StatusTooManyRequests } // responseError creates an error of Error type from resp. func responseError(resp *http.Response) error { // don't care if ReadAll returns an error: // json.Unmarshal will fail in that case anyway b, _ := io.ReadAll(resp.Body) e := &wireError{Status: resp.StatusCode} if err := json.Unmarshal(b, e); err != nil { // this is not a regular error response: // populate detail with anything we received, // e.Status will already contain HTTP response code value e.Detail = string(b) if e.Detail == "" { e.Detail = resp.Status } } return e.error(resp.Header) }	10.08 KB	2025-05-25 12:27
📄 http_test.go // Copyright 2018 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package acme import ( "context" "fmt" "io" "net/http" "net/http/httptest" "reflect" "strings" "testing" "time" ) func TestDefaultBackoff(t testing.T) { tt := []struct { nretry int retryAfter string // Retry-After header out time.Duration // expected min; max = min + jitter }{ {-1, "", time.Second}, // verify the lower bound is 1 {0, "", time.Second}, // verify the lower bound is 1 {100, "", 10 time.Second}, // verify the ceiling {1, "3600", time.Hour}, // verify the header value is used {1, "", 1 * time.Second}, {2, "", 2 * time.Second}, {3, "", 4 * time.Second}, {4, "", 8 * time.Second}, } for i, test := range tt { r := httptest.NewRequest("GET", "/", nil) resp := &http.Response{Header: http.Header{}} if test.retryAfter != "" { resp.Header.Set("Retry-After", test.retryAfter) } d := defaultBackoff(test.nretry, r, resp) max := test.out + time.Second // + max jitter if d < test.out \|\| max < d { t.Errorf("%d: defaultBackoff(%v) = %v; want between %v and %v", i, test.nretry, d, test.out, max) } } } func TestErrorResponse(t testing.T) { s := `{ "status": 400, "type": "urn:acme:error:xxx", "detail": "text" }` res := &http.Response{ StatusCode: 400, Status: "400 Bad Request", Body: io.NopCloser(strings.NewReader(s)), Header: http.Header{"X-Foo": {"bar"}}, } err := responseError(res) v, ok := err.(Error) if !ok { t.Fatalf("err = %+v (%T); want Error type", err, err) } if v.StatusCode != 400 { t.Errorf("v.StatusCode = %v; want 400", v.StatusCode) } if v.ProblemType != "urn:acme:error:xxx" { t.Errorf("v.ProblemType = %q; want urn:acme:error:xxx", v.ProblemType) } if v.Detail != "text" { t.Errorf("v.Detail = %q; want text", v.Detail) } if !reflect.DeepEqual(v.Header, res.Header) { t.Errorf("v.Header = %+v; want %+v", v.Header, res.Header) } } func TestPostWithRetries(t testing.T) { var count int ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { count++ w.Header().Set("Replay-Nonce", fmt.Sprintf("nonce%d", count)) if r.Method == "HEAD" { // We expect the client to do 2 head requests to fetch // nonces, one to start and another after getting badNonce return } head, err := decodeJWSHead(r.Body) switch { case err != nil: t.Errorf("decodeJWSHead: %v", err) case head.Nonce == "": t.Error("head.Nonce is empty") case head.Nonce == "nonce1": // Return a badNonce error to force the call to retry. w.Header().Set("Retry-After", "0") w.WriteHeader(http.StatusBadRequest) w.Write([]byte(`{"type":"urn:ietf:params:acme:error:badNonce"}`)) return } // Make client.Authorize happy; we're not testing its result. w.WriteHeader(http.StatusCreated) w.Write([]byte(`{"status":"valid"}`)) })) defer ts.Close() client := &Client{ Key: testKey, DirectoryURL: ts.URL, dir: &Directory{AuthzURL: ts.URL}, } // This call will fail with badNonce, causing a retry if _, err := client.Authorize(context.Background(), "example.com"); err != nil { t.Errorf("client.Authorize 1: %v", err) } if count != 3 { t.Errorf("total requests count: %d; want 3", count) } } func TestRetryErrorType(t testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { w.Header().Set("Replay-Nonce", "nonce") w.WriteHeader(http.StatusTooManyRequests) w.Write([]byte(`{"type":"rateLimited"}`)) })) defer ts.Close() client := &Client{ Key: testKey, RetryBackoff: func(n int, r http.Request, res http.Response) time.Duration { // Do no retries. return 0 }, dir: &Directory{AuthzURL: ts.URL}, } t.Run("post", func(t testing.T) { testRetryErrorType(t, func() error { _, err := client.Authorize(context.Background(), "example.com") return err }) }) t.Run("get", func(t testing.T) { testRetryErrorType(t, func() error { _, err := client.GetAuthorization(context.Background(), ts.URL) return err }) }) } func testRetryErrorType(t testing.T, callClient func() error) { t.Helper() err := callClient() if err == nil { t.Fatal("client.Authorize returned nil error") } acmeErr, ok := err.(Error) if !ok { t.Fatalf("err is %v (%T); want Error", err, err) } if acmeErr.StatusCode != http.StatusTooManyRequests { t.Errorf("acmeErr.StatusCode = %d; want %d", acmeErr.StatusCode, http.StatusTooManyRequests) } if acmeErr.ProblemType != "rateLimited" { t.Errorf("acmeErr.ProblemType = %q; want 'rateLimited'", acmeErr.ProblemType) } } func TestRetryBackoffArgs(t testing.T) { const resCode = http.StatusInternalServerError ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { w.Header().Set("Replay-Nonce", "test-nonce") w.WriteHeader(resCode) })) defer ts.Close() // Canceled in backoff. ctx, cancel := context.WithCancel(context.Background()) var nretry int backoff := func(n int, r http.Request, res http.Response) time.Duration { nretry++ if n != nretry { t.Errorf("n = %d; want %d", n, nretry) } if nretry == 3 { cancel() } if r == nil { t.Error("r is nil") } if res.StatusCode != resCode { t.Errorf("res.StatusCode = %d; want %d", res.StatusCode, resCode) } return time.Millisecond } client := &Client{ Key: testKey, RetryBackoff: backoff, dir: &Directory{AuthzURL: ts.URL}, } if _, err := client.Authorize(ctx, "example.com"); err == nil { t.Error("err is nil") } if nretry != 3 { t.Errorf("nretry = %d; want 3", nretry) } } func TestUserAgent(t testing.T) { for _, custom := range []string{"", "CUSTOM_UA"} { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { t.Log(r.UserAgent()) if s := "golang.org/x/crypto/acme"; !strings.Contains(r.UserAgent(), s) { t.Errorf("expected User-Agent to contain %q, got %q", s, r.UserAgent()) } if !strings.Contains(r.UserAgent(), custom) { t.Errorf("expected User-Agent to contain %q, got %q", custom, r.UserAgent()) } w.WriteHeader(http.StatusOK) w.Write([]byte(`{"newOrder": "sure"}`)) })) defer ts.Close() client := &Client{ Key: testKey, DirectoryURL: ts.URL, UserAgent: custom, } if _, err := client.Discover(context.Background()); err != nil { t.Errorf("client.Discover: %v", err) } } } func TestAccountKidLoop(t *testing.T) { // if Client.postNoRetry is called with a nil key argument // then Client.Key must be set, otherwise we fall into an // infinite loop (which also causes a deadlock). client := &Client{dir: &Directory{OrderURL: ":)"}} _, _, err := client.postNoRetry(context.Background(), nil, "", nil) if err == nil { t.Fatal("Client.postNoRetry didn't fail with a nil key") } expected := "acme: Client.Key must be populated to make POST requests" if err.Error() != expected { t.Fatalf("Unexpected error returned: wanted %q, got %q", expected, err.Error()) } }	7.04 KB	2025-05-25 12:27
📁 internal	-	2025-05-25 12:27
📄 jws.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package acme import ( "crypto" "crypto/ecdsa" "crypto/hmac" "crypto/rand" "crypto/rsa" "crypto/sha256" _ "crypto/sha512" // need for EC keys "encoding/asn1" "encoding/base64" "encoding/json" "errors" "fmt" "math/big" ) // KeyID is the account key identity provided by a CA during registration. type KeyID string // noKeyID indicates that jwsEncodeJSON should compute and use JWK instead of a KID. // See jwsEncodeJSON for details. const noKeyID = KeyID("") // noPayload indicates jwsEncodeJSON will encode zero-length octet string // in a JWS request. This is called POST-as-GET in RFC 8555 and is used to make // authenticated GET requests via POSTing with an empty payload. // See https://tools.ietf.org/html/rfc8555#section-6.3 for more details. const noPayload = "" // noNonce indicates that the nonce should be omitted from the protected header. // See jwsEncodeJSON for details. const noNonce = "" // jsonWebSignature can be easily serialized into a JWS following // https://tools.ietf.org/html/rfc7515#section-3.2. type jsonWebSignature struct { Protected string `json:"protected"` Payload string `json:"payload"` Sig string `json:"signature"` } // jwsEncodeJSON signs claimset using provided key and a nonce. // The result is serialized in JSON format containing either kid or jwk // fields based on the provided KeyID value. // // The claimset is marshalled using json.Marshal unless it is a string. // In which case it is inserted directly into the message. // // If kid is non-empty, its quoted value is inserted in the protected header // as "kid" field value. Otherwise, JWK is computed using jwkEncode and inserted // as "jwk" field value. The "jwk" and "kid" fields are mutually exclusive. // // If nonce is non-empty, its quoted value is inserted in the protected header. // // See https://tools.ietf.org/html/rfc7515#section-7. func jwsEncodeJSON(claimset interface{}, key crypto.Signer, kid KeyID, nonce, url string) ([]byte, error) { if key == nil { return nil, errors.New("nil key") } alg, sha := jwsHasher(key.Public()) if alg == "" \|\| !sha.Available() { return nil, ErrUnsupportedKey } headers := struct { Alg string `json:"alg"` KID string `json:"kid,omitempty"` JWK json.RawMessage `json:"jwk,omitempty"` Nonce string `json:"nonce,omitempty"` URL string `json:"url"` }{ Alg: alg, Nonce: nonce, URL: url, } switch kid { case noKeyID: jwk, err := jwkEncode(key.Public()) if err != nil { return nil, err } headers.JWK = json.RawMessage(jwk) default: headers.KID = string(kid) } phJSON, err := json.Marshal(headers) if err != nil { return nil, err } phead := base64.RawURLEncoding.EncodeToString([]byte(phJSON)) var payload string if val, ok := claimset.(string); ok { payload = val } else { cs, err := json.Marshal(claimset) if err != nil { return nil, err } payload = base64.RawURLEncoding.EncodeToString(cs) } hash := sha.New() hash.Write([]byte(phead + "." + payload)) sig, err := jwsSign(key, sha, hash.Sum(nil)) if err != nil { return nil, err } enc := jsonWebSignature{ Protected: phead, Payload: payload, Sig: base64.RawURLEncoding.EncodeToString(sig), } return json.Marshal(&enc) } // jwsWithMAC creates and signs a JWS using the given key and the HS256 // algorithm. kid and url are included in the protected header. rawPayload // should not be base64-URL-encoded. func jwsWithMAC(key []byte, kid, url string, rawPayload []byte) (jsonWebSignature, error) { if len(key) == 0 { return nil, errors.New("acme: cannot sign JWS with an empty MAC key") } header := struct { Algorithm string `json:"alg"` KID string `json:"kid"` URL string `json:"url,omitempty"` }{ // Only HMAC-SHA256 is supported. Algorithm: "HS256", KID: kid, URL: url, } rawProtected, err := json.Marshal(header) if err != nil { return nil, err } protected := base64.RawURLEncoding.EncodeToString(rawProtected) payload := base64.RawURLEncoding.EncodeToString(rawPayload) h := hmac.New(sha256.New, key) if _, err := h.Write([]byte(protected + "." + payload)); err != nil { return nil, err } mac := h.Sum(nil) return &jsonWebSignature{ Protected: protected, Payload: payload, Sig: base64.RawURLEncoding.EncodeToString(mac), }, nil } // jwkEncode encodes public part of an RSA or ECDSA key into a JWK. // The result is also suitable for creating a JWK thumbprint. // https://tools.ietf.org/html/rfc7517 func jwkEncode(pub crypto.PublicKey) (string, error) { switch pub := pub.(type) { case rsa.PublicKey: // https://tools.ietf.org/html/rfc7518#section-6.3.1 n := pub.N e := big.NewInt(int64(pub.E)) // Field order is important. // See https://tools.ietf.org/html/rfc7638#section-3.3 for details. return fmt.Sprintf(`{"e":"%s","kty":"RSA","n":"%s"}`, base64.RawURLEncoding.EncodeToString(e.Bytes()), base64.RawURLEncoding.EncodeToString(n.Bytes()), ), nil case ecdsa.PublicKey: // https://tools.ietf.org/html/rfc7518#section-6.2.1 p := pub.Curve.Params() n := p.BitSize / 8 if p.BitSize%8 != 0 { n++ } x := pub.X.Bytes() if n > len(x) { x = append(make([]byte, n-len(x)), x...) } y := pub.Y.Bytes() if n > len(y) { y = append(make([]byte, n-len(y)), y...) } // Field order is important. // See https://tools.ietf.org/html/rfc7638#section-3.3 for details. return fmt.Sprintf(`{"crv":"%s","kty":"EC","x":"%s","y":"%s"}`, p.Name, base64.RawURLEncoding.EncodeToString(x), base64.RawURLEncoding.EncodeToString(y), ), nil } return "", ErrUnsupportedKey } // jwsSign signs the digest using the given key. // The hash is unused for ECDSA keys. func jwsSign(key crypto.Signer, hash crypto.Hash, digest []byte) ([]byte, error) { switch pub := key.Public().(type) { case rsa.PublicKey: return key.Sign(rand.Reader, digest, hash) case ecdsa.PublicKey: sigASN1, err := key.Sign(rand.Reader, digest, hash) if err != nil { return nil, err } var rs struct{ R, S big.Int } if _, err := asn1.Unmarshal(sigASN1, &rs); err != nil { return nil, err } rb, sb := rs.R.Bytes(), rs.S.Bytes() size := pub.Params().BitSize / 8 if size%8 > 0 { size++ } sig := make([]byte, size2) copy(sig[size-len(rb):], rb) copy(sig[size2-len(sb):], sb) return sig, nil } return nil, ErrUnsupportedKey } // jwsHasher indicates suitable JWS algorithm name and a hash function // to use for signing a digest with the provided key. // It returns ("", 0) if the key is not supported. func jwsHasher(pub crypto.PublicKey) (string, crypto.Hash) { switch pub := pub.(type) { case rsa.PublicKey: return "RS256", crypto.SHA256 case ecdsa.PublicKey: switch pub.Params().Name { case "P-256": return "ES256", crypto.SHA256 case "P-384": return "ES384", crypto.SHA384 case "P-521": return "ES512", crypto.SHA512 } } return "", 0 } // JWKThumbprint creates a JWK thumbprint out of pub // as specified in https://tools.ietf.org/html/rfc7638. func JWKThumbprint(pub crypto.PublicKey) (string, error) { jwk, err := jwkEncode(pub) if err != nil { return "", err } b := sha256.Sum256([]byte(jwk)) return base64.RawURLEncoding.EncodeToString(b[:]), nil }	7.28 KB	2025-05-25 12:27
📄 jws_test.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package acme import ( "crypto" "crypto/ecdsa" "crypto/elliptic" "crypto/rsa" "crypto/sha256" "crypto/x509" "encoding/base64" "encoding/json" "encoding/pem" "fmt" "io" "math/big" "testing" ) // The following shell command alias is used in the comments // throughout this file: // alias b64raw="base64 -w0 \| tr -d '=' \| tr '/+' '_-'" const ( // Modulus in raw base64: // 4xgZ3eRPkwoRvy7qeRUbmMDe0V-xH9eWLdu0iheeLlrmD2mqWXfP9IeSKApbn34 // g8TuAS9g5zhq8ELQ3kmjr-KV86GAMgI6VAcGlq3QrzpTCf_30Ab7-zawrfRaFON // a1HwEzPY1KHnGVkxJc85gNkwYI9SY2RHXtvln3zs5wITNrdosqEXeaIkVYBEhbh // Nu54pp3kxo6TuWLi9e6pXeWetEwmlBwtWZlPoib2j3TxLBksKZfoyFyek380mHg // JAumQ_I2fjj98_97mk3ihOY4AgVdCDj1z_GCoZkG5Rq7nbCGyosyKWyDX00Zs-n // NqVhoLeIvXC4nnWdJMZ6rogxyQQ testKeyPEM = ` -----BEGIN RSA PRIVATE KEY----- MIIEowIBAAKCAQEA4xgZ3eRPkwoRvy7qeRUbmMDe0V+xH9eWLdu0iheeLlrmD2mq WXfP9IeSKApbn34g8TuAS9g5zhq8ELQ3kmjr+KV86GAMgI6VAcGlq3QrzpTCf/30 Ab7+zawrfRaFONa1HwEzPY1KHnGVkxJc85gNkwYI9SY2RHXtvln3zs5wITNrdosq EXeaIkVYBEhbhNu54pp3kxo6TuWLi9e6pXeWetEwmlBwtWZlPoib2j3TxLBksKZf oyFyek380mHgJAumQ/I2fjj98/97mk3ihOY4AgVdCDj1z/GCoZkG5Rq7nbCGyosy KWyDX00Zs+nNqVhoLeIvXC4nnWdJMZ6rogxyQQIDAQABAoIBACIEZTOI1Kao9nmV 9IeIsuaR1Y61b9neOF/MLmIVIZu+AAJFCMB4Iw11FV6sFodwpEyeZhx2WkpWVN+H r19eGiLX3zsL0DOdqBJoSIHDWCCMxgnYJ6nvS0nRxX3qVrBp8R2g12Ub+gNPbmFm ecf/eeERIVxfifd9VsyRu34eDEvcmKFuLYbElFcPh62xE3x12UZvV/sN7gXbawpP G+w255vbE5MoaKdnnO83cTFlcHvhn24M/78qP7Te5OAeelr1R89kYxQLpuGe4fbS zc6E3ym5Td6urDetGGrSY1Eu10/8sMusX+KNWkm+RsBRbkyKq72ks/qKpOxOa+c6 9gm+Y8ECgYEA/iNUyg1ubRdH11p82l8KHtFC1DPE0V1gSZsX29TpM5jS4qv46K+s 8Ym1zmrORM8x+cynfPx1VQZQ34EYeCMIX212ryJ+zDATl4NE0I4muMvSiH9vx6Xc 7FmhNnaYzPsBL5Tm9nmtQuP09YEn8poiOJFiDs/4olnD5ogA5O4THGkCgYEA5MIL qWYBUuqbEWLRtMruUtpASclrBqNNsJEsMGbeqBJmoMxdHeSZckbLOrqm7GlMyNRJ Ne/5uWRGSzaMYuGmwsPpERzqEvYFnSrpjW5YtXZ+JtxFXNVfm9Z1gLLgvGpOUCIU RbpoDckDe1vgUuk3y5+DjZihs+rqIJ45XzXTzBkCgYBWuf3segruJZy5rEKhTv+o JqeUvRn0jNYYKFpLBeyTVBrbie6GkbUGNIWbrK05pC+c3K9nosvzuRUOQQL1tJbd 4gA3oiD9U4bMFNr+BRTHyZ7OQBcIXdz3t1qhuHVKtnngIAN1p25uPlbRFUNpshnt jgeVoHlsBhApcs5DUc+pyQKBgDzeHPg/+g4z+nrPznjKnktRY1W+0El93kgi+J0Q YiJacxBKEGTJ1MKBb8X6sDurcRDm22wMpGfd9I5Cv2v4GsUsF7HD/cx5xdih+G73 c4clNj/k0Ff5Nm1izPUno4C+0IOl7br39IPmfpSuR6wH/h6iHQDqIeybjxyKvT1G N0rRAoGBAKGD+4ZI/E1MoJ5CXB8cDDMHagbE3cq/DtmYzE2v1DFpQYu5I4PCm5c7 EQeIP6dZtv8IMgtGIb91QX9pXvP0aznzQKwYIA8nZgoENCPfiMTPiEDT9e/0lObO 9XWsXpbSTsRPj0sv1rB+UzBJ0PgjK4q2zOF0sNo7b1+6nlM3BWPx -----END RSA PRIVATE KEY----- ` // This thumbprint is for the testKey defined above. testKeyThumbprint = "6nicxzh6WETQlrvdchkz-U3e3DOQZ4heJKU63rfqMqQ" // openssl ecparam -name secp256k1 -genkey -noout testKeyECPEM = ` -----BEGIN EC PRIVATE KEY----- MHcCAQEEIK07hGLr0RwyUdYJ8wbIiBS55CjnkMD23DWr+ccnypWLoAoGCCqGSM49 AwEHoUQDQgAE5lhEug5xK4xBDZ2nAbaxLtaLiv85bxJ7ePd1dkO23HThqIrvawF5 QAaS/RNouybCiRhRjI3EaxLkQwgrCw0gqQ== -----END EC PRIVATE KEY----- ` // openssl ecparam -name secp384r1 -genkey -noout testKeyEC384PEM = ` -----BEGIN EC PRIVATE KEY----- MIGkAgEBBDAQ4lNtXRORWr1bgKR1CGysr9AJ9SyEk4jiVnlUWWUChmSNL+i9SLSD Oe/naPqXJ6CgBwYFK4EEACKhZANiAAQzKtj+Ms0vHoTX5dzv3/L5YMXOWuI5UKRj JigpahYCqXD2BA1j0E/2xt5vlPf+gm0PL+UHSQsCokGnIGuaHCsJAp3ry0gHQEke WYXapUUFdvaK1R2/2hn5O+eiQM8YzCg= -----END EC PRIVATE KEY----- ` // openssl ecparam -name secp521r1 -genkey -noout testKeyEC512PEM = ` -----BEGIN EC PRIVATE KEY----- MIHcAgEBBEIBSNZKFcWzXzB/aJClAb305ibalKgtDA7+70eEkdPt28/3LZMM935Z KqYHh/COcxuu3Kt8azRAUz3gyr4zZKhlKUSgBwYFK4EEACOhgYkDgYYABAHUNKbx 7JwC7H6pa2sV0tERWhHhB3JmW+OP6SUgMWryvIKajlx73eS24dy4QPGrWO9/ABsD FqcRSkNVTXnIv6+0mAF25knqIBIg5Q8M9BnOu9GGAchcwt3O7RDHmqewnJJDrbjd GGnm6rb+NnWR9DIopM0nKNkToWoF/hzopxu4Ae/GsQ== -----END EC PRIVATE KEY----- ` // 1. openssl ec -in key.pem -noout -text // 2. remove first byte, 04 (the header); the rest is X and Y // 3. convert each with: echo <val> \| xxd -r -p \| b64raw testKeyECPubX = "5lhEug5xK4xBDZ2nAbaxLtaLiv85bxJ7ePd1dkO23HQ" testKeyECPubY = "4aiK72sBeUAGkv0TaLsmwokYUYyNxGsS5EMIKwsNIKk" testKeyEC384PubX = "MyrY_jLNLx6E1-Xc79_y-WDFzlriOVCkYyYoKWoWAqlw9gQNY9BP9sbeb5T3_oJt" testKeyEC384PubY = "Dy_lB0kLAqJBpyBrmhwrCQKd68tIB0BJHlmF2qVFBXb2itUdv9oZ-TvnokDPGMwo" testKeyEC512PubX = "AdQ0pvHsnALsfqlraxXS0RFaEeEHcmZb44_pJSAxavK8gpqOXHvd5Lbh3LhA8atY738AGwMWpxFKQ1VNeci_r7SY" testKeyEC512PubY = "AXbmSeogEiDlDwz0Gc670YYByFzC3c7tEMeap7CckkOtuN0Yaebqtv42dZH0MiikzSco2ROhagX-HOinG7gB78ax" // echo -n '{"crv":"P-256","kty":"EC","x":"<testKeyECPubX>","y":"<testKeyECPubY>"}' \| \ // openssl dgst -binary -sha256 \| b64raw testKeyECThumbprint = "zedj-Bd1Zshp8KLePv2MB-lJ_Hagp7wAwdkA0NUTniU" ) var ( testKey rsa.PrivateKey testKeyEC ecdsa.PrivateKey testKeyEC384 ecdsa.PrivateKey testKeyEC512 ecdsa.PrivateKey ) func init() { testKey = parseRSA(testKeyPEM, "testKeyPEM") testKeyEC = parseEC(testKeyECPEM, "testKeyECPEM") testKeyEC384 = parseEC(testKeyEC384PEM, "testKeyEC384PEM") testKeyEC512 = parseEC(testKeyEC512PEM, "testKeyEC512PEM") } func decodePEM(s, name string) []byte { d, _ := pem.Decode([]byte(s)) if d == nil { panic("no block found in " + name) } return d.Bytes } func parseRSA(s, name string) rsa.PrivateKey { b := decodePEM(s, name) k, err := x509.ParsePKCS1PrivateKey(b) if err != nil { panic(fmt.Sprintf("%s: %v", name, err)) } return k } func parseEC(s, name string) ecdsa.PrivateKey { b := decodePEM(s, name) k, err := x509.ParseECPrivateKey(b) if err != nil { panic(fmt.Sprintf("%s: %v", name, err)) } return k } func TestJWSEncodeJSON(t testing.T) { claims := struct{ Msg string }{"Hello JWS"} // JWS signed with testKey and "nonce" as the nonce value // JSON-serialized JWS fields are split for easier testing const ( // {"alg":"RS256","jwk":{"e":"AQAB","kty":"RSA","n":"..."},"nonce":"nonce","url":"url"} protected = "eyJhbGciOiJSUzI1NiIsImp3ayI6eyJlIjoiQVFBQiIsImt0eSI6" + "IlJTQSIsIm4iOiI0eGdaM2VSUGt3b1J2eTdxZVJVYm1NRGUwVi14" + "SDllV0xkdTBpaGVlTGxybUQybXFXWGZQOUllU0tBcGJuMzRnOFR1" + "QVM5ZzV6aHE4RUxRM2ttanItS1Y4NkdBTWdJNlZBY0dscTNRcnpw" + "VENmXzMwQWI3LXphd3JmUmFGT05hMUh3RXpQWTFLSG5HVmt4SmM4" + "NWdOa3dZSTlTWTJSSFh0dmxuM3pzNXdJVE5yZG9zcUVYZWFJa1ZZ" + "QkVoYmhOdTU0cHAza3hvNlR1V0xpOWU2cFhlV2V0RXdtbEJ3dFda" + "bFBvaWIyajNUeExCa3NLWmZveUZ5ZWszODBtSGdKQXVtUV9JMmZq" + "ajk4Xzk3bWszaWhPWTRBZ1ZkQ0RqMXpfR0NvWmtHNVJxN25iQ0d5" + "b3N5S1d5RFgwMFpzLW5OcVZob0xlSXZYQzRubldkSk1aNnJvZ3h5" + "UVEifSwibm9uY2UiOiJub25jZSIsInVybCI6InVybCJ9" // {"Msg":"Hello JWS"} payload = "eyJNc2ciOiJIZWxsbyBKV1MifQ" // printf '<protected>.<payload>' \| openssl dgst -binary -sha256 -sign testKey \| b64raw signature = "YFyl_xz1E7TR-3E1bIuASTr424EgCvBHjt25WUFC2VaDjXYV0Rj_" + "Hd3dJ_2IRqBrXDZZ2n4ZeA_4mm3QFwmwyeDwe2sWElhb82lCZ8iX" + "uFnjeOmSOjx-nWwPa5ibCXzLq13zZ-OBV1Z4oN_TuailQeRoSfA3" + "nO8gG52mv1x2OMQ5MAFtt8jcngBLzts4AyhI6mBJ2w7Yaj3ZCriq" + "DWA3GLFvvHdW1Ba9Z01wtGT2CuZI7DUk_6Qj1b3BkBGcoKur5C9i" + "bUJtCkABwBMvBQNyD3MmXsrRFRTgvVlyU_yMaucYm7nmzEr_2PaQ" + "50rFt_9qOfJ4sfbLtG1Wwae57BQx1g" ) b, err := jwsEncodeJSON(claims, testKey, noKeyID, "nonce", "url") if err != nil { t.Fatal(err) } var jws struct{ Protected, Payload, Signature string } if err := json.Unmarshal(b, &jws); err != nil { t.Fatal(err) } if jws.Protected != protected { t.Errorf("protected:\n%s\nwant:\n%s", jws.Protected, protected) } if jws.Payload != payload { t.Errorf("payload:\n%s\nwant:\n%s", jws.Payload, payload) } if jws.Signature != signature { t.Errorf("signature:\n%s\nwant:\n%s", jws.Signature, signature) } } func TestJWSEncodeNoNonce(t testing.T) { kid := KeyID("https://example.org/account/1") claims := "RawString" const ( // {"alg":"ES256","kid":"https://example.org/account/1","nonce":"nonce","url":"url"} protected = "eyJhbGciOiJFUzI1NiIsImtpZCI6Imh0dHBzOi8vZXhhbXBsZS5vcmcvYWNjb3VudC8xIiwidXJsIjoidXJsIn0" // "Raw String" payload = "RawString" ) b, err := jwsEncodeJSON(claims, testKeyEC, kid, "", "url") if err != nil { t.Fatal(err) } var jws struct{ Protected, Payload, Signature string } if err := json.Unmarshal(b, &jws); err != nil { t.Fatal(err) } if jws.Protected != protected { t.Errorf("protected:\n%s\nwant:\n%s", jws.Protected, protected) } if jws.Payload != payload { t.Errorf("payload:\n%s\nwant:\n%s", jws.Payload, payload) } sig, err := base64.RawURLEncoding.DecodeString(jws.Signature) if err != nil { t.Fatalf("jws.Signature: %v", err) } r, s := big.NewInt(0), big.NewInt(0) r.SetBytes(sig[:len(sig)/2]) s.SetBytes(sig[len(sig)/2:]) h := sha256.Sum256([]byte(protected + "." + payload)) if !ecdsa.Verify(testKeyEC.Public().(ecdsa.PublicKey), h[:], r, s) { t.Error("invalid signature") } } func TestJWSEncodeKID(t testing.T) { kid := KeyID("https://example.org/account/1") claims := struct{ Msg string }{"Hello JWS"} // JWS signed with testKeyEC const ( // {"alg":"ES256","kid":"https://example.org/account/1","nonce":"nonce","url":"url"} protected = "eyJhbGciOiJFUzI1NiIsImtpZCI6Imh0dHBzOi8vZXhhbXBsZS5" + "vcmcvYWNjb3VudC8xIiwibm9uY2UiOiJub25jZSIsInVybCI6InVybCJ9" // {"Msg":"Hello JWS"} payload = "eyJNc2ciOiJIZWxsbyBKV1MifQ" ) b, err := jwsEncodeJSON(claims, testKeyEC, kid, "nonce", "url") if err != nil { t.Fatal(err) } var jws struct{ Protected, Payload, Signature string } if err := json.Unmarshal(b, &jws); err != nil { t.Fatal(err) } if jws.Protected != protected { t.Errorf("protected:\n%s\nwant:\n%s", jws.Protected, protected) } if jws.Payload != payload { t.Errorf("payload:\n%s\nwant:\n%s", jws.Payload, payload) } sig, err := base64.RawURLEncoding.DecodeString(jws.Signature) if err != nil { t.Fatalf("jws.Signature: %v", err) } r, s := big.NewInt(0), big.NewInt(0) r.SetBytes(sig[:len(sig)/2]) s.SetBytes(sig[len(sig)/2:]) h := sha256.Sum256([]byte(protected + "." + payload)) if !ecdsa.Verify(testKeyEC.Public().(ecdsa.PublicKey), h[:], r, s) { t.Error("invalid signature") } } func TestJWSEncodeJSONEC(t testing.T) { tt := []struct { key ecdsa.PrivateKey x, y string alg, crv string }{ {testKeyEC, testKeyECPubX, testKeyECPubY, "ES256", "P-256"}, {testKeyEC384, testKeyEC384PubX, testKeyEC384PubY, "ES384", "P-384"}, {testKeyEC512, testKeyEC512PubX, testKeyEC512PubY, "ES512", "P-521"}, } for i, test := range tt { claims := struct{ Msg string }{"Hello JWS"} b, err := jwsEncodeJSON(claims, test.key, noKeyID, "nonce", "url") if err != nil { t.Errorf("%d: %v", i, err) continue } var jws struct{ Protected, Payload, Signature string } if err := json.Unmarshal(b, &jws); err != nil { t.Errorf("%d: %v", i, err) continue } b, err = base64.RawURLEncoding.DecodeString(jws.Protected) if err != nil { t.Errorf("%d: jws.Protected: %v", i, err) } var head struct { Alg string Nonce string URL string `json:"url"` KID string `json:"kid"` JWK struct { Crv string Kty string X string Y string } `json:"jwk"` } if err := json.Unmarshal(b, &head); err != nil { t.Errorf("%d: jws.Protected: %v", i, err) } if head.Alg != test.alg { t.Errorf("%d: head.Alg = %q; want %q", i, head.Alg, test.alg) } if head.Nonce != "nonce" { t.Errorf("%d: head.Nonce = %q; want nonce", i, head.Nonce) } if head.URL != "url" { t.Errorf("%d: head.URL = %q; want 'url'", i, head.URL) } if head.KID != "" { // We used noKeyID in jwsEncodeJSON: expect no kid value. t.Errorf("%d: head.KID = %q; want empty", i, head.KID) } if head.JWK.Crv != test.crv { t.Errorf("%d: head.JWK.Crv = %q; want %q", i, head.JWK.Crv, test.crv) } if head.JWK.Kty != "EC" { t.Errorf("%d: head.JWK.Kty = %q; want EC", i, head.JWK.Kty) } if head.JWK.X != test.x { t.Errorf("%d: head.JWK.X = %q; want %q", i, head.JWK.X, test.x) } if head.JWK.Y != test.y { t.Errorf("%d: head.JWK.Y = %q; want %q", i, head.JWK.Y, test.y) } } } type customTestSigner struct { sig []byte pub crypto.PublicKey } func (s customTestSigner) Public() crypto.PublicKey { return s.pub } func (s customTestSigner) Sign(io.Reader, []byte, crypto.SignerOpts) ([]byte, error) { return s.sig, nil } func TestJWSEncodeJSONCustom(t testing.T) { claims := struct{ Msg string }{"hello"} const ( // printf '{"Msg":"hello"}' \| b64raw payload = "eyJNc2ciOiJoZWxsbyJ9" // printf 'testsig' \| b64raw testsig = "dGVzdHNpZw" // the example P256 curve point from https://tools.ietf.org/html/rfc7515#appendix-A.3.1 // encoded as ASN.1… es256stdsig = "MEUCIA7RIVN5Y2xIPC9/FVgH1AKjsigDOvl8fheBmsMWnqZlAiEA" + "xQoH04w8cOXY8S2vCEpUgKZlkMXyk1Cajz9/ioOjVNU" // …and RFC7518 (https://tools.ietf.org/html/rfc7518#section-3.4) es256jwsig = "DtEhU3ljbEg8L38VWAfUAqOyKAM6-Xx-F4GawxaepmXFCgfTjDxw" + "5djxLa8ISlSApmWQxfKTUJqPP3-Kg6NU1Q" // printf '{"alg":"ES256","jwk":{"crv":"P-256","kty":"EC","x":<testKeyECPubY>,"y":<testKeyECPubY>},"nonce":"nonce","url":"url"}' \| b64raw es256phead = "eyJhbGciOiJFUzI1NiIsImp3ayI6eyJjcnYiOiJQLTI1NiIsImt0" + "eSI6IkVDIiwieCI6IjVsaEV1ZzV4SzR4QkRaMm5BYmF4THRhTGl2" + "ODVieEo3ZVBkMWRrTzIzSFEiLCJ5IjoiNGFpSzcyc0JlVUFHa3Yw" + "VGFMc213b2tZVVl5TnhHc1M1RU1JS3dzTklLayJ9LCJub25jZSI6" + "Im5vbmNlIiwidXJsIjoidXJsIn0" // {"alg":"RS256","jwk":{"e":"AQAB","kty":"RSA","n":"..."},"nonce":"nonce","url":"url"} rs256phead = "eyJhbGciOiJSUzI1NiIsImp3ayI6eyJlIjoiQVFBQiIsImt0eSI6" + "IlJTQSIsIm4iOiI0eGdaM2VSUGt3b1J2eTdxZVJVYm1NRGUwVi14" + "SDllV0xkdTBpaGVlTGxybUQybXFXWGZQOUllU0tBcGJuMzRnOFR1" + "QVM5ZzV6aHE4RUxRM2ttanItS1Y4NkdBTWdJNlZBY0dscTNRcnpw" + "VENmXzMwQWI3LXphd3JmUmFGT05hMUh3RXpQWTFLSG5HVmt4SmM4" + "NWdOa3dZSTlTWTJSSFh0dmxuM3pzNXdJVE5yZG9zcUVYZWFJa1ZZ" + "QkVoYmhOdTU0cHAza3hvNlR1V0xpOWU2cFhlV2V0RXdtbEJ3dFda" + "bFBvaWIyajNUeExCa3NLWmZveUZ5ZWszODBtSGdKQXVtUV9JMmZq" + "ajk4Xzk3bWszaWhPWTRBZ1ZkQ0RqMXpfR0NvWmtHNVJxN25iQ0d5" + "b3N5S1d5RFgwMFpzLW5OcVZob0xlSXZYQzRubldkSk1aNnJvZ3h5" + "UVEifSwibm9uY2UiOiJub25jZSIsInVybCI6InVybCJ9" ) tt := []struct { alg, phead string pub crypto.PublicKey stdsig, jwsig string }{ {"ES256", es256phead, testKeyEC.Public(), es256stdsig, es256jwsig}, {"RS256", rs256phead, testKey.Public(), testsig, testsig}, } for _, tc := range tt { tc := tc t.Run(tc.alg, func(t testing.T) { stdsig, err := base64.RawStdEncoding.DecodeString(tc.stdsig) if err != nil { t.Errorf("couldn't decode test vector: %v", err) } signer := &customTestSigner{ sig: stdsig, pub: tc.pub, } b, err := jwsEncodeJSON(claims, signer, noKeyID, "nonce", "url") if err != nil { t.Fatal(err) } var j jsonWebSignature if err := json.Unmarshal(b, &j); err != nil { t.Fatal(err) } if j.Protected != tc.phead { t.Errorf("j.Protected = %q\nwant %q", j.Protected, tc.phead) } if j.Payload != payload { t.Errorf("j.Payload = %q\nwant %q", j.Payload, payload) } if j.Sig != tc.jwsig { t.Errorf("j.Sig = %q\nwant %q", j.Sig, tc.jwsig) } }) } } func TestJWSWithMAC(t testing.T) { // Example from RFC 7520 Section 4.4.3. // https://tools.ietf.org/html/rfc7520#section-4.4.3 b64Key := "hJtXIZ2uSN5kbQfbtTNWbpdmhkV8FJG-Onbc6mxCcYg" rawPayload := []byte("It\xe2\x80\x99s a dangerous business, Frodo, going out your " + "door. You step onto the road, and if you don't keep your feet, " + "there\xe2\x80\x99s no knowing where you might be swept off " + "to.") protected := "eyJhbGciOiJIUzI1NiIsImtpZCI6IjAxOGMwYWU1LTRkOWItNDcxYi1iZmQ2LW" + "VlZjMxNGJjNzAzNyJ9" payload := "SXTigJlzIGEgZGFuZ2Vyb3VzIGJ1c2luZXNzLCBGcm9kbywg" + "Z29pbmcgb3V0IHlvdXIgZG9vci4gWW91IHN0ZXAgb250byB0aGUgcm9h" + "ZCwgYW5kIGlmIHlvdSBkb24ndCBrZWVwIHlvdXIgZmVldCwgdGhlcmXi" + "gJlzIG5vIGtub3dpbmcgd2hlcmUgeW91IG1pZ2h0IGJlIHN3ZXB0IG9m" + "ZiB0by4" sig := "s0h6KThzkfBBBkLspW1h84VsJZFTsPPqMDA7g1Md7p0" key, err := base64.RawURLEncoding.DecodeString(b64Key) if err != nil { t.Fatalf("unable to decode key: %q", b64Key) } got, err := jwsWithMAC(key, "018c0ae5-4d9b-471b-bfd6-eef314bc7037", "", rawPayload) if err != nil { t.Fatalf("jwsWithMAC() = %q", err) } if got.Protected != protected { t.Errorf("got.Protected = %q\nwant %q", got.Protected, protected) } if got.Payload != payload { t.Errorf("got.Payload = %q\nwant %q", got.Payload, payload) } if got.Sig != sig { t.Errorf("got.Signature = %q\nwant %q", got.Sig, sig) } } func TestJWSWithMACError(t testing.T) { p := "{}" if _, err := jwsWithMAC(nil, "", "", []byte(p)); err == nil { t.Errorf("jwsWithMAC(nil, ...) = success; want err") } } func TestJWKThumbprintRSA(t testing.T) { // Key example from RFC 7638 const base64N = "0vx7agoebGcQSuuPiLJXZptN9nndrQmbXEps2aiAFbWhM78LhWx4cbbfAAt" + "VT86zwu1RK7aPFFxuhDR1L6tSoc_BJECPebWKRXjBZCiFV4n3oknjhMstn6" + "4tZ_2W-5JsGY4Hc5n9yBXArwl93lqt7_RN5w6Cf0h4QyQ5v-65YGjQR0_FD" + "W2QvzqY368QQMicAtaSqzs8KJZgnYb9c7d0zgdAZHzu6qMQvRL5hajrn1n9" + "1CbOpbISD08qNLyrdkt-bFTWhAI4vMQFh6WeZu0fM4lFd2NcRwr3XPksINH" + "aQ-G_xBniIqbw0Ls1jF44-csFCur-kEgU8awapJzKnqDKgw" const base64E = "AQAB" const expected = "NzbLsXh8uDCcd-6MNwXF4W_7noWXFZAfHkxZsRGC9Xs" b, err := base64.RawURLEncoding.DecodeString(base64N) if err != nil { t.Fatalf("Error parsing example key N: %v", err) } n := new(big.Int).SetBytes(b) b, err = base64.RawURLEncoding.DecodeString(base64E) if err != nil { t.Fatalf("Error parsing example key E: %v", err) } e := new(big.Int).SetBytes(b) pub := &rsa.PublicKey{N: n, E: int(e.Uint64())} th, err := JWKThumbprint(pub) if err != nil { t.Error(err) } if th != expected { t.Errorf("thumbprint = %q; want %q", th, expected) } } func TestJWKThumbprintEC(t testing.T) { // Key example from RFC 7520 // expected was computed with // printf '{"crv":"P-521","kty":"EC","x":"<base64X>","y":"<base64Y>"}' \| \ // openssl dgst -binary -sha256 \| b64raw const ( base64X = "AHKZLLOsCOzz5cY97ewNUajB957y-C-U88c3v13nmGZx6sYl_oJXu9A5RkT" + "KqjqvjyekWF-7ytDyRXYgCF5cj0Kt" base64Y = "AdymlHvOiLxXkEhayXQnNCvDX4h9htZaCJN34kfmC6pV5OhQHiraVySsUda" + "QkAgDPrwQrJmbnX9cwlGfP-HqHZR1" expected = "dHri3SADZkrush5HU_50AoRhcKFryN-PI6jPBtPL55M" ) b, err := base64.RawURLEncoding.DecodeString(base64X) if err != nil { t.Fatalf("Error parsing example key X: %v", err) } x := new(big.Int).SetBytes(b) b, err = base64.RawURLEncoding.DecodeString(base64Y) if err != nil { t.Fatalf("Error parsing example key Y: %v", err) } y := new(big.Int).SetBytes(b) pub := &ecdsa.PublicKey{Curve: elliptic.P521(), X: x, Y: y} th, err := JWKThumbprint(pub) if err != nil { t.Error(err) } if th != expected { t.Errorf("thumbprint = %q; want %q", th, expected) } } func TestJWKThumbprintErrUnsupportedKey(t testing.T) { _, err := JWKThumbprint(struct{}{}) if err != ErrUnsupportedKey { t.Errorf("err = %q; want %q", err, ErrUnsupportedKey) } }	18.55 KB	2025-05-25 12:27
📄 rfc8555.go // Copyright 2019 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package acme import ( "context" "crypto" "encoding/base64" "encoding/json" "encoding/pem" "errors" "fmt" "io" "net/http" "time" ) // DeactivateReg permanently disables an existing account associated with c.Key. // A deactivated account can no longer request certificate issuance or access // resources related to the account, such as orders or authorizations. // // It only works with CAs implementing RFC 8555. func (c Client) DeactivateReg(ctx context.Context) error { if _, err := c.Discover(ctx); err != nil { // required by c.accountKID return err } url := string(c.accountKID(ctx)) if url == "" { return ErrNoAccount } req := json.RawMessage(`{"status": "deactivated"}`) res, err := c.post(ctx, nil, url, req, wantStatus(http.StatusOK)) if err != nil { return err } res.Body.Close() return nil } // registerRFC is equivalent to c.Register but for CAs implementing RFC 8555. // It expects c.Discover to have already been called. func (c Client) registerRFC(ctx context.Context, acct Account, prompt func(tosURL string) bool) (Account, error) { c.cacheMu.Lock() // guard c.kid access defer c.cacheMu.Unlock() req := struct { TermsAgreed bool `json:"termsOfServiceAgreed,omitempty"` Contact []string `json:"contact,omitempty"` ExternalAccountBinding jsonWebSignature `json:"externalAccountBinding,omitempty"` }{ Contact: acct.Contact, } if c.dir.Terms != "" { req.TermsAgreed = prompt(c.dir.Terms) } // set 'externalAccountBinding' field if requested if acct.ExternalAccountBinding != nil { eabJWS, err := c.encodeExternalAccountBinding(acct.ExternalAccountBinding) if err != nil { return nil, fmt.Errorf("acme: failed to encode external account binding: %v", err) } req.ExternalAccountBinding = eabJWS } res, err := c.post(ctx, c.Key, c.dir.RegURL, req, wantStatus( http.StatusOK, // account with this key already registered http.StatusCreated, // new account created )) if err != nil { return nil, err } defer res.Body.Close() a, err := responseAccount(res) if err != nil { return nil, err } // Cache Account URL even if we return an error to the caller. // It is by all means a valid and usable "kid" value for future requests. c.KID = KeyID(a.URI) if res.StatusCode == http.StatusOK { return nil, ErrAccountAlreadyExists } return a, nil } // encodeExternalAccountBinding will encode an external account binding stanza // as described in https://tools.ietf.org/html/rfc8555#section-7.3.4. func (c Client) encodeExternalAccountBinding(eab ExternalAccountBinding) (jsonWebSignature, error) { jwk, err := jwkEncode(c.Key.Public()) if err != nil { return nil, err } return jwsWithMAC(eab.Key, eab.KID, c.dir.RegURL, []byte(jwk)) } // updateRegRFC is equivalent to c.UpdateReg but for CAs implementing RFC 8555. // It expects c.Discover to have already been called. func (c Client) updateRegRFC(ctx context.Context, a Account) (Account, error) { url := string(c.accountKID(ctx)) if url == "" { return nil, ErrNoAccount } req := struct { Contact []string `json:"contact,omitempty"` }{ Contact: a.Contact, } res, err := c.post(ctx, nil, url, req, wantStatus(http.StatusOK)) if err != nil { return nil, err } defer res.Body.Close() return responseAccount(res) } // getRegRFC is equivalent to c.GetReg but for CAs implementing RFC 8555. // It expects c.Discover to have already been called. func (c Client) getRegRFC(ctx context.Context) (Account, error) { req := json.RawMessage(`{"onlyReturnExisting": true}`) res, err := c.post(ctx, c.Key, c.dir.RegURL, req, wantStatus(http.StatusOK)) if e, ok := err.(Error); ok && e.ProblemType == "urn:ietf:params:acme:error:accountDoesNotExist" { return nil, ErrNoAccount } if err != nil { return nil, err } defer res.Body.Close() return responseAccount(res) } func responseAccount(res http.Response) (Account, error) { var v struct { Status string Contact []string Orders string } if err := json.NewDecoder(res.Body).Decode(&v); err != nil { return nil, fmt.Errorf("acme: invalid account response: %v", err) } return &Account{ URI: res.Header.Get("Location"), Status: v.Status, Contact: v.Contact, OrdersURL: v.Orders, }, nil } // accountKeyRollover attempts to perform account key rollover. // On success it will change client.Key to the new key. func (c Client) accountKeyRollover(ctx context.Context, newKey crypto.Signer) error { dir, err := c.Discover(ctx) // Also required by c.accountKID if err != nil { return err } kid := c.accountKID(ctx) if kid == noKeyID { return ErrNoAccount } oldKey, err := jwkEncode(c.Key.Public()) if err != nil { return err } payload := struct { Account string `json:"account"` OldKey json.RawMessage `json:"oldKey"` }{ Account: string(kid), OldKey: json.RawMessage(oldKey), } inner, err := jwsEncodeJSON(payload, newKey, noKeyID, noNonce, dir.KeyChangeURL) if err != nil { return err } res, err := c.post(ctx, nil, dir.KeyChangeURL, base64.RawURLEncoding.EncodeToString(inner), wantStatus(http.StatusOK)) if err != nil { return err } defer res.Body.Close() c.Key = newKey return nil } // AuthorizeOrder initiates the order-based application for certificate issuance, // as opposed to pre-authorization in Authorize. // It is only supported by CAs implementing RFC 8555. // // The caller then needs to fetch each authorization with GetAuthorization, // identify those with StatusPending status and fulfill a challenge using Accept. // Once all authorizations are satisfied, the caller will typically want to poll // order status using WaitOrder until it's in StatusReady state. // To finalize the order and obtain a certificate, the caller submits a CSR with CreateOrderCert. func (c Client) AuthorizeOrder(ctx context.Context, id []AuthzID, opt ...OrderOption) (Order, error) { dir, err := c.Discover(ctx) if err != nil { return nil, err } req := struct { Identifiers []wireAuthzID `json:"identifiers"` NotBefore string `json:"notBefore,omitempty"` NotAfter string `json:"notAfter,omitempty"` }{} for _, v := range id { req.Identifiers = append(req.Identifiers, wireAuthzID{ Type: v.Type, Value: v.Value, }) } for _, o := range opt { switch o := o.(type) { case orderNotBeforeOpt: req.NotBefore = time.Time(o).Format(time.RFC3339) case orderNotAfterOpt: req.NotAfter = time.Time(o).Format(time.RFC3339) default: // Package's fault if we let this happen. panic(fmt.Sprintf("unsupported order option type %T", o)) } } res, err := c.post(ctx, nil, dir.OrderURL, req, wantStatus(http.StatusCreated)) if err != nil { return nil, err } defer res.Body.Close() return responseOrder(res) } // GetOrder retrives an order identified by the given URL. // For orders created with AuthorizeOrder, the url value is Order.URI. // // If a caller needs to poll an order until its status is final, // see the WaitOrder method. func (c Client) GetOrder(ctx context.Context, url string) (Order, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } res, err := c.postAsGet(ctx, url, wantStatus(http.StatusOK)) if err != nil { return nil, err } defer res.Body.Close() return responseOrder(res) } // WaitOrder polls an order from the given URL until it is in one of the final states, // StatusReady, StatusValid or StatusInvalid, the CA responded with a non-retryable error // or the context is done. // // It returns a non-nil Order only if its Status is StatusReady or StatusValid. // In all other cases WaitOrder returns an error. // If the Status is StatusInvalid, the returned error is of type OrderError. func (c Client) WaitOrder(ctx context.Context, url string) (Order, error) { if _, err := c.Discover(ctx); err != nil { return nil, err } for { res, err := c.postAsGet(ctx, url, wantStatus(http.StatusOK)) if err != nil { return nil, err } o, err := responseOrder(res) res.Body.Close() switch { case err != nil: // Skip and retry. case o.Status == StatusInvalid: return nil, &OrderError{OrderURL: o.URI, Status: o.Status} case o.Status == StatusReady \|\| o.Status == StatusValid: return o, nil } d := retryAfter(res.Header.Get("Retry-After")) if d == 0 { // Default retry-after. // Same reasoning as in WaitAuthorization. d = time.Second } t := time.NewTimer(d) select { case <-ctx.Done(): t.Stop() return nil, ctx.Err() case <-t.C: // Retry. } } } func responseOrder(res http.Response) (Order, error) { var v struct { Status string Expires time.Time Identifiers []wireAuthzID NotBefore time.Time NotAfter time.Time Error wireError Authorizations []string Finalize string Certificate string } if err := json.NewDecoder(res.Body).Decode(&v); err != nil { return nil, fmt.Errorf("acme: error reading order: %v", err) } o := &Order{ URI: res.Header.Get("Location"), Status: v.Status, Expires: v.Expires, NotBefore: v.NotBefore, NotAfter: v.NotAfter, AuthzURLs: v.Authorizations, FinalizeURL: v.Finalize, CertURL: v.Certificate, } for _, id := range v.Identifiers { o.Identifiers = append(o.Identifiers, AuthzID{Type: id.Type, Value: id.Value}) } if v.Error != nil { o.Error = v.Error.error(nil / headers /) } return o, nil } // CreateOrderCert submits the CSR (Certificate Signing Request) to a CA at the specified URL. // The URL is the FinalizeURL field of an Order created with AuthorizeOrder. // // If the bundle argument is true, the returned value also contain the CA (issuer) // certificate chain. Otherwise, only a leaf certificate is returned. // The returned URL can be used to re-fetch the certificate using FetchCert. // // This method is only supported by CAs implementing RFC 8555. See CreateCert for pre-RFC CAs. // // CreateOrderCert returns an error if the CA's response is unreasonably large. // Callers are encouraged to parse the returned value to ensure the certificate is valid and has the expected features. func (c Client) CreateOrderCert(ctx context.Context, url string, csr []byte, bundle bool) (der [][]byte, certURL string, err error) { if _, err := c.Discover(ctx); err != nil { // required by c.accountKID return nil, "", err } // RFC describes this as "finalize order" request. req := struct { CSR string `json:"csr"` }{ CSR: base64.RawURLEncoding.EncodeToString(csr), } res, err := c.post(ctx, nil, url, req, wantStatus(http.StatusOK)) if err != nil { return nil, "", err } defer res.Body.Close() o, err := responseOrder(res) if err != nil { return nil, "", err } // Wait for CA to issue the cert if they haven't. if o.Status != StatusValid { o, err = c.WaitOrder(ctx, o.URI) } if err != nil { return nil, "", err } // The only acceptable status post finalize and WaitOrder is "valid". if o.Status != StatusValid { return nil, "", &OrderError{OrderURL: o.URI, Status: o.Status} } crt, err := c.fetchCertRFC(ctx, o.CertURL, bundle) return crt, o.CertURL, err } // fetchCertRFC downloads issued certificate from the given URL. // It expects the CA to respond with PEM-encoded certificate chain. // // The URL argument is the CertURL field of Order. func (c Client) fetchCertRFC(ctx context.Context, url string, bundle bool) ([][]byte, error) { res, err := c.postAsGet(ctx, url, wantStatus(http.StatusOK)) if err != nil { return nil, err } defer res.Body.Close() // Get all the bytes up to a sane maximum. // Account very roughly for base64 overhead. const max = maxCertChainSize + maxCertChainSize/33 b, err := io.ReadAll(io.LimitReader(res.Body, max+1)) if err != nil { return nil, fmt.Errorf("acme: fetch cert response stream: %v", err) } if len(b) > max { return nil, errors.New("acme: certificate chain is too big") } // Decode PEM chain. var chain [][]byte for { var p pem.Block p, b = pem.Decode(b) if p == nil { break } if p.Type != "CERTIFICATE" { return nil, fmt.Errorf("acme: invalid PEM cert type %q", p.Type) } chain = append(chain, p.Bytes) if !bundle { return chain, nil } if len(chain) > maxChainLen { return nil, errors.New("acme: certificate chain is too long") } } if len(chain) == 0 { return nil, errors.New("acme: certificate chain is empty") } return chain, nil } // sends a cert revocation request in either JWK form when key is non-nil or KID form otherwise. func (c Client) revokeCertRFC(ctx context.Context, key crypto.Signer, cert []byte, reason CRLReasonCode) error { req := &struct { Cert string `json:"certificate"` Reason int `json:"reason"` }{ Cert: base64.RawURLEncoding.EncodeToString(cert), Reason: int(reason), } res, err := c.post(ctx, key, c.dir.RevokeURL, req, wantStatus(http.StatusOK)) if err != nil { if isAlreadyRevoked(err) { // Assume it is not an error to revoke an already revoked cert. return nil } return err } defer res.Body.Close() return nil } func isAlreadyRevoked(err error) bool { e, ok := err.(Error) return ok && e.ProblemType == "urn:ietf:params:acme:error:alreadyRevoked" } // ListCertAlternates retrieves any alternate certificate chain URLs for the // given certificate chain URL. These alternate URLs can be passed to FetchCert // in order to retrieve the alternate certificate chains. // // If there are no alternate issuer certificate chains, a nil slice will be // returned. func (c *Client) ListCertAlternates(ctx context.Context, url string) ([]string, error) { if _, err := c.Discover(ctx); err != nil { // required by c.accountKID return nil, err } res, err := c.postAsGet(ctx, url, wantStatus(http.StatusOK)) if err != nil { return nil, err } defer res.Body.Close() // We don't need the body but we need to discard it so we don't end up // preventing keep-alive if _, err := io.Copy(io.Discard, res.Body); err != nil { return nil, fmt.Errorf("acme: cert alternates response stream: %v", err) } alts := linkHeader(res.Header, "alternate") return alts, nil }	14.02 KB	2025-05-25 12:27
📄 rfc8555_test.go // Copyright 2019 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package acme import ( "bytes" "context" "crypto/hmac" "crypto/rand" "crypto/sha256" "crypto/x509" "crypto/x509/pkix" "encoding/base64" "encoding/json" "encoding/pem" "errors" "fmt" "io" "math/big" "net/http" "net/http/httptest" "reflect" "strings" "sync" "testing" "time" ) // While contents of this file is pertinent only to RFC8555, // it is complementary to the tests in the other _test.go files // many of which are valid for both pre- and RFC8555. // This will make it easier to clean up the tests once non-RFC compliant // code is removed. func TestRFC_Discover(t testing.T) { const ( nonce = "https://example.com/acme/new-nonce" reg = "https://example.com/acme/new-acct" order = "https://example.com/acme/new-order" authz = "https://example.com/acme/new-authz" revoke = "https://example.com/acme/revoke-cert" keychange = "https://example.com/acme/key-change" metaTerms = "https://example.com/acme/terms/2017-5-30" metaWebsite = "https://www.example.com/" metaCAA = "example.com" ) ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { w.Header().Set("Content-Type", "application/json") fmt.Fprintf(w, `{ "newNonce": %q, "newAccount": %q, "newOrder": %q, "newAuthz": %q, "revokeCert": %q, "keyChange": %q, "meta": { "termsOfService": %q, "website": %q, "caaIdentities": [%q], "externalAccountRequired": true } }`, nonce, reg, order, authz, revoke, keychange, metaTerms, metaWebsite, metaCAA) })) defer ts.Close() c := &Client{DirectoryURL: ts.URL} dir, err := c.Discover(context.Background()) if err != nil { t.Fatal(err) } if dir.NonceURL != nonce { t.Errorf("dir.NonceURL = %q; want %q", dir.NonceURL, nonce) } if dir.RegURL != reg { t.Errorf("dir.RegURL = %q; want %q", dir.RegURL, reg) } if dir.OrderURL != order { t.Errorf("dir.OrderURL = %q; want %q", dir.OrderURL, order) } if dir.AuthzURL != authz { t.Errorf("dir.AuthzURL = %q; want %q", dir.AuthzURL, authz) } if dir.RevokeURL != revoke { t.Errorf("dir.RevokeURL = %q; want %q", dir.RevokeURL, revoke) } if dir.KeyChangeURL != keychange { t.Errorf("dir.KeyChangeURL = %q; want %q", dir.KeyChangeURL, keychange) } if dir.Terms != metaTerms { t.Errorf("dir.Terms = %q; want %q", dir.Terms, metaTerms) } if dir.Website != metaWebsite { t.Errorf("dir.Website = %q; want %q", dir.Website, metaWebsite) } if len(dir.CAA) == 0 \|\| dir.CAA[0] != metaCAA { t.Errorf("dir.CAA = %q; want [%q]", dir.CAA, metaCAA) } if !dir.ExternalAccountRequired { t.Error("dir.Meta.ExternalAccountRequired is false") } } func TestRFC_popNonce(t testing.T) { var count int ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { // The Client uses only Directory.NonceURL when specified. // Expect no other URL paths. if r.URL.Path != "/new-nonce" { t.Errorf("r.URL.Path = %q; want /new-nonce", r.URL.Path) } if count > 0 { w.WriteHeader(http.StatusTooManyRequests) return } count++ w.Header().Set("Replay-Nonce", "second") })) cl := &Client{ DirectoryURL: ts.URL, dir: &Directory{NonceURL: ts.URL + "/new-nonce"}, } cl.addNonce(http.Header{"Replay-Nonce": {"first"}}) for i, nonce := range []string{"first", "second"} { v, err := cl.popNonce(context.Background(), "") if err != nil { t.Errorf("%d: cl.popNonce: %v", i, err) } if v != nonce { t.Errorf("%d: cl.popNonce = %q; want %q", i, v, nonce) } } // No more nonces and server replies with an error past first nonce fetch. // Expected to fail. if _, err := cl.popNonce(context.Background(), ""); err == nil { t.Error("last cl.popNonce returned nil error") } } func TestRFC_postKID(t testing.T) { var ts httptest.Server ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { switch r.URL.Path { case "/new-nonce": w.Header().Set("Replay-Nonce", "nonce") case "/new-account": w.Header().Set("Location", "/account-1") w.Write([]byte(`{"status":"valid"}`)) case "/post": b, _ := io.ReadAll(r.Body) // check err later in decodeJWSxxx head, err := decodeJWSHead(bytes.NewReader(b)) if err != nil { t.Errorf("decodeJWSHead: %v", err) return } if head.KID != "/account-1" { t.Errorf("head.KID = %q; want /account-1", head.KID) } if len(head.JWK) != 0 { t.Errorf("head.JWK = %q; want zero map", head.JWK) } if v := ts.URL + "/post"; head.URL != v { t.Errorf("head.URL = %q; want %q", head.URL, v) } var payload struct{ Msg string } decodeJWSRequest(t, &payload, bytes.NewReader(b)) if payload.Msg != "ping" { t.Errorf("payload.Msg = %q; want ping", payload.Msg) } w.Write([]byte("pong")) default: t.Errorf("unhandled %s %s", r.Method, r.URL) w.WriteHeader(http.StatusBadRequest) } })) defer ts.Close() ctx := context.Background() cl := &Client{ Key: testKey, DirectoryURL: ts.URL, dir: &Directory{ NonceURL: ts.URL + "/new-nonce", RegURL: ts.URL + "/new-account", OrderURL: "/force-rfc-mode", }, } req := json.RawMessage(`{"msg":"ping"}`) res, err := cl.post(ctx, nil / use kid /, ts.URL+"/post", req, wantStatus(http.StatusOK)) if err != nil { t.Fatal(err) } defer res.Body.Close() b, _ := io.ReadAll(res.Body) // don't care about err - just checking b if string(b) != "pong" { t.Errorf("res.Body = %q; want pong", b) } } // acmeServer simulates a subset of RFC 8555 compliant CA. // // TODO: We also have x/crypto/acme/autocert/acmetest and startACMEServerStub in autocert_test.go. // It feels like this acmeServer is a sweet spot between usefulness and added complexity. // Also, acmetest and startACMEServerStub were both written for draft-02, no RFC support. // The goal is to consolidate all into one ACME test server. type acmeServer struct { ts httptest.Server handler map[string]http.HandlerFunc // keyed by r.URL.Path mu sync.Mutex nnonce int } func newACMEServer() acmeServer { return &acmeServer{handler: make(map[string]http.HandlerFunc)} } func (s acmeServer) handle(path string, f func(http.ResponseWriter, http.Request)) { s.handler[path] = http.HandlerFunc(f) } func (s acmeServer) start() { s.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { w.Header().Set("Content-Type", "application/json") // Directory request. if r.URL.Path == "/" { fmt.Fprintf(w, `{ "newNonce": %q, "newAccount": %q, "newOrder": %q, "newAuthz": %q, "revokeCert": %q, "keyChange": %q, "meta": {"termsOfService": %q} }`, s.url("/acme/new-nonce"), s.url("/acme/new-account"), s.url("/acme/new-order"), s.url("/acme/new-authz"), s.url("/acme/revoke-cert"), s.url("/acme/key-change"), s.url("/terms"), ) return } // All other responses contain a nonce value unconditionally. w.Header().Set("Replay-Nonce", s.nonce()) if r.URL.Path == "/acme/new-nonce" { return } h := s.handler[r.URL.Path] if h == nil { w.WriteHeader(http.StatusBadRequest) fmt.Fprintf(w, "Unhandled %s", r.URL.Path) return } h.ServeHTTP(w, r) })) } func (s acmeServer) close() { s.ts.Close() } func (s acmeServer) url(path string) string { return s.ts.URL + path } func (s acmeServer) nonce() string { s.mu.Lock() defer s.mu.Unlock() s.nnonce++ return fmt.Sprintf("nonce%d", s.nnonce) } func (s acmeServer) error(w http.ResponseWriter, e wireError) { w.WriteHeader(e.Status) json.NewEncoder(w).Encode(e) } func TestRFC_Register(t testing.T) { const email = "mailto:user@example.org" s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusCreated) // 201 means new account created fmt.Fprintf(w, `{ "status": "valid", "contact": [%q], "orders": %q }`, email, s.url("/accounts/1/orders")) b, _ := io.ReadAll(r.Body) // check err later in decodeJWSxxx head, err := decodeJWSHead(bytes.NewReader(b)) if err != nil { t.Errorf("decodeJWSHead: %v", err) return } if len(head.JWK) == 0 { t.Error("head.JWK is empty") } var req struct{ Contact []string } decodeJWSRequest(t, &req, bytes.NewReader(b)) if len(req.Contact) != 1 \|\| req.Contact[0] != email { t.Errorf("req.Contact = %q; want [%q]", req.Contact, email) } }) s.start() defer s.close() ctx := context.Background() cl := &Client{ Key: testKeyEC, DirectoryURL: s.url("/"), } var didPrompt bool a := &Account{Contact: []string{email}} acct, err := cl.Register(ctx, a, func(tos string) bool { didPrompt = true terms := s.url("/terms") if tos != terms { t.Errorf("tos = %q; want %q", tos, terms) } return true }) if err != nil { t.Fatal(err) } okAccount := &Account{ URI: s.url("/accounts/1"), Status: StatusValid, Contact: []string{email}, OrdersURL: s.url("/accounts/1/orders"), } if !reflect.DeepEqual(acct, okAccount) { t.Errorf("acct = %+v; want %+v", acct, okAccount) } if !didPrompt { t.Error("tos prompt wasn't called") } if v := cl.accountKID(ctx); v != KeyID(okAccount.URI) { t.Errorf("account kid = %q; want %q", v, okAccount.URI) } } func TestRFC_RegisterExternalAccountBinding(t testing.T) { eab := &ExternalAccountBinding{ KID: "kid-1", Key: []byte("secret"), } type protected struct { Algorithm string `json:"alg"` KID string `json:"kid"` URL string `json:"url"` } const email = "mailto:user@example.org" s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) if r.Method != "POST" { t.Errorf("r.Method = %q; want POST", r.Method) } var j struct { Protected string Contact []string TermsOfServiceAgreed bool ExternalaccountBinding struct { Protected string Payload string Signature string } } decodeJWSRequest(t, &j, r.Body) protData, err := base64.RawURLEncoding.DecodeString(j.ExternalaccountBinding.Protected) if err != nil { t.Fatal(err) } var prot protected err = json.Unmarshal(protData, &prot) if err != nil { t.Fatal(err) } if !reflect.DeepEqual(j.Contact, []string{email}) { t.Errorf("j.Contact = %v; want %v", j.Contact, []string{email}) } if !j.TermsOfServiceAgreed { t.Error("j.TermsOfServiceAgreed = false; want true") } // Ensure same KID. if prot.KID != eab.KID { t.Errorf("j.ExternalAccountBinding.KID = %s; want %s", prot.KID, eab.KID) } // Ensure expected Algorithm. if prot.Algorithm != "HS256" { t.Errorf("j.ExternalAccountBinding.Alg = %s; want %s", prot.Algorithm, "HS256") } // Ensure same URL as outer JWS. url := fmt.Sprintf("http://%s/acme/new-account", r.Host) if prot.URL != url { t.Errorf("j.ExternalAccountBinding.URL = %s; want %s", prot.URL, url) } // Ensure payload is base64URL encoded string of JWK in outer JWS jwk, err := jwkEncode(testKeyEC.Public()) if err != nil { t.Fatal(err) } decodedPayload, err := base64.RawURLEncoding.DecodeString(j.ExternalaccountBinding.Payload) if err != nil { t.Fatal(err) } if jwk != string(decodedPayload) { t.Errorf("j.ExternalAccountBinding.Payload = %s; want %s", decodedPayload, jwk) } // Check signature on inner external account binding JWS hmac := hmac.New(sha256.New, []byte("secret")) _, err = hmac.Write([]byte(j.ExternalaccountBinding.Protected + "." + j.ExternalaccountBinding.Payload)) if err != nil { t.Fatal(err) } mac := hmac.Sum(nil) encodedMAC := base64.RawURLEncoding.EncodeToString(mac) if !bytes.Equal([]byte(encodedMAC), []byte(j.ExternalaccountBinding.Signature)) { t.Errorf("j.ExternalAccountBinding.Signature = %v; want %v", []byte(j.ExternalaccountBinding.Signature), encodedMAC) } w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusCreated) b, _ := json.Marshal([]string{email}) fmt.Fprintf(w, `{"status":"valid","orders":"%s","contact":%s}`, s.url("/accounts/1/orders"), b) }) s.start() defer s.close() ctx := context.Background() cl := &Client{ Key: testKeyEC, DirectoryURL: s.url("/"), } var didPrompt bool a := &Account{Contact: []string{email}, ExternalAccountBinding: eab} acct, err := cl.Register(ctx, a, func(tos string) bool { didPrompt = true terms := s.url("/terms") if tos != terms { t.Errorf("tos = %q; want %q", tos, terms) } return true }) if err != nil { t.Fatal(err) } okAccount := &Account{ URI: s.url("/accounts/1"), Status: StatusValid, Contact: []string{email}, OrdersURL: s.url("/accounts/1/orders"), } if !reflect.DeepEqual(acct, okAccount) { t.Errorf("acct = %+v; want %+v", acct, okAccount) } if !didPrompt { t.Error("tos prompt wasn't called") } if v := cl.accountKID(ctx); v != KeyID(okAccount.URI) { t.Errorf("account kid = %q; want %q", v, okAccount.URI) } } func TestRFC_RegisterExisting(t testing.T) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) // 200 means account already exists w.Write([]byte(`{"status": "valid"}`)) }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} _, err := cl.Register(context.Background(), &Account{}, AcceptTOS) if err != ErrAccountAlreadyExists { t.Errorf("err = %v; want %v", err, ErrAccountAlreadyExists) } kid := KeyID(s.url("/accounts/1")) if v := cl.accountKID(context.Background()); v != kid { t.Errorf("account kid = %q; want %q", v, kid) } } func TestRFC_UpdateReg(t testing.T) { const email = "mailto:user@example.org" s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) w.Write([]byte(`{"status": "valid"}`)) }) var didUpdate bool s.handle("/accounts/1", func(w http.ResponseWriter, r http.Request) { didUpdate = true w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) w.Write([]byte(`{"status": "valid"}`)) b, _ := io.ReadAll(r.Body) // check err later in decodeJWSxxx head, err := decodeJWSHead(bytes.NewReader(b)) if err != nil { t.Errorf("decodeJWSHead: %v", err) return } if len(head.JWK) != 0 { t.Error("head.JWK is non-zero") } kid := s.url("/accounts/1") if head.KID != kid { t.Errorf("head.KID = %q; want %q", head.KID, kid) } var req struct{ Contact []string } decodeJWSRequest(t, &req, bytes.NewReader(b)) if len(req.Contact) != 1 \|\| req.Contact[0] != email { t.Errorf("req.Contact = %q; want [%q]", req.Contact, email) } }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} _, err := cl.UpdateReg(context.Background(), &Account{Contact: []string{email}}) if err != nil { t.Error(err) } if !didUpdate { t.Error("UpdateReg didn't update the account") } } func TestRFC_GetReg(t testing.T) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) w.Write([]byte(`{"status": "valid"}`)) head, err := decodeJWSHead(r.Body) if err != nil { t.Errorf("decodeJWSHead: %v", err) return } if len(head.JWK) == 0 { t.Error("head.JWK is empty") } }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} acct, err := cl.GetReg(context.Background(), "") if err != nil { t.Fatal(err) } okAccount := &Account{ URI: s.url("/accounts/1"), Status: StatusValid, } if !reflect.DeepEqual(acct, okAccount) { t.Errorf("acct = %+v; want %+v", acct, okAccount) } } func TestRFC_GetRegNoAccount(t testing.T) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { s.error(w, &wireError{ Status: http.StatusBadRequest, Type: "urn:ietf:params:acme:error:accountDoesNotExist", }) }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} if _, err := cl.GetReg(context.Background(), ""); err != ErrNoAccount { t.Errorf("err = %v; want %v", err, ErrNoAccount) } } func TestRFC_GetRegOtherError(t testing.T) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.WriteHeader(http.StatusBadRequest) }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} if _, err := cl.GetReg(context.Background(), ""); err == nil \|\| err == ErrNoAccount { t.Errorf("GetReg: %v; want any other non-nil err", err) } } func TestRFC_AccountKeyRollover(t testing.T) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) w.Write([]byte(`{"status": "valid"}`)) }) s.handle("/acme/key-change", func(w http.ResponseWriter, r http.Request) { w.WriteHeader(http.StatusOK) }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} if err := cl.AccountKeyRollover(context.Background(), testKeyEC384); err != nil { t.Errorf("AccountKeyRollover: %v, wanted no error", err) } else if cl.Key != testKeyEC384 { t.Error("AccountKeyRollover did not rotate the client key") } } func TestRFC_DeactivateReg(t testing.T) { const email = "mailto:user@example.org" curStatus := StatusValid type account struct { Status string `json:"status"` Contact []string `json:"contact"` AcceptTOS bool `json:"termsOfServiceAgreed"` Orders string `json:"orders"` } s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) // 200 means existing account json.NewEncoder(w).Encode(account{ Status: curStatus, Contact: []string{email}, AcceptTOS: true, Orders: s.url("/accounts/1/orders"), }) b, _ := io.ReadAll(r.Body) // check err later in decodeJWSxxx head, err := decodeJWSHead(bytes.NewReader(b)) if err != nil { t.Errorf("decodeJWSHead: %v", err) return } if len(head.JWK) == 0 { t.Error("head.JWK is empty") } var req struct { Status string `json:"status"` Contact []string `json:"contact"` AcceptTOS bool `json:"termsOfServiceAgreed"` OnlyExisting bool `json:"onlyReturnExisting"` } decodeJWSRequest(t, &req, bytes.NewReader(b)) if !req.OnlyExisting { t.Errorf("req.OnlyReturnExisting = %t; want = %t", req.OnlyExisting, true) } }) s.handle("/accounts/1", func(w http.ResponseWriter, r http.Request) { if curStatus == StatusValid { curStatus = StatusDeactivated w.WriteHeader(http.StatusOK) } else { s.error(w, &wireError{ Status: http.StatusUnauthorized, Type: "urn:ietf:params:acme:error:unauthorized", }) } var req account b, _ := io.ReadAll(r.Body) // check err later in decodeJWSxxx head, err := decodeJWSHead(bytes.NewReader(b)) if err != nil { t.Errorf("decodeJWSHead: %v", err) return } if len(head.JWK) != 0 { t.Error("head.JWK is not empty") } if !strings.HasSuffix(head.KID, "/accounts/1") { t.Errorf("head.KID = %q; want suffix /accounts/1", head.KID) } decodeJWSRequest(t, &req, bytes.NewReader(b)) if req.Status != StatusDeactivated { t.Errorf("req.Status = %q; want = %q", req.Status, StatusDeactivated) } }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} if err := cl.DeactivateReg(context.Background()); err != nil { t.Errorf("DeactivateReg: %v, wanted no error", err) } if err := cl.DeactivateReg(context.Background()); err == nil { t.Errorf("DeactivateReg: %v, wanted error for unauthorized", err) } } func TestRF_DeactivateRegNoAccount(t testing.T) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { s.error(w, &wireError{ Status: http.StatusBadRequest, Type: "urn:ietf:params:acme:error:accountDoesNotExist", }) }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} if err := cl.DeactivateReg(context.Background()); !errors.Is(err, ErrNoAccount) { t.Errorf("DeactivateReg: %v, wanted ErrNoAccount", err) } } func TestRFC_AuthorizeOrder(t testing.T) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) w.Write([]byte(`{"status": "valid"}`)) }) s.handle("/acme/new-order", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/orders/1")) w.WriteHeader(http.StatusCreated) fmt.Fprintf(w, `{ "status": "pending", "expires": "2019-09-01T00:00:00Z", "notBefore": "2019-08-31T00:00:00Z", "notAfter": "2019-09-02T00:00:00Z", "identifiers": [{"type":"dns", "value":"example.org"}], "authorizations": [%q] }`, s.url("/authz/1")) }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} o, err := cl.AuthorizeOrder(context.Background(), DomainIDs("example.org"), WithOrderNotBefore(time.Date(2019, 8, 31, 0, 0, 0, 0, time.UTC)), WithOrderNotAfter(time.Date(2019, 9, 2, 0, 0, 0, 0, time.UTC)), ) if err != nil { t.Fatal(err) } okOrder := &Order{ URI: s.url("/orders/1"), Status: StatusPending, Expires: time.Date(2019, 9, 1, 0, 0, 0, 0, time.UTC), NotBefore: time.Date(2019, 8, 31, 0, 0, 0, 0, time.UTC), NotAfter: time.Date(2019, 9, 2, 0, 0, 0, 0, time.UTC), Identifiers: []AuthzID{AuthzID{Type: "dns", Value: "example.org"}}, AuthzURLs: []string{s.url("/authz/1")}, } if !reflect.DeepEqual(o, okOrder) { t.Errorf("AuthorizeOrder = %+v; want %+v", o, okOrder) } } func TestRFC_GetOrder(t testing.T) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) w.Write([]byte(`{"status": "valid"}`)) }) s.handle("/orders/1", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/orders/1")) w.WriteHeader(http.StatusOK) w.Write([]byte(`{ "status": "invalid", "expires": "2019-09-01T00:00:00Z", "notBefore": "2019-08-31T00:00:00Z", "notAfter": "2019-09-02T00:00:00Z", "identifiers": [{"type":"dns", "value":"example.org"}], "authorizations": ["/authz/1"], "finalize": "/orders/1/fin", "certificate": "/orders/1/cert", "error": {"type": "badRequest"} }`)) }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} o, err := cl.GetOrder(context.Background(), s.url("/orders/1")) if err != nil { t.Fatal(err) } okOrder := &Order{ URI: s.url("/orders/1"), Status: StatusInvalid, Expires: time.Date(2019, 9, 1, 0, 0, 0, 0, time.UTC), NotBefore: time.Date(2019, 8, 31, 0, 0, 0, 0, time.UTC), NotAfter: time.Date(2019, 9, 2, 0, 0, 0, 0, time.UTC), Identifiers: []AuthzID{AuthzID{Type: "dns", Value: "example.org"}}, AuthzURLs: []string{"/authz/1"}, FinalizeURL: "/orders/1/fin", CertURL: "/orders/1/cert", Error: &Error{ProblemType: "badRequest"}, } if !reflect.DeepEqual(o, okOrder) { t.Errorf("GetOrder = %+v\nwant %+v", o, okOrder) } } func TestRFC_WaitOrder(t testing.T) { for _, st := range []string{StatusReady, StatusValid} { t.Run(st, func(t testing.T) { testWaitOrderStatus(t, st) }) } } func testWaitOrderStatus(t testing.T, okStatus string) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) w.Write([]byte(`{"status": "valid"}`)) }) var count int s.handle("/orders/1", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/orders/1")) w.WriteHeader(http.StatusOK) s := StatusPending if count > 0 { s = okStatus } fmt.Fprintf(w, `{"status": %q}`, s) count++ }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} order, err := cl.WaitOrder(context.Background(), s.url("/orders/1")) if err != nil { t.Fatalf("WaitOrder: %v", err) } if order.Status != okStatus { t.Errorf("order.Status = %q; want %q", order.Status, okStatus) } } func TestRFC_WaitOrderError(t testing.T) { s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.WriteHeader(http.StatusOK) w.Write([]byte(`{"status": "valid"}`)) }) var count int s.handle("/orders/1", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/orders/1")) w.WriteHeader(http.StatusOK) s := StatusPending if count > 0 { s = StatusInvalid } fmt.Fprintf(w, `{"status": %q}`, s) count++ }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} _, err := cl.WaitOrder(context.Background(), s.url("/orders/1")) if err == nil { t.Fatal("WaitOrder returned nil error") } e, ok := err.(OrderError) if !ok { t.Fatalf("err = %v (%T); want OrderError", err, err) } if e.OrderURL != s.url("/orders/1") { t.Errorf("e.OrderURL = %q; want %q", e.OrderURL, s.url("/orders/1")) } if e.Status != StatusInvalid { t.Errorf("e.Status = %q; want %q", e.Status, StatusInvalid) } } func TestRFC_CreateOrderCert(t testing.T) { q := &x509.CertificateRequest{ Subject: pkix.Name{CommonName: "example.org"}, } csr, err := x509.CreateCertificateRequest(rand.Reader, q, testKeyEC) if err != nil { t.Fatal(err) } tmpl := &x509.Certificate{SerialNumber: big.NewInt(1)} leaf, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &testKeyEC.PublicKey, testKeyEC) if err != nil { t.Fatal(err) } s := newACMEServer() s.handle("/acme/new-account", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/accounts/1")) w.Write([]byte(`{"status": "valid"}`)) }) var count int s.handle("/pleaseissue", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Location", s.url("/pleaseissue")) st := StatusProcessing if count > 0 { st = StatusValid } fmt.Fprintf(w, `{"status":%q, "certificate":%q}`, st, s.url("/crt")) count++ }) s.handle("/crt", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Content-Type", "application/pem-certificate-chain") pem.Encode(w, &pem.Block{Type: "CERTIFICATE", Bytes: leaf}) }) s.start() defer s.close() ctx := context.Background() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} cert, curl, err := cl.CreateOrderCert(ctx, s.url("/pleaseissue"), csr, true) if err != nil { t.Fatalf("CreateOrderCert: %v", err) } if _, err := x509.ParseCertificate(cert[0]); err != nil { t.Errorf("ParseCertificate: %v", err) } if !reflect.DeepEqual(cert[0], leaf) { t.Errorf("cert and leaf bytes don't match") } if u := s.url("/crt"); curl != u { t.Errorf("curl = %q; want %q", curl, u) } } func TestRFC_AlreadyRevokedCert(t testing.T) { s := newACMEServer() s.handle("/acme/revoke-cert", func(w http.ResponseWriter, r http.Request) { s.error(w, &wireError{ Status: http.StatusBadRequest, Type: "urn:ietf:params:acme:error:alreadyRevoked", }) }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} err := cl.RevokeCert(context.Background(), testKeyEC, []byte{0}, CRLReasonUnspecified) if err != nil { t.Fatalf("RevokeCert: %v", err) } } func TestRFC_ListCertAlternates(t testing.T) { s := newACMEServer() s.handle("/crt", func(w http.ResponseWriter, r http.Request) { w.Header().Set("Content-Type", "application/pem-certificate-chain") w.Header().Add("Link", `<https://example.com/crt/2>;rel="alternate"`) w.Header().Add("Link", `<https://example.com/crt/3>; rel="alternate"`) w.Header().Add("Link", `<https://example.com/acme>; rel="index"`) }) s.handle("/crt2", func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/pem-certificate-chain") }) s.start() defer s.close() cl := &Client{Key: testKeyEC, DirectoryURL: s.url("/")} crts, err := cl.ListCertAlternates(context.Background(), s.url("/crt")) if err != nil { t.Fatalf("ListCertAlternates: %v", err) } want := []string{"https://example.com/crt/2", "https://example.com/crt/3"} if !reflect.DeepEqual(crts, want) { t.Errorf("ListCertAlternates(/crt): %v; want %v", crts, want) } crts, err = cl.ListCertAlternates(context.Background(), s.url("/crt2")) if err != nil { t.Fatalf("ListCertAlternates: %v", err) } if crts != nil { t.Errorf("ListCertAlternates(/crt2): %v; want nil", crts) } }	28.69 KB	2025-05-25 12:27
📄 types.go // Copyright 2016 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package acme import ( "crypto" "crypto/x509" "errors" "fmt" "net/http" "strings" "time" ) // ACME status values of Account, Order, Authorization and Challenge objects. // See https://tools.ietf.org/html/rfc8555#section-7.1.6 for details. const ( StatusDeactivated = "deactivated" StatusExpired = "expired" StatusInvalid = "invalid" StatusPending = "pending" StatusProcessing = "processing" StatusReady = "ready" StatusRevoked = "revoked" StatusUnknown = "unknown" StatusValid = "valid" ) // CRLReasonCode identifies the reason for a certificate revocation. type CRLReasonCode int // CRL reason codes as defined in RFC 5280. const ( CRLReasonUnspecified CRLReasonCode = 0 CRLReasonKeyCompromise CRLReasonCode = 1 CRLReasonCACompromise CRLReasonCode = 2 CRLReasonAffiliationChanged CRLReasonCode = 3 CRLReasonSuperseded CRLReasonCode = 4 CRLReasonCessationOfOperation CRLReasonCode = 5 CRLReasonCertificateHold CRLReasonCode = 6 CRLReasonRemoveFromCRL CRLReasonCode = 8 CRLReasonPrivilegeWithdrawn CRLReasonCode = 9 CRLReasonAACompromise CRLReasonCode = 10 ) var ( // ErrUnsupportedKey is returned when an unsupported key type is encountered. ErrUnsupportedKey = errors.New("acme: unknown key type; only RSA and ECDSA are supported") // ErrAccountAlreadyExists indicates that the Client's key has already been registered // with the CA. It is returned by Register method. ErrAccountAlreadyExists = errors.New("acme: account already exists") // ErrNoAccount indicates that the Client's key has not been registered with the CA. ErrNoAccount = errors.New("acme: account does not exist") ) // A Subproblem describes an ACME subproblem as reported in an Error. type Subproblem struct { // Type is a URI reference that identifies the problem type, // typically in a "urn:acme:error:xxx" form. Type string // Detail is a human-readable explanation specific to this occurrence of the problem. Detail string // Instance indicates a URL that the client should direct a human user to visit // in order for instructions on how to agree to the updated Terms of Service. // In such an event CA sets StatusCode to 403, Type to // "urn:ietf:params:acme:error:userActionRequired", and adds a Link header with relation // "terms-of-service" containing the latest TOS URL. Instance string // Identifier may contain the ACME identifier that the error is for. Identifier AuthzID } func (sp Subproblem) String() string { str := fmt.Sprintf("%s: ", sp.Type) if sp.Identifier != nil { str += fmt.Sprintf("[%s: %s] ", sp.Identifier.Type, sp.Identifier.Value) } str += sp.Detail return str } // Error is an ACME error, defined in Problem Details for HTTP APIs doc // http://tools.ietf.org/html/draft-ietf-appsawg-http-problem. type Error struct { // StatusCode is The HTTP status code generated by the origin server. StatusCode int // ProblemType is a URI reference that identifies the problem type, // typically in a "urn:acme:error:xxx" form. ProblemType string // Detail is a human-readable explanation specific to this occurrence of the problem. Detail string // Instance indicates a URL that the client should direct a human user to visit // in order for instructions on how to agree to the updated Terms of Service. // In such an event CA sets StatusCode to 403, ProblemType to // "urn:ietf:params:acme:error:userActionRequired" and a Link header with relation // "terms-of-service" containing the latest TOS URL. Instance string // Header is the original server error response headers. // It may be nil. Header http.Header // Subproblems may contain more detailed information about the individual problems // that caused the error. This field is only sent by RFC 8555 compatible ACME // servers. Defined in RFC 8555 Section 6.7.1. Subproblems []Subproblem } func (e Error) Error() string { str := fmt.Sprintf("%d %s: %s", e.StatusCode, e.ProblemType, e.Detail) if len(e.Subproblems) > 0 { str += fmt.Sprintf("; subproblems:") for _, sp := range e.Subproblems { str += fmt.Sprintf("\n\t%s", sp) } } return str } // AuthorizationError indicates that an authorization for an identifier // did not succeed. // It contains all errors from Challenge items of the failed Authorization. type AuthorizationError struct { // URI uniquely identifies the failed Authorization. URI string // Identifier is an AuthzID.Value of the failed Authorization. Identifier string // Errors is a collection of non-nil error values of Challenge items // of the failed Authorization. Errors []error } func (a AuthorizationError) Error() string { e := make([]string, len(a.Errors)) for i, err := range a.Errors { e[i] = err.Error() } if a.Identifier != "" { return fmt.Sprintf("acme: authorization error for %s: %s", a.Identifier, strings.Join(e, "; ")) } return fmt.Sprintf("acme: authorization error: %s", strings.Join(e, "; ")) } // OrderError is returned from Client's order related methods. // It indicates the order is unusable and the clients should start over with // AuthorizeOrder. // // The clients can still fetch the order object from CA using GetOrder // to inspect its state. type OrderError struct { OrderURL string Status string } func (oe OrderError) Error() string { return fmt.Sprintf("acme: order %s status: %s", oe.OrderURL, oe.Status) } // RateLimit reports whether err represents a rate limit error and // any Retry-After duration returned by the server. // // See the following for more details on rate limiting: // https://tools.ietf.org/html/draft-ietf-acme-acme-05#section-5.6 func RateLimit(err error) (time.Duration, bool) { e, ok := err.(Error) if !ok { return 0, false } // Some CA implementations may return incorrect values. // Use case-insensitive comparison. if !strings.HasSuffix(strings.ToLower(e.ProblemType), ":ratelimited") { return 0, false } if e.Header == nil { return 0, true } return retryAfter(e.Header.Get("Retry-After")), true } // Account is a user account. It is associated with a private key. // Non-RFC 8555 fields are empty when interfacing with a compliant CA. type Account struct { // URI is the account unique ID, which is also a URL used to retrieve // account data from the CA. // When interfacing with RFC 8555-compliant CAs, URI is the "kid" field // value in JWS signed requests. URI string // Contact is a slice of contact info used during registration. // See https://tools.ietf.org/html/rfc8555#section-7.3 for supported // formats. Contact []string // Status indicates current account status as returned by the CA. // Possible values are StatusValid, StatusDeactivated, and StatusRevoked. Status string // OrdersURL is a URL from which a list of orders submitted by this account // can be fetched. OrdersURL string // The terms user has agreed to. // A value not matching CurrentTerms indicates that the user hasn't agreed // to the actual Terms of Service of the CA. // // It is non-RFC 8555 compliant. Package users can store the ToS they agree to // during Client's Register call in the prompt callback function. AgreedTerms string // Actual terms of a CA. // // It is non-RFC 8555 compliant. Use Directory's Terms field. // When a CA updates their terms and requires an account agreement, // a URL at which instructions to do so is available in Error's Instance field. CurrentTerms string // Authz is the authorization URL used to initiate a new authz flow. // // It is non-RFC 8555 compliant. Use Directory's AuthzURL or OrderURL. Authz string // Authorizations is a URI from which a list of authorizations // granted to this account can be fetched via a GET request. // // It is non-RFC 8555 compliant and is obsoleted by OrdersURL. Authorizations string // Certificates is a URI from which a list of certificates // issued for this account can be fetched via a GET request. // // It is non-RFC 8555 compliant and is obsoleted by OrdersURL. Certificates string // ExternalAccountBinding represents an arbitrary binding to an account of // the CA which the ACME server is tied to. // See https://tools.ietf.org/html/rfc8555#section-7.3.4 for more details. ExternalAccountBinding ExternalAccountBinding } // ExternalAccountBinding contains the data needed to form a request with // an external account binding. // See https://tools.ietf.org/html/rfc8555#section-7.3.4 for more details. type ExternalAccountBinding struct { // KID is the Key ID of the symmetric MAC key that the CA provides to // identify an external account from ACME. KID string // Key is the bytes of the symmetric key that the CA provides to identify // the account. Key must correspond to the KID. Key []byte } func (e ExternalAccountBinding) String() string { return fmt.Sprintf("&{KID: %q, Key: redacted}", e.KID) } // Directory is ACME server discovery data. // See https://tools.ietf.org/html/rfc8555#section-7.1.1 for more details. type Directory struct { // NonceURL indicates an endpoint where to fetch fresh nonce values from. NonceURL string // RegURL is an account endpoint URL, allowing for creating new accounts. // Pre-RFC 8555 CAs also allow modifying existing accounts at this URL. RegURL string // OrderURL is used to initiate the certificate issuance flow // as described in RFC 8555. OrderURL string // AuthzURL is used to initiate identifier pre-authorization flow. // Empty string indicates the flow is unsupported by the CA. AuthzURL string // CertURL is a new certificate issuance endpoint URL. // It is non-RFC 8555 compliant and is obsoleted by OrderURL. CertURL string // RevokeURL is used to initiate a certificate revocation flow. RevokeURL string // KeyChangeURL allows to perform account key rollover flow. KeyChangeURL string // Term is a URI identifying the current terms of service. Terms string // Website is an HTTP or HTTPS URL locating a website // providing more information about the ACME server. Website string // CAA consists of lowercase hostname elements, which the ACME server // recognises as referring to itself for the purposes of CAA record validation // as defined in RFC 6844. CAA []string // ExternalAccountRequired indicates that the CA requires for all account-related // requests to include external account binding information. ExternalAccountRequired bool } // Order represents a client's request for a certificate. // It tracks the request flow progress through to issuance. type Order struct { // URI uniquely identifies an order. URI string // Status represents the current status of the order. // It indicates which action the client should take. // // Possible values are StatusPending, StatusReady, StatusProcessing, StatusValid and StatusInvalid. // Pending means the CA does not believe that the client has fulfilled the requirements. // Ready indicates that the client has fulfilled all the requirements and can submit a CSR // to obtain a certificate. This is done with Client's CreateOrderCert. // Processing means the certificate is being issued. // Valid indicates the CA has issued the certificate. It can be downloaded // from the Order's CertURL. This is done with Client's FetchCert. // Invalid means the certificate will not be issued. Users should consider this order // abandoned. Status string // Expires is the timestamp after which CA considers this order invalid. Expires time.Time // Identifiers contains all identifier objects which the order pertains to. Identifiers []AuthzID // NotBefore is the requested value of the notBefore field in the certificate. NotBefore time.Time // NotAfter is the requested value of the notAfter field in the certificate. NotAfter time.Time // AuthzURLs represents authorizations to complete before a certificate // for identifiers specified in the order can be issued. // It also contains unexpired authorizations that the client has completed // in the past. // // Authorization objects can be fetched using Client's GetAuthorization method. // // The required authorizations are dictated by CA policies. // There may not be a 1:1 relationship between the identifiers and required authorizations. // Required authorizations can be identified by their StatusPending status. // // For orders in the StatusValid or StatusInvalid state these are the authorizations // which were completed. AuthzURLs []string // FinalizeURL is the endpoint at which a CSR is submitted to obtain a certificate // once all the authorizations are satisfied. FinalizeURL string // CertURL points to the certificate that has been issued in response to this order. CertURL string // The error that occurred while processing the order as received from a CA, if any. Error Error } // OrderOption allows customizing Client.AuthorizeOrder call. type OrderOption interface { privateOrderOpt() } // WithOrderNotBefore sets order's NotBefore field. func WithOrderNotBefore(t time.Time) OrderOption { return orderNotBeforeOpt(t) } // WithOrderNotAfter sets order's NotAfter field. func WithOrderNotAfter(t time.Time) OrderOption { return orderNotAfterOpt(t) } type orderNotBeforeOpt time.Time func (orderNotBeforeOpt) privateOrderOpt() {} type orderNotAfterOpt time.Time func (orderNotAfterOpt) privateOrderOpt() {} // Authorization encodes an authorization response. type Authorization struct { // URI uniquely identifies a authorization. URI string // Status is the current status of an authorization. // Possible values are StatusPending, StatusValid, StatusInvalid, StatusDeactivated, // StatusExpired and StatusRevoked. Status string // Identifier is what the account is authorized to represent. Identifier AuthzID // The timestamp after which the CA considers the authorization invalid. Expires time.Time // Wildcard is true for authorizations of a wildcard domain name. Wildcard bool // Challenges that the client needs to fulfill in order to prove possession // of the identifier (for pending authorizations). // For valid authorizations, the challenge that was validated. // For invalid authorizations, the challenge that was attempted and failed. // // RFC 8555 compatible CAs require users to fuflfill only one of the challenges. Challenges []Challenge // A collection of sets of challenges, each of which would be sufficient // to prove possession of the identifier. // Clients must complete a set of challenges that covers at least one set. // Challenges are identified by their indices in the challenges array. // If this field is empty, the client needs to complete all challenges. // // This field is unused in RFC 8555. Combinations [][]int } // AuthzID is an identifier that an account is authorized to represent. type AuthzID struct { Type string // The type of identifier, "dns" or "ip". Value string // The identifier itself, e.g. "example.org". } // DomainIDs creates a slice of AuthzID with "dns" identifier type. func DomainIDs(names ...string) []AuthzID { a := make([]AuthzID, len(names)) for i, v := range names { a[i] = AuthzID{Type: "dns", Value: v} } return a } // IPIDs creates a slice of AuthzID with "ip" identifier type. // Each element of addr is textual form of an address as defined // in RFC 1123 Section 2.1 for IPv4 and in RFC 5952 Section 4 for IPv6. func IPIDs(addr ...string) []AuthzID { a := make([]AuthzID, len(addr)) for i, v := range addr { a[i] = AuthzID{Type: "ip", Value: v} } return a } // wireAuthzID is ACME JSON representation of authorization identifier objects. type wireAuthzID struct { Type string `json:"type"` Value string `json:"value"` } // wireAuthz is ACME JSON representation of Authorization objects. type wireAuthz struct { Identifier wireAuthzID Status string Expires time.Time Wildcard bool Challenges []wireChallenge Combinations [][]int Error wireError } func (z wireAuthz) authorization(uri string) Authorization { a := &Authorization{ URI: uri, Status: z.Status, Identifier: AuthzID{Type: z.Identifier.Type, Value: z.Identifier.Value}, Expires: z.Expires, Wildcard: z.Wildcard, Challenges: make([]Challenge, len(z.Challenges)), Combinations: z.Combinations, // shallow copy } for i, v := range z.Challenges { a.Challenges[i] = v.challenge() } return a } func (z wireAuthz) error(uri string) AuthorizationError { err := &AuthorizationError{ URI: uri, Identifier: z.Identifier.Value, } if z.Error != nil { err.Errors = append(err.Errors, z.Error.error(nil)) } for _, raw := range z.Challenges { if raw.Error != nil { err.Errors = append(err.Errors, raw.Error.error(nil)) } } return err } // Challenge encodes a returned CA challenge. // Its Error field may be non-nil if the challenge is part of an Authorization // with StatusInvalid. type Challenge struct { // Type is the challenge type, e.g. "http-01", "tls-alpn-01", "dns-01". Type string // URI is where a challenge response can be posted to. URI string // Token is a random value that uniquely identifies the challenge. Token string // Status identifies the status of this challenge. // In RFC 8555, possible values are StatusPending, StatusProcessing, StatusValid, // and StatusInvalid. Status string // Validated is the time at which the CA validated this challenge. // Always zero value in pre-RFC 8555. Validated time.Time // Error indicates the reason for an authorization failure // when this challenge was used. // The type of a non-nil value is Error. Error error } // wireChallenge is ACME JSON challenge representation. type wireChallenge struct { URL string `json:"url"` // RFC URI string `json:"uri"` // pre-RFC Type string Token string Status string Validated time.Time Error wireError } func (c wireChallenge) challenge() Challenge { v := &Challenge{ URI: c.URL, Type: c.Type, Token: c.Token, Status: c.Status, } if v.URI == "" { v.URI = c.URI // c.URL was empty; use legacy } if v.Status == "" { v.Status = StatusPending } if c.Error != nil { v.Error = c.Error.error(nil) } return v } // wireError is a subset of fields of the Problem Details object // as described in https://tools.ietf.org/html/rfc7807#section-3.1. type wireError struct { Status int Type string Detail string Instance string Subproblems []Subproblem } func (e wireError) error(h http.Header) Error { err := &Error{ StatusCode: e.Status, ProblemType: e.Type, Detail: e.Detail, Instance: e.Instance, Header: h, Subproblems: e.Subproblems, } return err } // CertOption is an optional argument type for the TLS ChallengeCert methods for // customizing a temporary certificate for TLS-based challenges. type CertOption interface { privateCertOpt() } // WithKey creates an option holding a private/public key pair. // The private part signs a certificate, and the public part represents the signee. func WithKey(key crypto.Signer) CertOption { return &certOptKey{key} } type certOptKey struct { key crypto.Signer } func (certOptKey) privateCertOpt() {} // WithTemplate creates an option for specifying a certificate template. // See x509.CreateCertificate for template usage details. // // In TLS ChallengeCert methods, the template is also used as parent, // resulting in a self-signed certificate. // The DNSNames field of t is always overwritten for tls-sni challenge certs. func WithTemplate(t x509.Certificate) CertOption { return (certOptTemplate)(t) } type certOptTemplate x509.Certificate func (*certOptTemplate) privateCertOpt() {}	19.47 KB	2025-05-25 12:27
📄 types_test.go // Copyright 2017 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package acme import ( "errors" "net/http" "reflect" "testing" "time" ) func TestExternalAccountBindingString(t testing.T) { eab := ExternalAccountBinding{ KID: "kid", Key: []byte("key"), } got := eab.String() want := `&{KID: "kid", Key: redacted}` if got != want { t.Errorf("eab.String() = %q, want: %q", got, want) } } func TestRateLimit(t testing.T) { now := time.Date(2017, 04, 27, 10, 0, 0, 0, time.UTC) f := timeNow defer func() { timeNow = f }() timeNow = func() time.Time { return now } h120, hTime := http.Header{}, http.Header{} h120.Set("Retry-After", "120") hTime.Set("Retry-After", "Tue Apr 27 11:00:00 2017") err1 := &Error{ ProblemType: "urn:ietf:params:acme:error:nolimit", Header: h120, } err2 := &Error{ ProblemType: "urn:ietf:params:acme:error:rateLimited", Header: h120, } err3 := &Error{ ProblemType: "urn:ietf:params:acme:error:rateLimited", Header: nil, } err4 := &Error{ ProblemType: "urn:ietf:params:acme:error:rateLimited", Header: hTime, } tt := []struct { err error res time.Duration ok bool }{ {nil, 0, false}, {errors.New("dummy"), 0, false}, {err1, 0, false}, {err2, 2 * time.Minute, true}, {err3, 0, true}, {err4, time.Hour, true}, } for i, test := range tt { res, ok := RateLimit(test.err) if ok != test.ok { t.Errorf("%d: RateLimit(%+v): ok = %v; want %v", i, test.err, ok, test.ok) continue } if res != test.res { t.Errorf("%d: RateLimit(%+v) = %v; want %v", i, test.err, res, test.res) } } } func TestAuthorizationError(t testing.T) { tests := []struct { desc string err AuthorizationError msg string }{ { desc: "when auth error identifier is set", err: &AuthorizationError{ Identifier: "domain.com", Errors: []error{ (&wireError{ Status: 403, Type: "urn:ietf:params:acme:error:caa", Detail: "CAA record for domain.com prevents issuance", }).error(nil), }, }, msg: "acme: authorization error for domain.com: 403 urn:ietf:params:acme:error:caa: CAA record for domain.com prevents issuance", }, { desc: "when auth error identifier is unset", err: &AuthorizationError{ Errors: []error{ (&wireError{ Status: 403, Type: "urn:ietf:params:acme:error:caa", Detail: "CAA record for domain.com prevents issuance", }).error(nil), }, }, msg: "acme: authorization error: 403 urn:ietf:params:acme:error:caa: CAA record for domain.com prevents issuance", }, } for _, tt := range tests { if tt.err.Error() != tt.msg { t.Errorf("got: %s\nwant: %s", tt.err, tt.msg) } } } func TestSubproblems(t testing.T) { tests := []struct { wire wireError expectedOut Error }{ { wire: wireError{ Status: 1, Type: "urn:error", Detail: "it's an error", }, expectedOut: Error{ StatusCode: 1, ProblemType: "urn:error", Detail: "it's an error", }, }, { wire: wireError{ Status: 1, Type: "urn:error", Detail: "it's an error", Subproblems: []Subproblem{ { Type: "urn:error:sub", Detail: "it's a subproblem", }, }, }, expectedOut: Error{ StatusCode: 1, ProblemType: "urn:error", Detail: "it's an error", Subproblems: []Subproblem{ { Type: "urn:error:sub", Detail: "it's a subproblem", }, }, }, }, { wire: wireError{ Status: 1, Type: "urn:error", Detail: "it's an error", Subproblems: []Subproblem{ { Type: "urn:error:sub", Detail: "it's a subproblem", Identifier: &AuthzID{Type: "dns", Value: "example"}, }, }, }, expectedOut: Error{ StatusCode: 1, ProblemType: "urn:error", Detail: "it's an error", Subproblems: []Subproblem{ { Type: "urn:error:sub", Detail: "it's a subproblem", Identifier: &AuthzID{Type: "dns", Value: "example"}, }, }, }, }, } for _, tc := range tests { out := tc.wire.error(nil) if !reflect.DeepEqual(out, tc.expectedOut) { t.Errorf("Unexpected error: wanted %v, got %v", tc.expectedOut, out) } } } func TestErrorStringerWithSubproblems(t testing.T) { err := Error{ StatusCode: 1, ProblemType: "urn:error", Detail: "it's an error", Subproblems: []Subproblem{ { Type: "urn:error:sub", Detail: "it's a subproblem", }, { Type: "urn:error:sub", Detail: "it's a subproblem", Identifier: &AuthzID{Type: "dns", Value: "example"}, }, }, } expectedStr := "1 urn:error: it's an error; subproblems:\n\turn:error:sub: it's a subproblem\n\turn:error:sub: [dns: example] it's a subproblem" if err.Error() != expectedStr { t.Errorf("Unexpected error string: wanted %q, got %q", expectedStr, err.Error()) } }	4.91 KB	2025-05-25 12:27

Terminal