From f64ea78c4481ecfb7d22decbf73dfd388a317d2a Mon Sep 17 00:00:00 2001 From: xiaojunnuo Date: Sun, 29 Jan 2023 15:27:11 +0800 Subject: [PATCH] =?UTF-8?q?=F0=9F=94=B1:=20[acme]=20sync=20upgrade=20with?= =?UTF-8?q?=2021=20commits=20[trident-sync]?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bump v5.0.0 --- .gitignore | 29 +- .../core/acme-client/.circleci/.gitignore | 1 + .../core/acme-client/.circleci/config.yml | 133 ++++ packages/core/acme-client/.editorconfig | 13 + packages/core/acme-client/.eslintrc.yml | 23 + packages/core/acme-client/.gitignore | 6 + packages/core/acme-client/.yarnrc | 2 + packages/core/acme-client/CHANGELOG.md | 222 ++++++ packages/core/acme-client/LICENSE | 21 + packages/core/acme-client/README.md | 262 +++++++ packages/core/acme-client/docs/client.md | 518 ++++++++++++ packages/core/acme-client/docs/crypto.md | 267 +++++++ packages/core/acme-client/docs/forge.md | 257 ++++++ packages/core/acme-client/docs/upgrade-v5.md | 98 +++ packages/core/acme-client/examples/api.js | 153 ++++ packages/core/acme-client/examples/auto.js | 118 +++ packages/core/acme-client/package.json | 60 ++ .../core/acme-client/scripts/run-tests.sh | 56 ++ .../scripts/test-suite-install-coredns.sh | 58 ++ .../scripts/test-suite-install-cts.sh | 13 + .../scripts/test-suite-install-pebble.sh | 33 + .../scripts/test-suite-install-step.sh | 20 + .../scripts/test-suite-wait-for-ca.sh | 27 + packages/core/acme-client/src/api.js | 250 ++++++ packages/core/acme-client/src/auto.js | 179 +++++ packages/core/acme-client/src/axios.js | 40 + packages/core/acme-client/src/client.js | 735 ++++++++++++++++++ packages/core/acme-client/src/crypto/forge.js | 448 +++++++++++ packages/core/acme-client/src/crypto/index.js | 526 +++++++++++++ packages/core/acme-client/src/http.js | 318 ++++++++ packages/core/acme-client/src/index.js | 46 ++ packages/core/acme-client/src/logger.js | 30 + packages/core/acme-client/src/util.js | 258 ++++++ packages/core/acme-client/src/verify.js | 127 +++ .../core/acme-client/test/00-pebble.spec.js | 121 +++ .../core/acme-client/test/10-http.spec.js | 101 +++ .../core/acme-client/test/10-logger.spec.js | 35 + .../core/acme-client/test/10-verify.spec.js | 106 +++ .../acme-client/test/20-crypto-legacy.spec.js | 276 +++++++ .../core/acme-client/test/20-crypto.spec.js | 317 ++++++++ .../core/acme-client/test/50-client.spec.js | 574 ++++++++++++++ .../core/acme-client/test/70-auto.spec.js | 384 +++++++++ .../core/acme-client/test/challtestsrv.js | 93 +++ .../acme-client/test/fixtures/certificate.crt | 30 + .../acme-client/test/fixtures/private.key | 27 + .../test/fixtures/san-certificate.crt | 18 + .../core/acme-client/test/get-cert-issuers.js | 40 + packages/core/acme-client/test/setup.js | 87 +++ packages/core/acme-client/test/spec.js | 178 +++++ packages/core/acme-client/types/index.d.ts | 190 +++++ packages/core/acme-client/types/rfc8555.d.ts | 127 +++ packages/core/acme-client/types/test.ts | 70 ++ packages/core/acme-client/types/tsconfig.json | 11 + packages/core/acme-client/types/tslint.json | 6 + 54 files changed, 8136 insertions(+), 2 deletions(-) create mode 100644 packages/core/acme-client/.circleci/.gitignore create mode 100644 packages/core/acme-client/.circleci/config.yml create mode 100644 packages/core/acme-client/.editorconfig create mode 100644 packages/core/acme-client/.eslintrc.yml create mode 100644 packages/core/acme-client/.gitignore create mode 100644 packages/core/acme-client/.yarnrc create mode 100644 packages/core/acme-client/CHANGELOG.md create mode 100644 packages/core/acme-client/LICENSE create mode 100644 packages/core/acme-client/README.md create mode 100644 packages/core/acme-client/docs/client.md create mode 100644 packages/core/acme-client/docs/crypto.md create mode 100644 packages/core/acme-client/docs/forge.md create mode 100644 packages/core/acme-client/docs/upgrade-v5.md create mode 100644 packages/core/acme-client/examples/api.js create mode 100644 packages/core/acme-client/examples/auto.js create mode 100644 packages/core/acme-client/package.json create mode 100644 packages/core/acme-client/scripts/run-tests.sh create mode 100644 packages/core/acme-client/scripts/test-suite-install-coredns.sh create mode 100644 packages/core/acme-client/scripts/test-suite-install-cts.sh create mode 100644 packages/core/acme-client/scripts/test-suite-install-pebble.sh create mode 100644 packages/core/acme-client/scripts/test-suite-install-step.sh create mode 100644 packages/core/acme-client/scripts/test-suite-wait-for-ca.sh create mode 100644 packages/core/acme-client/src/api.js create mode 100644 packages/core/acme-client/src/auto.js create mode 100644 packages/core/acme-client/src/axios.js create mode 100644 packages/core/acme-client/src/client.js create mode 100644 packages/core/acme-client/src/crypto/forge.js create mode 100644 packages/core/acme-client/src/crypto/index.js create mode 100644 packages/core/acme-client/src/http.js create mode 100644 packages/core/acme-client/src/index.js create mode 100644 packages/core/acme-client/src/logger.js create mode 100644 packages/core/acme-client/src/util.js create mode 100644 packages/core/acme-client/src/verify.js create mode 100644 packages/core/acme-client/test/00-pebble.spec.js create mode 100644 packages/core/acme-client/test/10-http.spec.js create mode 100644 packages/core/acme-client/test/10-logger.spec.js create mode 100644 packages/core/acme-client/test/10-verify.spec.js create mode 100644 packages/core/acme-client/test/20-crypto-legacy.spec.js create mode 100644 packages/core/acme-client/test/20-crypto.spec.js create mode 100644 packages/core/acme-client/test/50-client.spec.js create mode 100644 packages/core/acme-client/test/70-auto.spec.js create mode 100644 packages/core/acme-client/test/challtestsrv.js create mode 100644 packages/core/acme-client/test/fixtures/certificate.crt create mode 100644 packages/core/acme-client/test/fixtures/private.key create mode 100644 packages/core/acme-client/test/fixtures/san-certificate.crt create mode 100644 packages/core/acme-client/test/get-cert-issuers.js create mode 100644 packages/core/acme-client/test/setup.js create mode 100644 packages/core/acme-client/test/spec.js create mode 100644 packages/core/acme-client/types/index.d.ts create mode 100644 packages/core/acme-client/types/rfc8555.d.ts create mode 100644 packages/core/acme-client/types/test.ts create mode 100644 packages/core/acme-client/types/tsconfig.json create mode 100644 packages/core/acme-client/types/tslint.json diff --git a/.gitignore b/.gitignore index ccedd9ff..3fda4751 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,32 @@ # IntelliJ project files +.vscode/ +node_modules/ +npm-debug.log +yarn-error.log +yarn.lock +package-lock.json +/.idea/ +*/**/dist +*/**/pnpm-lock.yaml +*/**/stats.html .idea *.iml out gen -node_modules/ -packages/*/test/*-private.js +/test/*.private.* + +/*.log + +/packages/ui/*/.idea + +/packages/ui/*/node_modules + +/packages/*/node_modules +/packages/ui/certd-server/tmp/ +/packages/ui/certd-ui/dist/ +/other +/dev-sidecar-test +/packages/core/certd/yarn.lock +/packages/test +/test/own +/pnpm-lock.yaml diff --git a/packages/core/acme-client/.circleci/.gitignore b/packages/core/acme-client/.circleci/.gitignore new file mode 100644 index 00000000..0ae14133 --- /dev/null +++ b/packages/core/acme-client/.circleci/.gitignore @@ -0,0 +1 @@ +.temp.yml diff --git a/packages/core/acme-client/.circleci/config.yml b/packages/core/acme-client/.circleci/config.yml new file mode 100644 index 00000000..db3ef431 --- /dev/null +++ b/packages/core/acme-client/.circleci/config.yml @@ -0,0 +1,133 @@ +--- +version: 2.1 + +commands: + pre: + steps: + - run: node --version + - run: npm --version + - run: yarn --version + - checkout + + enable-eab: + steps: + - run: + name: Enable EAB through environment + command: | + echo 'export ACME_CAP_EAB_ENABLED=1' >> $BASH_ENV + + install-cts: + steps: + - run: + name: Install Pebble Challenge Test Server + command: sudo -E /bin/bash ./scripts/test-suite-install-cts.sh + environment: + PEBBLECTS_VERSION: 2.3.1 + + - run: + name: Start Pebble Challenge Test Server + command: pebble-challtestsrv -dns01 ":8053" -tlsalpn01 ":5001" -http01 ":5002" -https01 ":5003" -defaultIPv4 "127.0.0.1" -defaultIPv6 "" + background: true + + install-pebble: + steps: + - run: + name: Install Pebble + command: sudo -E /bin/bash ./scripts/test-suite-install-pebble.sh + environment: + PEBBLE_VERSION: 2.3.1 + + - run: + name: Start Pebble + command: pebble -strict -config /etc/pebble/pebble.json -dnsserver "127.0.0.1:53" + background: true + environment: + PEBBLE_ALTERNATE_ROOTS: 2 + + - run: + name: Set up environment + command: | + echo 'export NODE_EXTRA_CA_CERTS="/etc/pebble/ca.cert.pem"' >> $BASH_ENV + echo 'export ACME_CA_CERT_PATH="/etc/pebble/ca.cert.pem"' >> $BASH_ENV + echo 'export ACME_DIRECTORY_URL="https://127.0.0.1:14000/dir"' >> $BASH_ENV + echo 'export ACME_PEBBLE_MANAGEMENT_URL="https://127.0.0.1:15000"' >> $BASH_ENV + + - run: + name: Wait for Pebble + command: /bin/bash ./scripts/test-suite-wait-for-ca.sh + + install-step: + steps: + - run: + name: Install Step Certificates + command: /bin/bash ./scripts/test-suite-install-step.sh + environment: + STEPCA_VERSION: 0.18.0 + STEPCLI_VERSION: 0.18.0 + + - run: + name: Start Step CA + command: /usr/bin/step-ca --resolver="127.0.0.1:53" --password-file="/tmp/password" ~/.step/config/ca.json + background: true + + - run: + name: Set up environment + command: | + echo 'export NODE_EXTRA_CA_CERTS="/home/circleci/.step/certs/root_ca.crt"' >> $BASH_ENV + echo 'export ACME_CA_CERT_PATH="/home/circleci/.step/certs/root_ca.crt"' >> $BASH_ENV + echo 'export ACME_DIRECTORY_URL="https://localhost:8443/acme/acme/directory"' >> $BASH_ENV + + echo 'export ACME_CAP_META_TOS_FIELD=0' >> $BASH_ENV + echo 'export ACME_CAP_UPDATE_ACCOUNT_KEY=0' >> $BASH_ENV + echo 'export ACME_CAP_ALTERNATE_CERT_ROOTS=0' >> $BASH_ENV + + - run: + name: Wait for Step CA + command: /bin/bash ./scripts/test-suite-wait-for-ca.sh + + install-coredns: + steps: + - run: + name: Install CoreDNS + command: sudo -E /bin/bash ./scripts/test-suite-install-coredns.sh + environment: + COREDNS_VERSION: 1.8.6 + PEBBLECTS_DNS_PORT: 8053 + + - run: + name: Start CoreDNS + command: sudo coredns -p 53 -conf /etc/coredns/Corefile + background: true + + test: + steps: + - run: yarn --color + - run: yarn run lint --color + - run: yarn run lint-types + - run: yarn run build-docs + + - run: + command: yarn run test --color + environment: + ACME_DOMAIN_NAME: test.example.com + ACME_CHALLTESTSRV_URL: http://127.0.0.1:8055 + ACME_DNS_RESOLVER: 127.0.0.1 + ACME_TLSALPN_PORT: 5001 + ACME_HTTP_PORT: 5002 + ACME_HTTPS_PORT: 5003 + +jobs: + v16: { docker: [{ image: cimg/node:16.16 }], steps: [ pre, install-cts, install-pebble, install-coredns, test ]} + v18: { docker: [{ image: cimg/node:18.4 }], steps: [ pre, install-cts, install-pebble, install-coredns, test ]} + eab-v16: { docker: [{ image: cimg/node:16.16 }], steps: [ pre, enable-eab, install-cts, install-pebble, install-coredns, test ]} + eab-v18: { docker: [{ image: cimg/node:18.4 }], steps: [ pre, enable-eab, install-cts, install-pebble, install-coredns, test ]} + # step-v12: { docker: [{ image: cimg/node:12.22 }], steps: [ pre, install-cts, install-step, install-coredns, test ]} + +workflows: + test-suite: + jobs: + - v16 + - v18 + - eab-v16 + - eab-v18 + # - step-v12 diff --git a/packages/core/acme-client/.editorconfig b/packages/core/acme-client/.editorconfig new file mode 100644 index 00000000..f95adc8f --- /dev/null +++ b/packages/core/acme-client/.editorconfig @@ -0,0 +1,13 @@ +# +# http://editorconfig.org +# + +root = true + +[*] +indent_style = spaces +indent_size = 4 +trim_trailing_whitespace = true + +[{*.yml,*.yaml}] +indent_size = 2 diff --git a/packages/core/acme-client/.eslintrc.yml b/packages/core/acme-client/.eslintrc.yml new file mode 100644 index 00000000..ec901b2c --- /dev/null +++ b/packages/core/acme-client/.eslintrc.yml @@ -0,0 +1,23 @@ +extends: + - 'airbnb-base' + +env: + browser: false + node: true + mocha: true + +rules: + indent: [2, 4, { SwitchCase: 1, VariableDeclarator: 1 }] + brace-style: [2, 'stroustrup', { allowSingleLine: true }] + space-before-function-paren: [2, { anonymous: 'never', named: 'never' }] + func-names: 0 + prefer-destructuring: 0 + object-curly-newline: 0 + class-methods-use-this: 0 + wrap-iife: [2, 'inside'] + no-param-reassign: 0 + comma-dangle: [2, 'never'] + max-len: [1, 200, 2, { ignoreUrls: true, ignoreComments: false }] + no-multiple-empty-lines: [2, { max: 2, maxBOF: 0, maxEOF: 0 }] + prefer-object-spread: 0 + import/no-useless-path-segments: 0 diff --git a/packages/core/acme-client/.gitignore b/packages/core/acme-client/.gitignore new file mode 100644 index 00000000..61a8d616 --- /dev/null +++ b/packages/core/acme-client/.gitignore @@ -0,0 +1,6 @@ +.vscode/ +node_modules/ +npm-debug.log +yarn-error.log +yarn.lock +package-lock.json diff --git a/packages/core/acme-client/.yarnrc b/packages/core/acme-client/.yarnrc new file mode 100644 index 00000000..8d6f153a --- /dev/null +++ b/packages/core/acme-client/.yarnrc @@ -0,0 +1,2 @@ +ignore-engines true +ignore-optional true diff --git a/packages/core/acme-client/CHANGELOG.md b/packages/core/acme-client/CHANGELOG.md new file mode 100644 index 00000000..05e46a01 --- /dev/null +++ b/packages/core/acme-client/CHANGELOG.md @@ -0,0 +1,222 @@ +# Changelog + +## Important upgrade notice + +On September 15, 2022, Let's Encrypt will stop accepting Certificate Signing Requests signed using the obsolete SHA-1 hash. This change affects all `acme-client` versions lower than `3.3.2` and `4.2.4`. Please upgrade ASAP to ensure that your certificates can still be issued following this date. + +A more detailed explanation can be found [at the Let's Encrypt forums](https://community.letsencrypt.org/t/rejecting-sha-1-csrs-and-validation-using-tls-1-0-1-1-urls/175144). + + +## v5.0.0 (2022-07-28) + +* [Upgrade guide here](docs/upgrade-v5.md) +* `added` New native crypto interface, ECC/ECDSA support +* `breaking` Remove support for Node v10, v12 and v14 +* `breaking` Prioritize issuer closest to root during preferred chain selection - [#46](https://github.com/publishlab/node-acme-client/issues/46) +* `changed` Replace `bluebird` dependency with native promise APIs +* `changed` Replace `backo2` dependency with internal utility + + +## v4.2.5 (2022-03-21) + +* `fixed` Upgrade `axios@0.26.1` +* `fixed` Upgrade `node-forge@1.3.0` - [CVE-2022-24771](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-24771), [CVE-2022-24772](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-24772), [CVE-2022-24773](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-24773) + + +## 4.2.4 (2022-03-19) + +* `fixed` Use SHA-256 when signing CSRs + + +## v3.3.2 (2022-03-19) + +* `backport` Use SHA-256 when signing CSRs + + +## v4.2.3 (2022-01-11) + +* `added` Directory URLs for ACME providers [Buypass](https://www.buypass.com) and [ZeroSSL](https://zerossl.com) +* `fixed` Skip already valid authorizations when using `client.auto()` + + +## v4.2.2 (2022-01-10) + +* `fixed` Upgrade `node-forge@1.2.0` + + +## v4.2.1 (2022-01-10) + +* `fixed` ZeroSSL `duplicate_domains_in_array` error when using `client.auto()` + + +## v4.2.0 (2022-01-06) + +* `added` Support for external account binding - [RFC 8555 Section 7.3.4](https://tools.ietf.org/html/rfc8555#section-7.3.4) +* `added` Ability to pass through custom logger function +* `changed` Increase default `backoffAttempts` to 10 +* `fixed` Deactivate authorizations where challenges can not be completed +* `fixed` Attempt authoritative name servers when verifying `dns-01` challenges +* `fixed` Error verbosity when failing to read ACME directory +* `fixed` Correctly recognize `ready` and `processing` states - [RFC 8555 Section 7.1.6](https://tools.ietf.org/html/rfc8555#section-7.1.6) + + +## v4.1.4 (2021-12-23) + +* `fixed` Upgrade `axios@0.21.4` - [CVE-2021-3749](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-3749) + + +## v4.1.3 (2021-02-22) + +* `fixed` Upgrade `axios@0.21.1` - [CVE-2020-28168](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-28168) + + +## v4.1.2 (2020-11-16) + +* `fixed` Bug when encoding PEM payloads, potentially causing malformed requests + + +## v4.1.1 (2020-11-13) + +* `fixed` Missing TypeScript definitions + + +## v4.1.0 (2020-11-12) + +* `added` Option `preferredChain` added to `client.getCertificate()` and `client.auto()` to indicate which certificate chain is preferred if a CA offers multiple + * Related: [https://community.letsencrypt.org/t/transition-to-isrgs-root-delayed-until-jan-11-2021/125516](https://community.letsencrypt.org/t/transition-to-isrgs-root-delayed-until-jan-11-2021/125516) +* `added` Method `client.getOrder()` to refresh order from CA +* `fixed` Upgrade `axios@0.21.0` +* `fixed` Error when attempting to revoke a certificate chain +* `fixed` Missing URL augmentation in `client.finalizeOrder()` and `client.deactivateAuthorization()` +* `fixed` Add certificate issuer to response from `forge.readCertificateInfo()` + + +## v4.0.2 (2020-10-09) + +* `fixed` Explicitly set default `axios` HTTP adapter - [axios/axios#1180](https://github.com/axios/axios/issues/1180) + + +## v4.0.1 (2020-09-15) + +* `fixed` Upgrade `node-forge@0.10.0` - [CVE-2020-7720](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-7720) + + +## v4.0.0 (2020-05-29) + +* `breaking` Remove support for Node v8 +* `breaking` Remove deprecated `openssl` crypto module +* `fixed` Incorrect TypeScript `CertificateInfo` definitions +* `fixed` Allow trailing whitespace character in `http-01` challenge response + + +## v3.3.1 (2020-01-07) + +* `fixed` Improvements to TypeScript definitions + + +## v3.3.0 (2019-12-19) + +* `added` TypeScript definitions +* `fixed` Allow missing ACME directory meta field - [RFC 8555 Section 7.1.1](https://tools.ietf.org/html/rfc8555#section-7.1.1) + + +## v3.2.1 (2019-11-14) + +* `added` New option `skipChallengeVerification` added to `client.auto()` to bypass internal challenge verification + + +## v3.2.0 (2019-08-26) + +* `added` More extensive testing using [letsencrypt/pebble](https://github.com/letsencrypt/pebble) +* `changed` When creating a CSR, `commonName` no longer defaults to `'localhost'` + * This change is not considered breaking since `commonName: 'localhost'` will result in an error when ordering a certificate +* `fixed` Retry signed API requests on `urn:ietf:params:acme:error:badNonce` - [RFC 8555 Section 6.5](https://tools.ietf.org/html/rfc8555#section-6.5) +* `fixed` Minor bugs related to `POST-as-GET` when calling `updateAccount()` +* `fixed` Ensure subject common name is present in SAN when creating a CSR - [CAB v1.2.3 Section 9.2.2](https://cabforum.org/wp-content/uploads/BRv1.2.3.pdf) +* `fixed` Send empty JSON body when responding to challenges - [RFC 8555 Section 7.5.1](https://tools.ietf.org/html/rfc8555#section-7.5.1) + + +## v2.3.1 (2019-08-26) + +* `backport` Minor bugs related to `POST-as-GET` when calling `client.updateAccount()` +* `backport` Send empty JSON body when responding to challenges + + +## v3.1.0 (2019-08-21) + +* `added` UTF-8 support when generating a CSR subject using forge - [RFC 5280](https://tools.ietf.org/html/rfc5280) +* `fixed` Implement `POST-as-GET` for all ACME API requests - [RFC 8555 Section 6.3](https://tools.ietf.org/html/rfc8555#section-6.3) + + +## v2.3.0 (2019-08-21) + +* `backport` Implement `POST-as-GET` for all ACME API requests + + +## v3.0.0 (2019-07-13) + +* `added` Expose `axios` instance to allow manipulating HTTP client defaults +* `breaking` Remove support for Node v4 and v6 +* `breaking` Remove Babel transpilation + + +## v2.2.3 (2019-01-25) + +* `added` DNS CNAME detection when verifying `dns-01` challenges + + +## v2.2.2 (2019-01-07) + +* `added` Support for `tls-alpn-01` challenge key authorization + + +## v2.2.1 (2019-01-04) + +* `fixed` Handle and throw errors from OpenSSL process + + +## v2.2.0 (2018-11-06) + +* `added` New [node-forge](https://www.npmjs.com/package/node-forge) crypto interface, removes OpenSSL CLI dependency +* `added` Support native `crypto.generateKeyPair()` API when generating key pairs + + +## v2.1.0 (2018-10-21) + +* `added` Ability to set and get current account URL +* `fixed` Replace HTTP client `request` with `axios` +* `fixed` Auto-mode no longer tries to create account when account URL exists + + +## v2.0.1 (2018-08-17) + +* `fixed` Key rollover in compliance with [draft-ietf-acme-13](https://tools.ietf.org/html/draft-ietf-acme-acme-13) + + +## v2.0.0 (2018-04-02) + +* `breaking` ACMEv2 +* `breaking` API changes +* `breaking` Rewrite to ES6 +* `breaking` Promises instead of callbacks + + +## v1.0.0 (2017-10-20) + +* API stable + + +## v0.2.1 (2017-09-27) + +* `fixed` Bug causing invalid anti-replay nonce + + +## v0.2.0 (2017-09-21) + +* `breaking` OpenSSL method `readCsrDomains` and `readCertificateInfo` now return domains as an object +* `fixed` Added and fixed some tests + + +## v0.1.0 (2017-09-14) + +* `acme-client` released diff --git a/packages/core/acme-client/LICENSE b/packages/core/acme-client/LICENSE new file mode 100644 index 00000000..7c8adf14 --- /dev/null +++ b/packages/core/acme-client/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017-2022 Publish Lab + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/core/acme-client/README.md b/packages/core/acme-client/README.md new file mode 100644 index 00000000..88af9efe --- /dev/null +++ b/packages/core/acme-client/README.md @@ -0,0 +1,262 @@ +# acme-client [![CircleCI](https://circleci.com/gh/publishlab/node-acme-client.svg?style=svg)](https://circleci.com/gh/publishlab/node-acme-client) + +*A simple and unopinionated ACME client.* + +This module is written to handle communication with a Boulder/Let's Encrypt-style ACME API. + +* RFC 8555 - Automatic Certificate Management Environment (ACME): [https://tools.ietf.org/html/rfc8555](https://tools.ietf.org/html/rfc8555) +* Boulder divergences from ACME: [https://github.com/letsencrypt/boulder/blob/master/docs/acme-divergences.md](https://github.com/letsencrypt/boulder/blob/master/docs/acme-divergences.md) + + +## Important upgrade notice + +On September 15, 2022, Let's Encrypt will stop accepting Certificate Signing Requests signed using the obsolete SHA-1 hash. This change affects all `acme-client` versions lower than `3.3.2` and `4.2.4`. Please upgrade ASAP to ensure that your certificates can still be issued following this date. + +A more detailed explanation can be found [at the Let's Encrypt forums](https://community.letsencrypt.org/t/rejecting-sha-1-csrs-and-validation-using-tls-1-0-1-1-urls/175144). + + +### Compatibility + +| acme-client | Node.js | | +| ------------- | --------- | ----------------------------------------- | +| v5.x | >= v16 | [Upgrade guide](docs/upgrade-v5.md) | +| v4.x | >= v10 | [Changelog](CHANGELOG.md#v400-2020-05-29) | +| v3.x | >= v8 | [Changelog](CHANGELOG.md#v300-2019-07-13) | +| v2.x | >= v4 | [Changelog](CHANGELOG.md#v200-2018-04-02) | +| v1.x | >= v4 | [Changelog](CHANGELOG.md#v100-2017-10-20) | + + +### Table of contents + +* [Installation](#installation) +* [Usage](#usage) + * [Directory URLs](#directory-urls) + * [External account binding](#external-account-binding) + * [Specifying the account URL](#specifying-the-account-url) +* [Cryptography](#cryptography) + * [Legacy .forge interface](#legacy-forge-interface) +* [Auto mode](#auto-mode) + * [Challenge priority](#challenge-priority) + * [Internal challenge verification](#internal-challenge-verification) +* [API](#api) +* [HTTP client defaults](#http-client-defaults) +* [Debugging](#debugging) +* [License](#license) + + +## Installation + +```bash +$ npm install acme-client +``` + + +## Usage + +```js +const acme = require('acme-client'); + +const accountPrivateKey = ''; + +const client = new acme.Client({ + directoryUrl: acme.directory.letsencrypt.staging, + accountKey: accountPrivateKey +}); +``` + + +### Directory URLs + +```js +acme.directory.buypass.staging; +acme.directory.buypass.production; + +acme.directory.letsencrypt.staging; +acme.directory.letsencrypt.production; + +acme.directory.zerossl.production; +``` + + +### External account binding + +To enable [external account binding](https://tools.ietf.org/html/rfc8555#section-7.3.4) when creating your ACME account, provide your KID and HMAC key to the client constructor. + +```js +const client = new acme.Client({ + directoryUrl: 'https://acme-provider.example.com/directory-url', + accountKey: accountPrivateKey, + externalAccountBinding: { + kid: 'YOUR-EAB-KID', + hmacKey: 'YOUR-EAB-HMAC-KEY' + } +}); +``` + + +### Specifying the account URL + +During the ACME account creation process, the server will check the supplied account key and either create a new account if the key is unused, or return the existing ACME account bound to that key. + +In some cases, for example with some EAB providers, this account creation step may be prohibited and might require you to manually specify the account URL beforehand. This can be done through `accountUrl` in the client constructor. + +```js +const client = new acme.Client({ + directoryUrl: acme.directory.letsencrypt.staging, + accountKey: accountPrivateKey, + accountUrl: 'https://acme-v02.api.letsencrypt.org/acme/acct/12345678' +}); +``` + +You can fetch the clients current account URL, either after creating an account or supplying it through the constructor, using `getAccountUrl()`: + +```js +const myAccountUrl = client.getAccountUrl(); +``` + + +## Cryptography + +For key pairs `acme-client` utilizes native Node.js cryptography APIs, supporting signing and generation of both RSA and ECDSA keys. The module [jsrsasign](https://www.npmjs.com/package/jsrsasign) is used to generate and parse Certificate Signing Requests. + +These utility methods are exposed through `.crypto`. + +* __Documentation: [docs/crypto.md](docs/crypto.md)__ + +```js +const privateRsaKey = await acme.crypto.createPrivateRsaKey(); +const privateEcdsaKey = await acme.crypto.createPrivateEcdsaKey(); + +const [certificateKey, certificateCsr] = await acme.crypto.createCsr({ + commonName: '*.example.com', + altNames: ['example.com'] +}); +``` + + +### Legacy `.forge` interface + +The legacy `node-forge` crypto interface is still available for backward compatibility, however this interface is now considered deprecated and will be removed in a future major version of `acme-client`. + +You should consider migrating to the new `.crypto` API at your earliest convenience. More details can be found in the [acme-client v5 upgrade guide](docs/upgrade-v5.md). + +* __Documentation: [docs/forge.md](docs/forge.md)__ + + +## Auto mode + +For convenience an `auto()` method is included in the client that takes a single config object. This method will handle the entire process of getting a certificate for one or multiple domains. + +* __Documentation: [docs/client.md#AcmeClient+auto](docs/client.md#AcmeClient+auto)__ +* __Full example: [examples/auto.js](examples/auto.js)__ + +```js +const autoOpts = { + csr: '', + email: 'test@example.com', + termsOfServiceAgreed: true, + challengeCreateFn: async (authz, challenge, keyAuthorization) => {}, + challengeRemoveFn: async (authz, challenge, keyAuthorization) => {} +}; + +const certificate = await client.auto(autoOpts); +``` + + +### Challenge priority + +When ordering a certificate using auto mode, `acme-client` uses a priority list when selecting challenges to respond to. Its default value is `['http-01', 'dns-01']` which translates to "use `http-01` if any challenges exist, otherwise fall back to `dns-01`". + +While most challenges can be validated using the method of your choosing, please note that __wildcard certificates can only be validated through `dns-01`__. More information regarding Let's Encrypt challenge types [can be found here](https://letsencrypt.org/docs/challenge-types/). + +To modify challenge priority, provide a list of challenge types in `challengePriority`: + +```js +await client.auto({ + ..., + challengePriority: ['http-01', 'dns-01'] +}); +``` + + +### Internal challenge verification + +When using auto mode, `acme-client` will first validate that challenges are satisfied internally before completing the challenge at the ACME provider. In some cases (firewalls, etc) this internal challenge verification might not be possible to complete. + +If internal challenge validation needs to travel through an HTTP proxy, see [HTTP client defaults](#http-client-defaults). + +To completely disable `acme-client`s internal challenge verification, enable `skipChallengeVerification`: + +```js +await client.auto({ + ..., + skipChallengeVerification: true +}); +``` + + +## API + +For more fine-grained control you can interact with the ACME API using the methods documented below. + +* __Documentation: [docs/client.md](docs/client.md)__ +* __Full example: [examples/api.js](examples/api.js)__ + +```js +const account = await client.createAccount({ + termsOfServiceAgreed: true, + contact: ['mailto:test@example.com'] +}); + +const order = await client.createOrder({ + identifiers: [ + { type: 'dns', value: 'example.com' }, + { type: 'dns', value: '*.example.com' } + ] +}); +``` + + +## HTTP client defaults + +This module uses [axios](https://github.com/axios/axios) when communicating with the ACME HTTP API, and exposes the client instance through `.axios`. + +For example, should you need to change the default axios configuration to route requests through an HTTP proxy, this can be achieved as follows: + +```js +const acme = require('acme-client'); + +acme.axios.defaults.proxy = { + host: '127.0.0.1', + port: 9000 +}; +``` + +A complete list of axios options and documentation can be found at: + +* [https://github.com/axios/axios#request-config](https://github.com/axios/axios#request-config) +* [https://github.com/axios/axios#custom-instance-defaults](https://github.com/axios/axios#custom-instance-defaults) + + +## Debugging + +To get a better grasp of what `acme-client` is doing behind the scenes, you can either pass it a logger function, or enable debugging through an environment variable. + +Setting a logger function may for example be useful for passing messages on to another logging system, or just dumping them to the console. + +```js +acme.setLogger((message) => { + console.log(message); +}); +``` + +Debugging to the console can also be enabled through [debug](https://www.npmjs.com/package/debug) by setting an environment variable. + +```bash +DEBUG=acme-client node index.js +``` + + +## License + +[MIT](LICENSE) diff --git a/packages/core/acme-client/docs/client.md b/packages/core/acme-client/docs/client.md new file mode 100644 index 00000000..65dc325a --- /dev/null +++ b/packages/core/acme-client/docs/client.md @@ -0,0 +1,518 @@ +## Classes + +
+
AcmeClient
+

AcmeClient

+
+
+ +## Objects + +
+
Client : object
+

ACME client

+
+
+ + + +## AcmeClient +AcmeClient + +**Kind**: global class + +* [AcmeClient](#AcmeClient) + * [new AcmeClient(opts)](#new_AcmeClient_new) + * [.getTermsOfServiceUrl()](#AcmeClient+getTermsOfServiceUrl) ⇒ Promise.<(string\|null)> + * [.getAccountUrl()](#AcmeClient+getAccountUrl) ⇒ string + * [.createAccount([data])](#AcmeClient+createAccount) ⇒ Promise.<object> + * [.updateAccount([data])](#AcmeClient+updateAccount) ⇒ Promise.<object> + * [.updateAccountKey(newAccountKey, [data])](#AcmeClient+updateAccountKey) ⇒ Promise.<object> + * [.createOrder(data)](#AcmeClient+createOrder) ⇒ Promise.<object> + * [.getOrder(order)](#AcmeClient+getOrder) ⇒ Promise.<object> + * [.finalizeOrder(order, csr)](#AcmeClient+finalizeOrder) ⇒ Promise.<object> + * [.getAuthorizations(order)](#AcmeClient+getAuthorizations) ⇒ Promise.<Array.<object>> + * [.deactivateAuthorization(authz)](#AcmeClient+deactivateAuthorization) ⇒ Promise.<object> + * [.getChallengeKeyAuthorization(challenge)](#AcmeClient+getChallengeKeyAuthorization) ⇒ Promise.<string> + * [.verifyChallenge(authz, challenge)](#AcmeClient+verifyChallenge) ⇒ Promise + * [.completeChallenge(challenge)](#AcmeClient+completeChallenge) ⇒ Promise.<object> + * [.waitForValidStatus(item)](#AcmeClient+waitForValidStatus) ⇒ Promise.<object> + * [.getCertificate(order, [preferredChain])](#AcmeClient+getCertificate) ⇒ Promise.<string> + * [.revokeCertificate(cert, [data])](#AcmeClient+revokeCertificate) ⇒ Promise + * [.auto(opts)](#AcmeClient+auto) ⇒ Promise.<string> + + + +### new AcmeClient(opts) + +| Param | Type | Description | +| --- | --- | --- | +| opts | object | | +| opts.directoryUrl | string | ACME directory URL | +| opts.accountKey | buffer \| string | PEM encoded account private key | +| [opts.accountUrl] | string | Account URL, default: `null` | +| [opts.externalAccountBinding] | object | | +| [opts.externalAccountBinding.kid] | string | External account binding KID | +| [opts.externalAccountBinding.hmacKey] | string | External account binding HMAC key | +| [opts.backoffAttempts] | number | Maximum number of backoff attempts, default: `10` | +| [opts.backoffMin] | number | Minimum backoff attempt delay in milliseconds, default: `5000` | +| [opts.backoffMax] | number | Maximum backoff attempt delay in milliseconds, default: `30000` | + +**Example** +Create ACME client instance +```js +const client = new acme.Client({ + directoryUrl: acme.directory.letsencrypt.staging, + accountKey: 'Private key goes here' +}); +``` +**Example** +Create ACME client instance +```js +const client = new acme.Client({ + directoryUrl: acme.directory.letsencrypt.staging, + accountKey: 'Private key goes here', + accountUrl: 'Optional account URL goes here', + backoffAttempts: 10, + backoffMin: 5000, + backoffMax: 30000 +}); +``` +**Example** +Create ACME client with external account binding +```js +const client = new acme.Client({ + directoryUrl: 'https://acme-provider.example.com/directory-url', + accountKey: 'Private key goes here', + externalAccountBinding: { + kid: 'YOUR-EAB-KID', + hmacKey: 'YOUR-EAB-HMAC-KEY' + } +}); +``` + + +### acmeClient.getTermsOfServiceUrl() ⇒ Promise.<(string\|null)> +Get Terms of Service URL if available + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<(string\|null)> - ToS URL +**Example** +Get Terms of Service URL +```js +const termsOfService = client.getTermsOfServiceUrl(); + +if (!termsOfService) { + // CA did not provide Terms of Service +} +``` + + +### acmeClient.getAccountUrl() ⇒ string +Get current account URL + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: string - Account URL +**Throws**: + +- Error No account URL found + +**Example** +Get current account URL +```js +try { + const accountUrl = client.getAccountUrl(); +} +catch (e) { + // No account URL exists, need to create account first +} +``` + + +### acmeClient.createAccount([data]) ⇒ Promise.<object> +Create a new account + +https://tools.ietf.org/html/rfc8555#section-7.3 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<object> - Account + +| Param | Type | Description | +| --- | --- | --- | +| [data] | object | Request data | + +**Example** +Create a new account +```js +const account = await client.createAccount({ + termsOfServiceAgreed: true +}); +``` +**Example** +Create a new account with contact info +```js +const account = await client.createAccount({ + termsOfServiceAgreed: true, + contact: ['mailto:test@example.com'] +}); +``` + + +### acmeClient.updateAccount([data]) ⇒ Promise.<object> +Update existing account + +https://tools.ietf.org/html/rfc8555#section-7.3.2 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<object> - Account + +| Param | Type | Description | +| --- | --- | --- | +| [data] | object | Request data | + +**Example** +Update existing account +```js +const account = await client.updateAccount({ + contact: ['mailto:foo@example.com'] +}); +``` + + +### acmeClient.updateAccountKey(newAccountKey, [data]) ⇒ Promise.<object> +Update account private key + +https://tools.ietf.org/html/rfc8555#section-7.3.5 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<object> - Account + +| Param | Type | Description | +| --- | --- | --- | +| newAccountKey | buffer \| string | New PEM encoded private key | +| [data] | object | Additional request data | + +**Example** +Update account private key +```js +const newAccountKey = 'New private key goes here'; +const result = await client.updateAccountKey(newAccountKey); +``` + + +### acmeClient.createOrder(data) ⇒ Promise.<object> +Create a new order + +https://tools.ietf.org/html/rfc8555#section-7.4 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<object> - Order + +| Param | Type | Description | +| --- | --- | --- | +| data | object | Request data | + +**Example** +Create a new order +```js +const order = await client.createOrder({ + identifiers: [ + { type: 'dns', value: 'example.com' }, + { type: 'dns', value: 'test.example.com' } + ] +}); +``` + + +### acmeClient.getOrder(order) ⇒ Promise.<object> +Refresh order object from CA + +https://tools.ietf.org/html/rfc8555#section-7.4 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<object> - Order + +| Param | Type | Description | +| --- | --- | --- | +| order | object | Order object | + +**Example** +```js +const order = { ... }; // Previously created order object +const result = await client.getOrder(order); +``` + + +### acmeClient.finalizeOrder(order, csr) ⇒ Promise.<object> +Finalize order + +https://tools.ietf.org/html/rfc8555#section-7.4 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<object> - Order + +| Param | Type | Description | +| --- | --- | --- | +| order | object | Order object | +| csr | buffer \| string | PEM encoded Certificate Signing Request | + +**Example** +Finalize order +```js +const order = { ... }; // Previously created order object +const csr = { ... }; // Previously created Certificate Signing Request +const result = await client.finalizeOrder(order, csr); +``` + + +### acmeClient.getAuthorizations(order) ⇒ Promise.<Array.<object>> +Get identifier authorizations from order + +https://tools.ietf.org/html/rfc8555#section-7.5 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<Array.<object>> - Authorizations + +| Param | Type | Description | +| --- | --- | --- | +| order | object | Order | + +**Example** +Get identifier authorizations +```js +const order = { ... }; // Previously created order object +const authorizations = await client.getAuthorizations(order); + +authorizations.forEach((authz) => { + const { challenges } = authz; +}); +``` + + +### acmeClient.deactivateAuthorization(authz) ⇒ Promise.<object> +Deactivate identifier authorization + +https://tools.ietf.org/html/rfc8555#section-7.5.2 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<object> - Authorization + +| Param | Type | Description | +| --- | --- | --- | +| authz | object | Identifier authorization | + +**Example** +Deactivate identifier authorization +```js +const authz = { ... }; // Identifier authorization resolved from previously created order +const result = await client.deactivateAuthorization(authz); +``` + + +### acmeClient.getChallengeKeyAuthorization(challenge) ⇒ Promise.<string> +Get key authorization for ACME challenge + +https://tools.ietf.org/html/rfc8555#section-8.1 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<string> - Key authorization + +| Param | Type | Description | +| --- | --- | --- | +| challenge | object | Challenge object returned by API | + +**Example** +Get challenge key authorization +```js +const challenge = { ... }; // Challenge from previously resolved identifier authorization +const key = await client.getChallengeKeyAuthorization(challenge); + +// Write key somewhere to satisfy challenge +``` + + +### acmeClient.verifyChallenge(authz, challenge) ⇒ Promise +Verify that ACME challenge is satisfied + +**Kind**: instance method of [AcmeClient](#AcmeClient) + +| Param | Type | Description | +| --- | --- | --- | +| authz | object | Identifier authorization | +| challenge | object | Authorization challenge | + +**Example** +Verify satisfied ACME challenge +```js +const authz = { ... }; // Identifier authorization +const challenge = { ... }; // Satisfied challenge +await client.verifyChallenge(authz, challenge); +``` + + +### acmeClient.completeChallenge(challenge) ⇒ Promise.<object> +Notify CA that challenge has been completed + +https://tools.ietf.org/html/rfc8555#section-7.5.1 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<object> - Challenge + +| Param | Type | Description | +| --- | --- | --- | +| challenge | object | Challenge object returned by API | + +**Example** +Notify CA that challenge has been completed +```js +const challenge = { ... }; // Satisfied challenge +const result = await client.completeChallenge(challenge); +``` + + +### acmeClient.waitForValidStatus(item) ⇒ Promise.<object> +Wait for ACME provider to verify status on a order, authorization or challenge + +https://tools.ietf.org/html/rfc8555#section-7.5.1 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<object> - Valid order, authorization or challenge + +| Param | Type | Description | +| --- | --- | --- | +| item | object | An order, authorization or challenge object | + +**Example** +Wait for valid challenge status +```js +const challenge = { ... }; +await client.waitForValidStatus(challenge); +``` +**Example** +Wait for valid authoriation status +```js +const authz = { ... }; +await client.waitForValidStatus(authz); +``` +**Example** +Wait for valid order status +```js +const order = { ... }; +await client.waitForValidStatus(order); +``` + + +### acmeClient.getCertificate(order, [preferredChain]) ⇒ Promise.<string> +Get certificate from ACME order + +https://tools.ietf.org/html/rfc8555#section-7.4.2 + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<string> - Certificate + +| Param | Type | Default | Description | +| --- | --- | --- | --- | +| order | object | | Order object | +| [preferredChain] | string | null | Indicate which certificate chain is preferred if a CA offers multiple, by exact issuer common name, default: `null` | + +**Example** +Get certificate +```js +const order = { ... }; // Previously created order +const certificate = await client.getCertificate(order); +``` +**Example** +Get certificate with preferred chain +```js +const order = { ... }; // Previously created order +const certificate = await client.getCertificate(order, 'DST Root CA X3'); +``` + + +### acmeClient.revokeCertificate(cert, [data]) ⇒ Promise +Revoke certificate + +https://tools.ietf.org/html/rfc8555#section-7.6 + +**Kind**: instance method of [AcmeClient](#AcmeClient) + +| Param | Type | Description | +| --- | --- | --- | +| cert | buffer \| string | PEM encoded certificate | +| [data] | object | Additional request data | + +**Example** +Revoke certificate +```js +const certificate = { ... }; // Previously created certificate +const result = await client.revokeCertificate(certificate); +``` +**Example** +Revoke certificate with reason +```js +const certificate = { ... }; // Previously created certificate +const result = await client.revokeCertificate(certificate, { + reason: 4 +}); +``` + + +### acmeClient.auto(opts) ⇒ Promise.<string> +Auto mode + +**Kind**: instance method of [AcmeClient](#AcmeClient) +**Returns**: Promise.<string> - Certificate + +| Param | Type | Description | +| --- | --- | --- | +| opts | object | | +| opts.csr | buffer \| string | Certificate Signing Request | +| opts.challengeCreateFn | function | Function returning Promise triggered before completing ACME challenge | +| opts.challengeRemoveFn | function | Function returning Promise triggered after completing ACME challenge | +| [opts.email] | string | Account email address | +| [opts.termsOfServiceAgreed] | boolean | Agree to Terms of Service, default: `false` | +| [opts.skipChallengeVerification] | boolean | Skip internal challenge verification before notifying ACME provider, default: `false` | +| [opts.challengePriority] | Array.<string> | Array defining challenge type priority, default: `['http-01', 'dns-01']` | +| [opts.preferredChain] | string | Indicate which certificate chain is preferred if a CA offers multiple, by exact issuer common name, default: `null` | + +**Example** +Order a certificate using auto mode +```js +const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + commonName: 'test.example.com' +}); + +const certificate = await client.auto({ + csr: certificateRequest, + email: 'test@example.com', + termsOfServiceAgreed: true, + challengeCreateFn: async (authz, challenge, keyAuthorization) => { + // Satisfy challenge here + }, + challengeRemoveFn: async (authz, challenge, keyAuthorization) => { + // Clean up challenge here + } +}); +``` +**Example** +Order a certificate using auto mode with preferred chain +```js +const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + commonName: 'test.example.com' +}); + +const certificate = await client.auto({ + csr: certificateRequest, + email: 'test@example.com', + termsOfServiceAgreed: true, + preferredChain: 'DST Root CA X3', + challengeCreateFn: async () => {}, + challengeRemoveFn: async () => {} +}); +``` + + +## Client : object +ACME client + +**Kind**: global namespace diff --git a/packages/core/acme-client/docs/crypto.md b/packages/core/acme-client/docs/crypto.md new file mode 100644 index 00000000..1391263c --- /dev/null +++ b/packages/core/acme-client/docs/crypto.md @@ -0,0 +1,267 @@ +## Objects + +
+
crypto : object
+

Native Node.js crypto interface

+
+
+ +## Functions + +
+
createPrivateRsaKey([modulusLength]) ⇒ Promise.<buffer>
+

Generate a private RSA key

+
+
createPrivateKey()
+

Alias of createPrivateRsaKey()

+
+
createPrivateEcdsaKey([namedCurve]) ⇒ Promise.<buffer>
+

Generate a private ECDSA key

+
+
getPublicKey(keyPem) ⇒ buffer
+

Get a public key derived from a RSA or ECDSA key

+
+
getJwk(keyPem) ⇒ object
+

Get a JSON Web Key derived from a RSA or ECDSA key

+

https://datatracker.ietf.org/doc/html/rfc7517

+
+
splitPemChain(chainPem) ⇒ array
+

Split chain of PEM encoded objects from string into array

+
+
getPemBodyAsB64u(pem) ⇒ string
+

Parse body of PEM encoded object and return a Base64URL string +If multiple objects are chained, the first body will be returned

+
+
readCsrDomains(csrPem) ⇒ object
+

Read domains from a Certificate Signing Request

+
+
readCertificateInfo(certPem) ⇒ object
+

Read information from a certificate +If multiple certificates are chained, the first will be read

+
+
createCsr(data, [keyPem]) ⇒ Promise.<Array.<buffer>>
+

Create a Certificate Signing Request

+
+
+ + + +## crypto : object +Native Node.js crypto interface + +**Kind**: global namespace + + +## createPrivateRsaKey([modulusLength]) ⇒ Promise.<buffer> +Generate a private RSA key + +**Kind**: global function +**Returns**: Promise.<buffer> - PEM encoded private RSA key + +| Param | Type | Default | Description | +| --- | --- | --- | --- | +| [modulusLength] | number | 2048 | Size of the keys modulus in bits, default: `2048` | + +**Example** +Generate private RSA key +```js +const privateKey = await acme.crypto.createPrivateRsaKey(); +``` +**Example** +Private RSA key with modulus size 4096 +```js +const privateKey = await acme.crypto.createPrivateRsaKey(4096); +``` + + +## createPrivateKey() +Alias of `createPrivateRsaKey()` + +**Kind**: global function + + +## createPrivateEcdsaKey([namedCurve]) ⇒ Promise.<buffer> +Generate a private ECDSA key + +**Kind**: global function +**Returns**: Promise.<buffer> - PEM encoded private ECDSA key + +| Param | Type | Description | +| --- | --- | --- | +| [namedCurve] | string | ECDSA curve name (P-256, P-384 or P-521), default `P-256` | + +**Example** +Generate private ECDSA key +```js +const privateKey = await acme.crypto.createPrivateEcdsaKey(); +``` +**Example** +Private ECDSA key using P-384 curve +```js +const privateKey = await acme.crypto.createPrivateEcdsaKey('P-384'); +``` + + +## getPublicKey(keyPem) ⇒ buffer +Get a public key derived from a RSA or ECDSA key + +**Kind**: global function +**Returns**: buffer - PEM encoded public key + +| Param | Type | Description | +| --- | --- | --- | +| keyPem | buffer \| string | PEM encoded private or public key | + +**Example** +Get public key +```js +const publicKey = acme.crypto.getPublicKey(privateKey); +``` + + +## getJwk(keyPem) ⇒ object +Get a JSON Web Key derived from a RSA or ECDSA key + +https://datatracker.ietf.org/doc/html/rfc7517 + +**Kind**: global function +**Returns**: object - JSON Web Key + +| Param | Type | Description | +| --- | --- | --- | +| keyPem | buffer \| string | PEM encoded private or public key | + +**Example** +Get JWK +```js +const jwk = acme.crypto.getJwk(privateKey); +``` + + +## splitPemChain(chainPem) ⇒ array +Split chain of PEM encoded objects from string into array + +**Kind**: global function +**Returns**: array - Array of PEM objects including headers + +| Param | Type | Description | +| --- | --- | --- | +| chainPem | buffer \| string | PEM encoded object chain | + + + +## getPemBodyAsB64u(pem) ⇒ string +Parse body of PEM encoded object and return a Base64URL string +If multiple objects are chained, the first body will be returned + +**Kind**: global function +**Returns**: string - Base64URL-encoded body + +| Param | Type | Description | +| --- | --- | --- | +| pem | buffer \| string | PEM encoded chain or object | + + + +## readCsrDomains(csrPem) ⇒ object +Read domains from a Certificate Signing Request + +**Kind**: global function +**Returns**: object - {commonName, altNames} + +| Param | Type | Description | +| --- | --- | --- | +| csrPem | buffer \| string | PEM encoded Certificate Signing Request | + +**Example** +Read Certificate Signing Request domains +```js +const { commonName, altNames } = acme.crypto.readCsrDomains(certificateRequest); + +console.log(`Common name: ${commonName}`); +console.log(`Alt names: ${altNames.join(', ')}`); +``` + + +## readCertificateInfo(certPem) ⇒ object +Read information from a certificate +If multiple certificates are chained, the first will be read + +**Kind**: global function +**Returns**: object - Certificate info + +| Param | Type | Description | +| --- | --- | --- | +| certPem | buffer \| string | PEM encoded certificate or chain | + +**Example** +Read certificate information +```js +const info = acme.crypto.readCertificateInfo(certificate); +const { commonName, altNames } = info.domains; + +console.log(`Not after: ${info.notAfter}`); +console.log(`Not before: ${info.notBefore}`); + +console.log(`Common name: ${commonName}`); +console.log(`Alt names: ${altNames.join(', ')}`); +``` + + +## createCsr(data, [keyPem]) ⇒ Promise.<Array.<buffer>> +Create a Certificate Signing Request + +**Kind**: global function +**Returns**: Promise.<Array.<buffer>> - [privateKey, certificateSigningRequest] + +| Param | Type | Description | +| --- | --- | --- | +| data | object | | +| [data.keySize] | number | Size of newly created RSA private key modulus in bits, default: `2048` | +| [data.commonName] | string | FQDN of your server | +| [data.altNames] | array | SAN (Subject Alternative Names), default: `[]` | +| [data.country] | string | 2 letter country code | +| [data.state] | string | State or province | +| [data.locality] | string | City | +| [data.organization] | string | Organization name | +| [data.organizationUnit] | string | Organizational unit name | +| [data.emailAddress] | string | Email address | +| [keyPem] | string | PEM encoded CSR private key | + +**Example** +Create a Certificate Signing Request +```js +const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + commonName: 'test.example.com' +}); +``` +**Example** +Certificate Signing Request with both common and alternative names +```js +const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + keySize: 4096, + commonName: 'test.example.com', + altNames: ['foo.example.com', 'bar.example.com'] +}); +``` +**Example** +Certificate Signing Request with additional information +```js +const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + commonName: 'test.example.com', + country: 'US', + state: 'California', + locality: 'Los Angeles', + organization: 'The Company Inc.', + organizationUnit: 'IT Department', + emailAddress: 'contact@example.com' +}); +``` +**Example** +Certificate Signing Request with ECDSA private key +```js +const certificateKey = await acme.crypto.createPrivateEcdsaKey(); + +const [, certificateRequest] = await acme.crypto.createCsr({ + commonName: 'test.example.com' +}, certificateKey); diff --git a/packages/core/acme-client/docs/forge.md b/packages/core/acme-client/docs/forge.md new file mode 100644 index 00000000..2d7601fd --- /dev/null +++ b/packages/core/acme-client/docs/forge.md @@ -0,0 +1,257 @@ +## Objects + +
+
forge : object
+

Legacy node-forge crypto interface

+

DEPRECATION WARNING: This crypto interface is deprecated and will be removed from acme-client in a future +major release. Please migrate to the new acme.crypto interface at your earliest convenience.

+
+
+ +## Functions + +
+
createPrivateKey([size]) ⇒ Promise.<buffer>
+

Generate a private RSA key

+
+
createPublicKey(key) ⇒ Promise.<buffer>
+

Create public key from a private RSA key

+
+
getPemBody(str) ⇒ string
+

Parse body of PEM encoded object from buffer or string +If multiple objects are chained, the first body will be returned

+
+
splitPemChain(str) ⇒ Array.<string>
+

Split chain of PEM encoded objects from buffer or string into array

+
+
getModulus(input) ⇒ Promise.<buffer>
+

Get modulus

+
+
getPublicExponent(input) ⇒ Promise.<buffer>
+

Get public exponent

+
+
readCsrDomains(csr) ⇒ Promise.<object>
+

Read domains from a Certificate Signing Request

+
+
readCertificateInfo(cert) ⇒ Promise.<object>
+

Read information from a certificate

+
+
createCsr(data, [key]) ⇒ Promise.<Array.<buffer>>
+

Create a Certificate Signing Request

+
+
+ + + +## forge : object +Legacy node-forge crypto interface + +DEPRECATION WARNING: This crypto interface is deprecated and will be removed from acme-client in a future +major release. Please migrate to the new `acme.crypto` interface at your earliest convenience. + +**Kind**: global namespace + + +## createPrivateKey([size]) ⇒ Promise.<buffer> +Generate a private RSA key + +**Kind**: global function +**Returns**: Promise.<buffer> - PEM encoded private RSA key + +| Param | Type | Default | Description | +| --- | --- | --- | --- | +| [size] | number | 2048 | Size of the key, default: `2048` | + +**Example** +Generate private RSA key +```js +const privateKey = await acme.forge.createPrivateKey(); +``` +**Example** +Private RSA key with defined size +```js +const privateKey = await acme.forge.createPrivateKey(4096); +``` + + +## createPublicKey(key) ⇒ Promise.<buffer> +Create public key from a private RSA key + +**Kind**: global function +**Returns**: Promise.<buffer> - PEM encoded public RSA key + +| Param | Type | Description | +| --- | --- | --- | +| key | buffer \| string | PEM encoded private RSA key | + +**Example** +Create public key +```js +const publicKey = await acme.forge.createPublicKey(privateKey); +``` + + +## getPemBody(str) ⇒ string +Parse body of PEM encoded object from buffer or string +If multiple objects are chained, the first body will be returned + +**Kind**: global function +**Returns**: string - PEM body + +| Param | Type | Description | +| --- | --- | --- | +| str | buffer \| string | PEM encoded buffer or string | + + + +## splitPemChain(str) ⇒ Array.<string> +Split chain of PEM encoded objects from buffer or string into array + +**Kind**: global function +**Returns**: Array.<string> - Array of PEM bodies + +| Param | Type | Description | +| --- | --- | --- | +| str | buffer \| string | PEM encoded buffer or string | + + + +## getModulus(input) ⇒ Promise.<buffer> +Get modulus + +**Kind**: global function +**Returns**: Promise.<buffer> - Modulus + +| Param | Type | Description | +| --- | --- | --- | +| input | buffer \| string | PEM encoded private key, certificate or CSR | + +**Example** +Get modulus +```js +const m1 = await acme.forge.getModulus(privateKey); +const m2 = await acme.forge.getModulus(certificate); +const m3 = await acme.forge.getModulus(certificateRequest); +``` + + +## getPublicExponent(input) ⇒ Promise.<buffer> +Get public exponent + +**Kind**: global function +**Returns**: Promise.<buffer> - Exponent + +| Param | Type | Description | +| --- | --- | --- | +| input | buffer \| string | PEM encoded private key, certificate or CSR | + +**Example** +Get public exponent +```js +const e1 = await acme.forge.getPublicExponent(privateKey); +const e2 = await acme.forge.getPublicExponent(certificate); +const e3 = await acme.forge.getPublicExponent(certificateRequest); +``` + + +## readCsrDomains(csr) ⇒ Promise.<object> +Read domains from a Certificate Signing Request + +**Kind**: global function +**Returns**: Promise.<object> - {commonName, altNames} + +| Param | Type | Description | +| --- | --- | --- | +| csr | buffer \| string | PEM encoded Certificate Signing Request | + +**Example** +Read Certificate Signing Request domains +```js +const { commonName, altNames } = await acme.forge.readCsrDomains(certificateRequest); + +console.log(`Common name: ${commonName}`); +console.log(`Alt names: ${altNames.join(', ')}`); +``` + + +## readCertificateInfo(cert) ⇒ Promise.<object> +Read information from a certificate + +**Kind**: global function +**Returns**: Promise.<object> - Certificate info + +| Param | Type | Description | +| --- | --- | --- | +| cert | buffer \| string | PEM encoded certificate | + +**Example** +Read certificate information +```js +const info = await acme.forge.readCertificateInfo(certificate); +const { commonName, altNames } = info.domains; + +console.log(`Not after: ${info.notAfter}`); +console.log(`Not before: ${info.notBefore}`); + +console.log(`Common name: ${commonName}`); +console.log(`Alt names: ${altNames.join(', ')}`); +``` + + +## createCsr(data, [key]) ⇒ Promise.<Array.<buffer>> +Create a Certificate Signing Request + +**Kind**: global function +**Returns**: Promise.<Array.<buffer>> - [privateKey, certificateSigningRequest] + +| Param | Type | Description | +| --- | --- | --- | +| data | object | | +| [data.keySize] | number | Size of newly created private key, default: `2048` | +| [data.commonName] | string | | +| [data.altNames] | array | default: `[]` | +| [data.country] | string | | +| [data.state] | string | | +| [data.locality] | string | | +| [data.organization] | string | | +| [data.organizationUnit] | string | | +| [data.emailAddress] | string | | +| [key] | buffer \| string | CSR private key | + +**Example** +Create a Certificate Signing Request +```js +const [certificateKey, certificateRequest] = await acme.forge.createCsr({ + commonName: 'test.example.com' +}); +``` +**Example** +Certificate Signing Request with both common and alternative names +```js +const [certificateKey, certificateRequest] = await acme.forge.createCsr({ + keySize: 4096, + commonName: 'test.example.com', + altNames: ['foo.example.com', 'bar.example.com'] +}); +``` +**Example** +Certificate Signing Request with additional information +```js +const [certificateKey, certificateRequest] = await acme.forge.createCsr({ + commonName: 'test.example.com', + country: 'US', + state: 'California', + locality: 'Los Angeles', + organization: 'The Company Inc.', + organizationUnit: 'IT Department', + emailAddress: 'contact@example.com' +}); +``` +**Example** +Certificate Signing Request with predefined private key +```js +const certificateKey = await acme.forge.createPrivateKey(); + +const [, certificateRequest] = await acme.forge.createCsr({ + commonName: 'test.example.com' +}, certificateKey); diff --git a/packages/core/acme-client/docs/upgrade-v5.md b/packages/core/acme-client/docs/upgrade-v5.md new file mode 100644 index 00000000..a9156244 --- /dev/null +++ b/packages/core/acme-client/docs/upgrade-v5.md @@ -0,0 +1,98 @@ +# Upgrading to v5 of `acme-client` + +This document outlines the breaking changes introduced in v5 of `acme-client`, why they were introduced and what you should look out for when upgrading your application. + +First off this release drops support for Node LTS v10, v12 and v14, and the reason for that is a new native crypto interface - more on that below. Since Node v14 is still currently in maintenance mode, `acme-client` v4 will continue to receive security updates and bugfixes until (at least) Node v14 reaches its end-of-line. + + +## New native crypto interface + +A new crypto interface has been introduced with v5, which you can find under `acme.crypto`. It uses native Node.js cryptography APIs to generate private keys, JSON Web Keys and signatures, and finally enables support for ECC/ECDSA (P-256, P384 and P521), both for account private keys and certificates. The [jsrsasign](https://www.npmjs.com/package/jsrsasign) module is used to handle generation and parsing of Certificate Signing Requests. + +Full documentation of `acme.crypto` can be [found here](crypto.md). + +Since the release of `acme-client` v1.0.0 the crypto interface API has remained mostly unaltered. Back then an OpenSSL CLI wrapper was used to generate keys, and very much has changed since. This has naturally resulted in a buildup of technical debt and slight API inconsistencies over time. The introduction of a new interface was a good opportunity to finally clean up these APIs. + +Below you will find a table summarizing the current `acme.forge` methods, and their new `acme.crypto` replacements. A summary of the changes for each method, including examples on how to migrate, can be found following the table. + +*Note: The now deprecated `acme.forge` interface is still available for use in v5, and will not be removed until a future major version, most likely v6. Should you not wish to change to the new interface right away, the following breaking changes will not immediately affect you.* + +- :green_circle: = API functionality unchanged between `acme.forge` and `acme.crypto` +- :orange_circle: = Slight API changes, like depromising or renaming, action may be required +- :red_circle: = Breaking API changes or removal, action required if using these methods + +| Deprecated `.forge` API | New `.crypto` API | State | +| ----------------------------- | ----------------------------- | --------------------- | +| `await createPrivateKey()` | `await createPrivateKey()` | :green_circle: | +| `await createPublicKey()` | `getPublicKey()` | :orange_circle: (1) | +| `getPemBody()` | `getPemBodyAsB64u()` | :red_circle: (2) | +| `splitPemChain()` | `splitPemChain()` | :green_circle: | +| `await getModulus()` | `getJwk()` | :red_circle: (3) | +| `await getPublicExponent()` | `getJwk()` | :red_circle: (3) | +| `await readCsrDomains()` | `readCsrDomains()` | :orange_circle: (4) | +| `await readCertificateInfo()` | `readCertificateInfo()` | :orange_circle: (4) | +| `await createCsr()` | `await createCsr()` | :green_circle: | + + +### 1. `createPublicKey` renamed and depromised + +* The method `createPublicKey()` has been renamed to `getPublicKey()` +* No longer returns a promise, but the resulting public key directly +* This is non-breaking if called with `await`, since `await` does not require its operand to be a promise +* :orange_circle: **This is a breaking change if used with `.then()` or `.catch()`** + +```js +// Before +const publicKey = await acme.forge.createPublicKey(privateKey); + +// After +const publicKey = acme.crypto.getPublicKey(privateKey); +``` + + +### 2. `getPemBody` renamed, now returns Base64URL + +* Method `getPemBody()` has been renamed to `getPemBodyAsB64u()` +* Instead of a Base64-encoded PEM body, now returns a Base64URL-encoded PEM body +* :red_circle: **This is a breaking change** + +```js +// Before +const body = acme.forge.getPemBody(pem); + +// After +const body = acme.crypto.getPemBodyAsB64u(pem); +``` + + +### 3. `getModulus` and `getPublicExponent` merged into `getJwk` + +* Methods `getModulus()` and `getPublicExponent()` have been removed +* Replaced by new method `getJwk()` +* :red_circle: **This is a breaking change** + +```js +// Before +const mod = await acme.forge.getModulus(key); +const exp = await acme.forge.getPublicExponent(key); + +// After +const { e, n } = acme.crypto.getJwk(key); +``` + + +### 4. `readCsrDomains` and `readCertificateInfo` depromised + +* Methods `readCsrDomains()` and `readCertificateInfo()` no longer return promises, but their resulting payloads directly +* This is non-breaking if called with `await`, since `await` does not require its operand to be a promise +* :orange_circle: **This is a breaking change if used with `.then()` or `.catch()`** + +```js +// Before +const domains = await acme.forge.readCsrDomains(csr); +const info = await acme.forge.readCertificateInfo(certificate); + +// After +const domains = acme.crypto.readCsrDomains(csr); +const info = acme.crypto.readCertificateInfo(certificate); +``` diff --git a/packages/core/acme-client/examples/api.js b/packages/core/acme-client/examples/api.js new file mode 100644 index 00000000..998201e6 --- /dev/null +++ b/packages/core/acme-client/examples/api.js @@ -0,0 +1,153 @@ +/** + * Example of acme.Client API + */ + +const acme = require('./../'); + + +function log(m) { + process.stdout.write(`${m}\n`); +} + + +/** + * Function used to satisfy an ACME challenge + * + * @param {object} authz Authorization object + * @param {object} challenge Selected challenge + * @param {string} keyAuthorization Authorization key + * @returns {Promise} + */ + +async function challengeCreateFn(authz, challenge, keyAuthorization) { + /* Do something here */ + log(JSON.stringify(authz)); + log(JSON.stringify(challenge)); + log(keyAuthorization); +} + + +/** + * Function used to remove an ACME challenge response + * + * @param {object} authz Authorization object + * @param {object} challenge Selected challenge + * @returns {Promise} + */ + +async function challengeRemoveFn(authz, challenge, keyAuthorization) { + /* Do something here */ + log(JSON.stringify(authz)); + log(JSON.stringify(challenge)); + log(keyAuthorization); +} + + +/** + * Main + */ + +module.exports = async function() { + /* Init client */ + const client = new acme.Client({ + directoryUrl: acme.directory.letsencrypt.staging, + accountKey: await acme.crypto.createPrivateKey() + }); + + /* Register account */ + await client.createAccount({ + termsOfServiceAgreed: true, + contact: ['mailto:test@example.com'] + }); + + /* Place new order */ + const order = await client.createOrder({ + identifiers: [ + { type: 'dns', value: 'example.com' }, + { type: 'dns', value: '*.example.com' } + ] + }); + + /** + * authorizations / client.getAuthorizations(order); + * An array with one item per DNS name in the certificate order. + * All items require at least one satisfied challenge before order can be completed. + */ + + const authorizations = await client.getAuthorizations(order); + + const promises = authorizations.map(async (authz) => { + let challengeCompleted = false; + + try { + /** + * challenges / authz.challenges + * An array of all available challenge types for a single DNS name. + * One of these challenges needs to be satisfied. + */ + + const { challenges } = authz; + + /* Just select any challenge */ + const challenge = challenges.pop(); + const keyAuthorization = await client.getChallengeKeyAuthorization(challenge); + + try { + /* Satisfy challenge */ + await challengeCreateFn(authz, challenge, keyAuthorization); + + /* Verify that challenge is satisfied */ + await client.verifyChallenge(authz, challenge); + + /* Notify ACME provider that challenge is satisfied */ + await client.completeChallenge(challenge); + challengeCompleted = true; + + /* Wait for ACME provider to respond with valid status */ + await client.waitForValidStatus(challenge); + } + finally { + /* Clean up challenge response */ + try { + await challengeRemoveFn(authz, challenge, keyAuthorization); + } + catch (e) { + /** + * Catch errors thrown by challengeRemoveFn() so the order can + * be finalized, even though something went wrong during cleanup + */ + } + } + } + catch (e) { + /* Deactivate pending authz when unable to complete challenge */ + if (!challengeCompleted) { + try { + await client.deactivateAuthorization(authz); + } + catch (f) { + /* Catch and suppress deactivateAuthorization() errors */ + } + } + + throw e; + } + }); + + /* Wait for challenges to complete */ + await Promise.all(promises); + + /* Finalize order */ + const [key, csr] = await acme.crypto.createCsr({ + commonName: '*.example.com', + altNames: ['example.com'] + }); + + const finalized = await client.finalizeOrder(order, csr); + const cert = await client.getCertificate(finalized); + + /* Done */ + log(`CSR:\n${csr.toString()}`); + log(`Private key:\n${key.toString()}`); + log(`Certificate:\n${cert.toString()}`); +}; diff --git a/packages/core/acme-client/examples/auto.js b/packages/core/acme-client/examples/auto.js new file mode 100644 index 00000000..1495043b --- /dev/null +++ b/packages/core/acme-client/examples/auto.js @@ -0,0 +1,118 @@ +/** + * Example of acme.Client.auto() + */ + +// const fs = require('fs').promises; +const acme = require('./../'); + + +function log(m) { + process.stdout.write(`${m}\n`); +} + + +/** + * Function used to satisfy an ACME challenge + * + * @param {object} authz Authorization object + * @param {object} challenge Selected challenge + * @param {string} keyAuthorization Authorization key + * @returns {Promise} + */ + +async function challengeCreateFn(authz, challenge, keyAuthorization) { + log('Triggered challengeCreateFn()'); + + /* http-01 */ + if (challenge.type === 'http-01') { + const filePath = `/var/www/html/.well-known/acme-challenge/${challenge.token}`; + const fileContents = keyAuthorization; + + log(`Creating challenge response for ${authz.identifier.value} at path: ${filePath}`); + + /* Replace this */ + log(`Would write "${fileContents}" to path "${filePath}"`); + // await fs.writeFile(filePath, fileContents); + } + + /* dns-01 */ + else if (challenge.type === 'dns-01') { + const dnsRecord = `_acme-challenge.${authz.identifier.value}`; + const recordValue = keyAuthorization; + + log(`Creating TXT record for ${authz.identifier.value}: ${dnsRecord}`); + + /* Replace this */ + log(`Would create TXT record "${dnsRecord}" with value "${recordValue}"`); + // await dnsProvider.createRecord(dnsRecord, 'TXT', recordValue); + } +} + + +/** + * Function used to remove an ACME challenge response + * + * @param {object} authz Authorization object + * @param {object} challenge Selected challenge + * @param {string} keyAuthorization Authorization key + * @returns {Promise} + */ + +async function challengeRemoveFn(authz, challenge, keyAuthorization) { + log('Triggered challengeRemoveFn()'); + + /* http-01 */ + if (challenge.type === 'http-01') { + const filePath = `/var/www/html/.well-known/acme-challenge/${challenge.token}`; + + log(`Removing challenge response for ${authz.identifier.value} at path: ${filePath}`); + + /* Replace this */ + log(`Would remove file on path "${filePath}"`); + // await fs.unlink(filePath); + } + + /* dns-01 */ + else if (challenge.type === 'dns-01') { + const dnsRecord = `_acme-challenge.${authz.identifier.value}`; + const recordValue = keyAuthorization; + + log(`Removing TXT record for ${authz.identifier.value}: ${dnsRecord}`); + + /* Replace this */ + log(`Would remove TXT record "${dnsRecord}" with value "${recordValue}"`); + // await dnsProvider.removeRecord(dnsRecord, 'TXT'); + } +} + + +/** + * Main + */ + +module.exports = async function() { + /* Init client */ + const client = new acme.Client({ + directoryUrl: acme.directory.letsencrypt.staging, + accountKey: await acme.crypto.createPrivateKey() + }); + + /* Create CSR */ + const [key, csr] = await acme.crypto.createCsr({ + commonName: 'example.com' + }); + + /* Certificate */ + const cert = await client.auto({ + csr, + email: 'test@example.com', + termsOfServiceAgreed: true, + challengeCreateFn, + challengeRemoveFn + }); + + /* Done */ + log(`CSR:\n${csr.toString()}`); + log(`Private key:\n${key.toString()}`); + log(`Certificate:\n${cert.toString()}`); +}; diff --git a/packages/core/acme-client/package.json b/packages/core/acme-client/package.json new file mode 100644 index 00000000..9f905f5d --- /dev/null +++ b/packages/core/acme-client/package.json @@ -0,0 +1,60 @@ +{ + "name": "acme-client", + "description": "Simple and unopinionated ACME client", + "author": "nmorsman", + "version": "5.0.0", + "main": "src/index.js", + "types": "types", + "license": "MIT", + "homepage": "https://github.com/publishlab/node-acme-client", + "engines": { + "node": ">= 16" + }, + "files": [ + "src", + "types" + ], + "dependencies": { + "axios": "0.27.2", + "debug": "^4.1.1", + "jsrsasign": "^10.5.26", + "node-forge": "^1.3.1" + }, + "devDependencies": { + "@types/node": "^18.6.1", + "chai": "^4.3.6", + "chai-as-promised": "^7.1.1", + "dtslint": "^4.2.1", + "eslint": "^8.11.0", + "eslint-config-airbnb-base": "^15.0.0", + "eslint-plugin-import": "^2.25.4", + "jsdoc-to-markdown": "^7.1.1", + "mocha": "^10.0.0", + "nock": "^13.2.4", + "typescript": "^4.6.2", + "uuid": "^8.3.2" + }, + "scripts": { + "build-docs": "jsdoc2md src/client.js > docs/client.md && jsdoc2md src/crypto/index.js > docs/crypto.md && jsdoc2md src/crypto/forge.js > docs/forge.md", + "lint": "eslint .", + "lint-types": "dtslint types", + "prepublishOnly": "npm run build-docs", + "test": "mocha -t 60000 \"test/setup.js\" \"test/**/*.spec.js\"", + "test-local": "/bin/bash scripts/run-tests.sh" + }, + "repository": { + "type": "git", + "url": "https://github.com/publishlab/node-acme-client" + }, + "keywords": [ + "acme", + "client", + "lets", + "encrypt", + "acmev2", + "boulder" + ], + "bugs": { + "url": "https://github.com/publishlab/node-acme-client/issues" + } +} diff --git a/packages/core/acme-client/scripts/run-tests.sh b/packages/core/acme-client/scripts/run-tests.sh new file mode 100644 index 00000000..b0613ac2 --- /dev/null +++ b/packages/core/acme-client/scripts/run-tests.sh @@ -0,0 +1,56 @@ +#!/bin/bash +# +# Run test suite locally using CircleCI CLI. +# +set -eu + +JOBS=("$@") + +CIRCLECI_CLI_URL="https://github.com/CircleCI-Public/circleci-cli/releases/download/v0.1.16947/circleci-cli_0.1.16947_linux_amd64.tar.gz" +CIRCLECI_CLI_SHASUM="c6f9a3276445c69ae40439acfed07e2c53502216a96bfacc4556e1d862d1019a" +CIRCLECI_CLI_PATH="/tmp/circleci-cli" +CIRCLECI_CLI_BIN="${CIRCLECI_CLI_PATH}/circleci" + +PROJECT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && cd .. && pwd )" +CONFIG_PATH="${PROJECT_DIR}/.circleci/.temp.yml" + +# Run all jobs by default +if [[ ${#JOBS[@]} -eq 0 ]]; then + JOBS=( + "v16" + "v18" + "eab-v16" + "eab-v18" + ) +fi + +# Download CircleCI CLI +if [[ ! -f "${CIRCLECI_CLI_BIN}" ]]; then + echo "[-] Downloading CircleCI cli" + mkdir -p "${CIRCLECI_CLI_PATH}" + wget -nv "${CIRCLECI_CLI_URL}" -O "${CIRCLECI_CLI_PATH}/circleci-cli.tar.gz" + echo "${CIRCLECI_CLI_SHASUM} *${CIRCLECI_CLI_PATH}/circleci-cli.tar.gz" | sha256sum -c + tar zxvf "${CIRCLECI_CLI_PATH}/circleci-cli.tar.gz" -C "${CIRCLECI_CLI_PATH}" --strip-components=1 +fi + +# Skip CircleCI update checks +export CIRCLECI_CLI_SKIP_UPDATE_CHECK="true" + +# Run test suite +echo "[-] Running test suite" +$CIRCLECI_CLI_BIN config process "${PROJECT_DIR}/.circleci/config.yml" > "${CONFIG_PATH}" +$CIRCLECI_CLI_BIN config validate -c "${CONFIG_PATH}" + +for job in "${JOBS[@]}"; do + echo "[-] Running job: ${job}" + $CIRCLECI_CLI_BIN local execute -c "${CONFIG_PATH}" --job "${job}" --skip-checkout + echo "[+] ${job} completed successfully" +done + +# Clean up +if [[ -f "${CONFIG_PATH}" ]]; then + rm "${CONFIG_PATH}" +fi + +echo "[+] Test suite ran successfully!" +exit 0 diff --git a/packages/core/acme-client/scripts/test-suite-install-coredns.sh b/packages/core/acme-client/scripts/test-suite-install-coredns.sh new file mode 100644 index 00000000..c4876beb --- /dev/null +++ b/packages/core/acme-client/scripts/test-suite-install-coredns.sh @@ -0,0 +1,58 @@ +#!/bin/bash +# +# Install CoreDNS for testing. +# +set -eu + +# Download and install +wget -nv "https://github.com/coredns/coredns/releases/download/v${COREDNS_VERSION}/coredns_${COREDNS_VERSION}_linux_amd64.tgz" -O /tmp/coredns.tgz + +tar zxvf /tmp/coredns.tgz -C /usr/local/bin +chown root:root /usr/local/bin/coredns +chmod 0755 /usr/local/bin/coredns + +mkdir -p /etc/coredns + +# Zones +tee /etc/coredns/db.example.com << EOF +\$ORIGIN example.com. +@ 3600 IN SOA ns.coredns.invalid. master.coredns.invalid. ( + 2017042745 ; serial + 7200 ; refresh + 3600 ; retry + 1209600 ; expire + 3600 ; minimum + ) + + 3600 IN NS ns1.example.com. + 3600 IN NS ns2.example.com. + +ns1 3600 IN A 127.0.0.1 +ns2 3600 IN A 127.0.0.1 + +@ 3600 IN A 127.0.0.1 +www 3600 IN CNAME example.com. +EOF + +# Config +tee /etc/coredns/Corefile << EOF +example.com { + errors + log + file /etc/coredns/db.example.com +} + +test.example.com { + errors + log + forward . 127.0.0.1:${PEBBLECTS_DNS_PORT} +} + +. { + errors + log + forward . 8.8.8.8 +} +EOF + +exit 0 diff --git a/packages/core/acme-client/scripts/test-suite-install-cts.sh b/packages/core/acme-client/scripts/test-suite-install-cts.sh new file mode 100644 index 00000000..ab9a85c1 --- /dev/null +++ b/packages/core/acme-client/scripts/test-suite-install-cts.sh @@ -0,0 +1,13 @@ +#!/bin/bash +# +# Install Pebble Challenge Test Server for testing. +# +set -eu + +# Download and install +wget -nv "https://github.com/letsencrypt/pebble/releases/download/v${PEBBLECTS_VERSION}/pebble-challtestsrv_linux-amd64" -O /usr/local/bin/pebble-challtestsrv + +chown root:root /usr/local/bin/pebble-challtestsrv +chmod 0755 /usr/local/bin/pebble-challtestsrv + +exit 0 diff --git a/packages/core/acme-client/scripts/test-suite-install-pebble.sh b/packages/core/acme-client/scripts/test-suite-install-pebble.sh new file mode 100644 index 00000000..9378250c --- /dev/null +++ b/packages/core/acme-client/scripts/test-suite-install-pebble.sh @@ -0,0 +1,33 @@ +#!/bin/bash +# +# Install Pebble for testing. +# +set -eu + +config_name="pebble-config.json" + +# Use Pebble EAB config if enabled +set +u +if [[ ! -z $ACME_CAP_EAB_ENABLED ]] && [[ $ACME_CAP_EAB_ENABLED -eq 1 ]]; then + config_name="pebble-config-external-account-bindings.json" +fi +set -u + +# Download certs and config +mkdir -p /etc/pebble + +wget -nv "https://raw.githubusercontent.com/letsencrypt/pebble/v${PEBBLE_VERSION}/test/certs/pebble.minica.pem" -O /etc/pebble/ca.cert.pem +wget -nv "https://raw.githubusercontent.com/letsencrypt/pebble/v${PEBBLE_VERSION}/test/certs/localhost/cert.pem" -O /etc/pebble/cert.pem +wget -nv "https://raw.githubusercontent.com/letsencrypt/pebble/v${PEBBLE_VERSION}/test/certs/localhost/key.pem" -O /etc/pebble/key.pem +wget -nv "https://raw.githubusercontent.com/letsencrypt/pebble/v${PEBBLE_VERSION}/test/config/${config_name}" -O /etc/pebble/pebble.json + +# Download and install Pebble +wget -nv "https://github.com/letsencrypt/pebble/releases/download/v${PEBBLE_VERSION}/pebble_linux-amd64" -O /usr/local/bin/pebble + +chown root:root /usr/local/bin/pebble +chmod 0755 /usr/local/bin/pebble + +# Config +sed -i 's/test\/certs\/localhost/\/etc\/pebble/' /etc/pebble/pebble.json + +exit 0 diff --git a/packages/core/acme-client/scripts/test-suite-install-step.sh b/packages/core/acme-client/scripts/test-suite-install-step.sh new file mode 100644 index 00000000..5de092a5 --- /dev/null +++ b/packages/core/acme-client/scripts/test-suite-install-step.sh @@ -0,0 +1,20 @@ +#!/bin/bash +# +# Install and init step-ca for testing. +# +set -eu + +# Download and install +wget -nv "https://dl.step.sm/gh-release/certificates/gh-release-header/v${STEPCA_VERSION}/step-ca_${STEPCA_VERSION}_amd64.deb" -O /tmp/step-ca.deb +wget -nv "https://dl.step.sm/gh-release/cli/gh-release-header/v${STEPCLI_VERSION}/step-cli_${STEPCLI_VERSION}_amd64.deb" -O /tmp/step-cli.deb + +sudo dpkg -i /tmp/step-ca.deb +sudo dpkg -i /tmp/step-cli.deb + +# Initialize +echo "hunter2" > /tmp/password + +step ca init --name="Example Inc." --dns="localhost" --address="127.0.0.1:8443" --provisioner="test@example.com" --password-file="/tmp/password" +step ca provisioner add acme --type ACME + +exit 0 diff --git a/packages/core/acme-client/scripts/test-suite-wait-for-ca.sh b/packages/core/acme-client/scripts/test-suite-wait-for-ca.sh new file mode 100644 index 00000000..a35cf6a1 --- /dev/null +++ b/packages/core/acme-client/scripts/test-suite-wait-for-ca.sh @@ -0,0 +1,27 @@ +#!/bin/bash +# +# Wait for ACME server to accept connections. +# +set -eu + +MAX_ATTEMPTS=15 +ATTEMPT=0 + +# Loop until ready +while ! $(curl --cacert "${ACME_CA_CERT_PATH}" -s -D - "${ACME_DIRECTORY_URL}" | grep '^HTTP.*200' > /dev/null 2>&1); do + ATTEMPT=$((ATTEMPT + 1)) + + # Max attempts + if [[ $ATTEMPT -gt $MAX_ATTEMPTS ]]; then + echo "[!] Waited ${ATTEMPT} attempts for server to become ready, exit 1" + exit 1 + fi + + # Retry + echo "[-] Waiting 1 second for server to become ready, attempt: ${ATTEMPT}/${MAX_ATTEMPTS}, check: ${ACME_DIRECTORY_URL}, cert: ${ACME_CA_CERT_PATH}" + sleep 1 +done + +# Ready +echo "[+] Server ready!" +exit 0 diff --git a/packages/core/acme-client/src/api.js b/packages/core/acme-client/src/api.js new file mode 100644 index 00000000..84fe0f88 --- /dev/null +++ b/packages/core/acme-client/src/api.js @@ -0,0 +1,250 @@ +/** + * ACME API client + */ + +const util = require('./util'); + + +/** + * AcmeApi + * + * @class + * @param {HttpClient} httpClient + */ + +class AcmeApi { + constructor(httpClient, accountUrl = null) { + this.http = httpClient; + this.accountUrl = accountUrl; + } + + + /** + * Get account URL + * + * @private + * @returns {string} Account URL + */ + + getAccountUrl() { + if (!this.accountUrl) { + throw new Error('No account URL found, register account first'); + } + + return this.accountUrl; + } + + + /** + * ACME API request + * + * @private + * @param {string} url Request URL + * @param {object} [payload] Request payload, default: `null` + * @param {array} [validStatusCodes] Array of valid HTTP response status codes, default: `[]` + * @param {object} [opts] + * @param {boolean} [opts.includeJwsKid] Include KID instead of JWK in JWS header, default: `true` + * @param {boolean} [opts.includeExternalAccountBinding] Include EAB in request, default: `false` + * @returns {Promise} HTTP response + */ + + async apiRequest(url, payload = null, validStatusCodes = [], { includeJwsKid = true, includeExternalAccountBinding = false } = {}) { + const kid = includeJwsKid ? this.getAccountUrl() : null; + const resp = await this.http.signedRequest(url, payload, { kid, includeExternalAccountBinding }); + + if (validStatusCodes.length && (validStatusCodes.indexOf(resp.status) === -1)) { + throw new Error(util.formatResponseError(resp)); + } + + return resp; + } + + + /** + * ACME API request by resource name helper + * + * @private + * @param {string} resource Request resource name + * @param {object} [payload] Request payload, default: `null` + * @param {array} [validStatusCodes] Array of valid HTTP response status codes, default: `[]` + * @param {object} [opts] + * @param {boolean} [opts.includeJwsKid] Include KID instead of JWK in JWS header, default: `true` + * @param {boolean} [opts.includeExternalAccountBinding] Include EAB in request, default: `false` + * @returns {Promise} HTTP response + */ + + async apiResourceRequest(resource, payload = null, validStatusCodes = [], { includeJwsKid = true, includeExternalAccountBinding = false } = {}) { + const resourceUrl = await this.http.getResourceUrl(resource); + return this.apiRequest(resourceUrl, payload, validStatusCodes, { includeJwsKid, includeExternalAccountBinding }); + } + + + /** + * Get Terms of Service URL if available + * + * https://tools.ietf.org/html/rfc8555#section-7.1.1 + * + * @returns {Promise} ToS URL + */ + + async getTermsOfServiceUrl() { + return this.http.getMetaField('termsOfService'); + } + + + /** + * Create new account + * + * https://tools.ietf.org/html/rfc8555#section-7.3 + * + * @param {object} data Request payload + * @returns {Promise} HTTP response + */ + + async createAccount(data) { + const resp = await this.apiResourceRequest('newAccount', data, [200, 201], { + includeJwsKid: false, + includeExternalAccountBinding: (data.onlyReturnExisting !== true) + }); + + /* Set account URL */ + if (resp.headers.location) { + this.accountUrl = resp.headers.location; + } + + return resp; + } + + + /** + * Update account + * + * https://tools.ietf.org/html/rfc8555#section-7.3.2 + * + * @param {object} data Request payload + * @returns {Promise} HTTP response + */ + + updateAccount(data) { + return this.apiRequest(this.getAccountUrl(), data, [200, 202]); + } + + + /** + * Update account key + * + * https://tools.ietf.org/html/rfc8555#section-7.3.5 + * + * @param {object} data Request payload + * @returns {Promise} HTTP response + */ + + updateAccountKey(data) { + return this.apiResourceRequest('keyChange', data, [200]); + } + + + /** + * Create new order + * + * https://tools.ietf.org/html/rfc8555#section-7.4 + * + * @param {object} data Request payload + * @returns {Promise} HTTP response + */ + + createOrder(data) { + return this.apiResourceRequest('newOrder', data, [201]); + } + + + /** + * Get order + * + * https://tools.ietf.org/html/rfc8555#section-7.4 + * + * @param {string} url Order URL + * @returns {Promise} HTTP response + */ + + getOrder(url) { + return this.apiRequest(url, null, [200]); + } + + + /** + * Finalize order + * + * https://tools.ietf.org/html/rfc8555#section-7.4 + * + * @param {string} url Finalization URL + * @param {object} data Request payload + * @returns {Promise} HTTP response + */ + + finalizeOrder(url, data) { + return this.apiRequest(url, data, [200]); + } + + + /** + * Get identifier authorization + * + * https://tools.ietf.org/html/rfc8555#section-7.5 + * + * @param {string} url Authorization URL + * @returns {Promise} HTTP response + */ + + getAuthorization(url) { + return this.apiRequest(url, null, [200]); + } + + + /** + * Update identifier authorization + * + * https://tools.ietf.org/html/rfc8555#section-7.5.2 + * + * @param {string} url Authorization URL + * @param {object} data Request payload + * @returns {Promise} HTTP response + */ + + updateAuthorization(url, data) { + return this.apiRequest(url, data, [200]); + } + + + /** + * Complete challenge + * + * https://tools.ietf.org/html/rfc8555#section-7.5.1 + * + * @param {string} url Challenge URL + * @param {object} data Request payload + * @returns {Promise} HTTP response + */ + + completeChallenge(url, data) { + return this.apiRequest(url, data, [200]); + } + + + /** + * Revoke certificate + * + * https://tools.ietf.org/html/rfc8555#section-7.6 + * + * @param {object} data Request payload + * @returns {Promise} HTTP response + */ + + revokeCert(data) { + return this.apiResourceRequest('revokeCert', data, [200]); + } +} + + +/* Export API */ +module.exports = AcmeApi; diff --git a/packages/core/acme-client/src/auto.js b/packages/core/acme-client/src/auto.js new file mode 100644 index 00000000..2b009d7f --- /dev/null +++ b/packages/core/acme-client/src/auto.js @@ -0,0 +1,179 @@ +/** + * ACME auto helper + */ + +const { readCsrDomains } = require('./crypto'); +const { log } = require('./logger'); + +const defaultOpts = { + csr: null, + email: null, + preferredChain: null, + termsOfServiceAgreed: false, + skipChallengeVerification: false, + challengePriority: ['http-01', 'dns-01'], + challengeCreateFn: async () => { throw new Error('Missing challengeCreateFn()'); }, + challengeRemoveFn: async () => { throw new Error('Missing challengeRemoveFn()'); } +}; + + +/** + * ACME client auto mode + * + * @param {AcmeClient} client ACME client + * @param {object} userOpts Options + * @returns {Promise} Certificate + */ + +module.exports = async function(client, userOpts) { + const opts = Object.assign({}, defaultOpts, userOpts); + const accountPayload = { termsOfServiceAgreed: opts.termsOfServiceAgreed }; + + if (!Buffer.isBuffer(opts.csr)) { + opts.csr = Buffer.from(opts.csr); + } + + if (opts.email) { + accountPayload.contact = [`mailto:${opts.email}`]; + } + + + /** + * Register account + */ + + log('[auto] Checking account'); + + try { + client.getAccountUrl(); + log('[auto] Account URL already exists, skipping account registration'); + } + catch (e) { + log('[auto] Registering account'); + await client.createAccount(accountPayload); + } + + + /** + * Parse domains from CSR + */ + + log('[auto] Parsing domains from Certificate Signing Request'); + const csrDomains = readCsrDomains(opts.csr); + const domains = [csrDomains.commonName].concat(csrDomains.altNames); + const uniqueDomains = Array.from(new Set(domains)); + + log(`[auto] Resolved ${uniqueDomains.length} unique domains from parsing the Certificate Signing Request`); + + + /** + * Place order + */ + + log('[auto] Placing new certificate order with ACME provider'); + const orderPayload = { identifiers: uniqueDomains.map((d) => ({ type: 'dns', value: d })) }; + const order = await client.createOrder(orderPayload); + const authorizations = await client.getAuthorizations(order); + + log(`[auto] Placed certificate order successfully, received ${authorizations.length} identity authorizations`); + + + /** + * Resolve and satisfy challenges + */ + + log('[auto] Resolving and satisfying authorization challenges'); + + const challengePromises = authorizations.map(async (authz) => { + const d = authz.identifier.value; + let challengeCompleted = false; + + /* Skip authz that already has valid status */ + if (authz.status === 'valid') { + log(`[auto] [${d}] Authorization already has valid status, no need to complete challenges`); + return; + } + + try { + /* Select challenge based on priority */ + const challenge = authz.challenges.sort((a, b) => { + const aidx = opts.challengePriority.indexOf(a.type); + const bidx = opts.challengePriority.indexOf(b.type); + + if (aidx === -1) return 1; + if (bidx === -1) return -1; + return aidx - bidx; + }).slice(0, 1)[0]; + + if (!challenge) { + throw new Error(`Unable to select challenge for ${d}, no challenge found`); + } + + log(`[auto] [${d}] Found ${authz.challenges.length} challenges, selected type: ${challenge.type}`); + + /* Trigger challengeCreateFn() */ + log(`[auto] [${d}] Trigger challengeCreateFn()`); + const keyAuthorization = await client.getChallengeKeyAuthorization(challenge); + + try { + await opts.challengeCreateFn(authz, challenge, keyAuthorization); + + /* Challenge verification */ + if (opts.skipChallengeVerification === true) { + log(`[auto] [${d}] Skipping challenge verification since skipChallengeVerification=true`); + } + else { + log(`[auto] [${d}] Running challenge verification`); + await client.verifyChallenge(authz, challenge); + } + + /* Complete challenge and wait for valid status */ + log(`[auto] [${d}] Completing challenge with ACME provider and waiting for valid status`); + await client.completeChallenge(challenge); + challengeCompleted = true; + + await client.waitForValidStatus(challenge); + } + finally { + /* Trigger challengeRemoveFn(), suppress errors */ + log(`[auto] [${d}] Trigger challengeRemoveFn()`); + + try { + await opts.challengeRemoveFn(authz, challenge, keyAuthorization); + } + catch (e) { + log(`[auto] [${d}] challengeRemoveFn threw error: ${e.message}`); + } + } + } + catch (e) { + /* Deactivate pending authz when unable to complete challenge */ + if (!challengeCompleted) { + log(`[auto] [${d}] Unable to complete challenge: ${e.message}`); + + try { + log(`[auto] [${d}] Deactivating failed authorization`); + await client.deactivateAuthorization(authz); + } + catch (f) { + /* Suppress deactivateAuthorization() errors */ + log(`[auto] [${d}] Authorization deactivation threw error: ${f.message}`); + } + } + + throw e; + } + }); + + log('[auto] Waiting for challenge valid status'); + await Promise.all(challengePromises); + + + /** + * Finalize order and download certificate + */ + + log('[auto] Finalizing order and downloading certificate'); + const finalized = await client.finalizeOrder(order, opts.csr); + return client.getCertificate(finalized, opts.preferredChain); +}; diff --git a/packages/core/acme-client/src/axios.js b/packages/core/acme-client/src/axios.js new file mode 100644 index 00000000..b9974852 --- /dev/null +++ b/packages/core/acme-client/src/axios.js @@ -0,0 +1,40 @@ +/** + * Axios instance + */ + +const axios = require('axios'); +const adapter = require('axios/lib/adapters/http'); +const pkg = require('./../package.json'); + + +/** + * Instance + */ + +const instance = axios.create(); + +/* Default User-Agent */ +instance.defaults.headers.common['User-Agent'] = `node-${pkg.name}/${pkg.version}`; + +/* Default ACME settings */ +instance.defaults.acmeSettings = { + httpChallengePort: 80, + bypassCustomDnsResolver: false +}; + + +/** + * Explicitly set Node as default HTTP adapter + * + * https://github.com/axios/axios/issues/1180 + * https://stackoverflow.com/questions/42677387 + */ + +instance.defaults.adapter = adapter; + + +/** + * Export instance + */ + +module.exports = instance; diff --git a/packages/core/acme-client/src/client.js b/packages/core/acme-client/src/client.js new file mode 100644 index 00000000..6547522e --- /dev/null +++ b/packages/core/acme-client/src/client.js @@ -0,0 +1,735 @@ +/** + * ACME client + * + * @namespace Client + */ + +const { createHash } = require('crypto'); +const { getPemBodyAsB64u } = require('./crypto'); +const { log } = require('./logger'); +const HttpClient = require('./http'); +const AcmeApi = require('./api'); +const verify = require('./verify'); +const util = require('./util'); +const auto = require('./auto'); + + +/** + * ACME states + * + * @private + */ + +const validStates = ['ready', 'valid']; +const pendingStates = ['pending', 'processing']; +const invalidStates = ['invalid']; + + +/** + * Default options + * + * @private + */ + +const defaultOpts = { + directoryUrl: undefined, + accountKey: undefined, + accountUrl: null, + externalAccountBinding: {}, + backoffAttempts: 10, + backoffMin: 5000, + backoffMax: 30000 +}; + + +/** + * AcmeClient + * + * @class + * @param {object} opts + * @param {string} opts.directoryUrl ACME directory URL + * @param {buffer|string} opts.accountKey PEM encoded account private key + * @param {string} [opts.accountUrl] Account URL, default: `null` + * @param {object} [opts.externalAccountBinding] + * @param {string} [opts.externalAccountBinding.kid] External account binding KID + * @param {string} [opts.externalAccountBinding.hmacKey] External account binding HMAC key + * @param {number} [opts.backoffAttempts] Maximum number of backoff attempts, default: `10` + * @param {number} [opts.backoffMin] Minimum backoff attempt delay in milliseconds, default: `5000` + * @param {number} [opts.backoffMax] Maximum backoff attempt delay in milliseconds, default: `30000` + * + * @example Create ACME client instance + * ```js + * const client = new acme.Client({ + * directoryUrl: acme.directory.letsencrypt.staging, + * accountKey: 'Private key goes here' + * }); + * ``` + * + * @example Create ACME client instance + * ```js + * const client = new acme.Client({ + * directoryUrl: acme.directory.letsencrypt.staging, + * accountKey: 'Private key goes here', + * accountUrl: 'Optional account URL goes here', + * backoffAttempts: 10, + * backoffMin: 5000, + * backoffMax: 30000 + * }); + * ``` + * + * @example Create ACME client with external account binding + * ```js + * const client = new acme.Client({ + * directoryUrl: 'https://acme-provider.example.com/directory-url', + * accountKey: 'Private key goes here', + * externalAccountBinding: { + * kid: 'YOUR-EAB-KID', + * hmacKey: 'YOUR-EAB-HMAC-KEY' + * } + * }); + * ``` + */ + +class AcmeClient { + constructor(opts) { + if (!Buffer.isBuffer(opts.accountKey)) { + opts.accountKey = Buffer.from(opts.accountKey); + } + + this.opts = Object.assign({}, defaultOpts, opts); + + this.backoffOpts = { + attempts: this.opts.backoffAttempts, + min: this.opts.backoffMin, + max: this.opts.backoffMax + }; + + this.http = new HttpClient(this.opts.directoryUrl, this.opts.accountKey, this.opts.externalAccountBinding); + this.api = new AcmeApi(this.http, this.opts.accountUrl); + } + + + /** + * Get Terms of Service URL if available + * + * @returns {Promise} ToS URL + * + * @example Get Terms of Service URL + * ```js + * const termsOfService = client.getTermsOfServiceUrl(); + * + * if (!termsOfService) { + * // CA did not provide Terms of Service + * } + * ``` + */ + + getTermsOfServiceUrl() { + return this.api.getTermsOfServiceUrl(); + } + + + /** + * Get current account URL + * + * @returns {string} Account URL + * @throws {Error} No account URL found + * + * @example Get current account URL + * ```js + * try { + * const accountUrl = client.getAccountUrl(); + * } + * catch (e) { + * // No account URL exists, need to create account first + * } + * ``` + */ + + getAccountUrl() { + return this.api.getAccountUrl(); + } + + + /** + * Create a new account + * + * https://tools.ietf.org/html/rfc8555#section-7.3 + * + * @param {object} [data] Request data + * @returns {Promise} Account + * + * @example Create a new account + * ```js + * const account = await client.createAccount({ + * termsOfServiceAgreed: true + * }); + * ``` + * + * @example Create a new account with contact info + * ```js + * const account = await client.createAccount({ + * termsOfServiceAgreed: true, + * contact: ['mailto:test@example.com'] + * }); + * ``` + */ + + async createAccount(data = {}) { + try { + this.getAccountUrl(); + + /* Account URL exists */ + log('Account URL exists, returning updateAccount()'); + return this.updateAccount(data); + } + catch (e) { + const resp = await this.api.createAccount(data); + + /* HTTP 200: Account exists */ + if (resp.status === 200) { + log('Account already exists (HTTP 200), returning updateAccount()'); + return this.updateAccount(data); + } + + return resp.data; + } + } + + + /** + * Update existing account + * + * https://tools.ietf.org/html/rfc8555#section-7.3.2 + * + * @param {object} [data] Request data + * @returns {Promise} Account + * + * @example Update existing account + * ```js + * const account = await client.updateAccount({ + * contact: ['mailto:foo@example.com'] + * }); + * ``` + */ + + async updateAccount(data = {}) { + try { + this.api.getAccountUrl(); + } + catch (e) { + log('No account URL found, returning createAccount()'); + return this.createAccount(data); + } + + /* Remove data only applicable to createAccount() */ + if ('onlyReturnExisting' in data) { + delete data.onlyReturnExisting; + } + + /* POST-as-GET */ + if (Object.keys(data).length === 0) { + data = null; + } + + const resp = await this.api.updateAccount(data); + return resp.data; + } + + + /** + * Update account private key + * + * https://tools.ietf.org/html/rfc8555#section-7.3.5 + * + * @param {buffer|string} newAccountKey New PEM encoded private key + * @param {object} [data] Additional request data + * @returns {Promise} Account + * + * @example Update account private key + * ```js + * const newAccountKey = 'New private key goes here'; + * const result = await client.updateAccountKey(newAccountKey); + * ``` + */ + + async updateAccountKey(newAccountKey, data = {}) { + if (!Buffer.isBuffer(newAccountKey)) { + newAccountKey = Buffer.from(newAccountKey); + } + + const accountUrl = this.api.getAccountUrl(); + + /* Create new HTTP and API clients using new key */ + const newHttpClient = new HttpClient(this.opts.directoryUrl, newAccountKey); + const newApiClient = new AcmeApi(newHttpClient, accountUrl); + + /* Get old JWK */ + data.account = accountUrl; + data.oldKey = this.http.getJwk(); + + /* Get signed request body from new client */ + const url = await newHttpClient.getResourceUrl('keyChange'); + const body = newHttpClient.createSignedBody(url, data); + + /* Change key using old client */ + const resp = await this.api.updateAccountKey(body); + + /* Replace existing HTTP and API client */ + this.http = newHttpClient; + this.api = newApiClient; + + return resp.data; + } + + + /** + * Create a new order + * + * https://tools.ietf.org/html/rfc8555#section-7.4 + * + * @param {object} data Request data + * @returns {Promise} Order + * + * @example Create a new order + * ```js + * const order = await client.createOrder({ + * identifiers: [ + * { type: 'dns', value: 'example.com' }, + * { type: 'dns', value: 'test.example.com' } + * ] + * }); + * ``` + */ + + async createOrder(data) { + const resp = await this.api.createOrder(data); + + if (!resp.headers.location) { + throw new Error('Creating a new order did not return an order link'); + } + + /* Add URL to response */ + resp.data.url = resp.headers.location; + return resp.data; + } + + + /** + * Refresh order object from CA + * + * https://tools.ietf.org/html/rfc8555#section-7.4 + * + * @param {object} order Order object + * @returns {Promise} Order + * + * @example + * ```js + * const order = { ... }; // Previously created order object + * const result = await client.getOrder(order); + * ``` + */ + + async getOrder(order) { + if (!order.url) { + throw new Error('Unable to get order, URL not found'); + } + + const resp = await this.api.getOrder(order.url); + + /* Add URL to response */ + resp.data.url = order.url; + return resp.data; + } + + /** + * Finalize order + * + * https://tools.ietf.org/html/rfc8555#section-7.4 + * + * @param {object} order Order object + * @param {buffer|string} csr PEM encoded Certificate Signing Request + * @returns {Promise} Order + * + * @example Finalize order + * ```js + * const order = { ... }; // Previously created order object + * const csr = { ... }; // Previously created Certificate Signing Request + * const result = await client.finalizeOrder(order, csr); + * ``` + */ + + async finalizeOrder(order, csr) { + if (!order.finalize) { + throw new Error('Unable to finalize order, URL not found'); + } + + if (!Buffer.isBuffer(csr)) { + csr = Buffer.from(csr); + } + + const data = { csr: getPemBodyAsB64u(csr) }; + const resp = await this.api.finalizeOrder(order.finalize, data); + + /* Add URL to response */ + resp.data.url = order.url; + return resp.data; + } + + + /** + * Get identifier authorizations from order + * + * https://tools.ietf.org/html/rfc8555#section-7.5 + * + * @param {object} order Order + * @returns {Promise} Authorizations + * + * @example Get identifier authorizations + * ```js + * const order = { ... }; // Previously created order object + * const authorizations = await client.getAuthorizations(order); + * + * authorizations.forEach((authz) => { + * const { challenges } = authz; + * }); + * ``` + */ + + async getAuthorizations(order) { + return Promise.all((order.authorizations || []).map(async (url) => { + const resp = await this.api.getAuthorization(url); + + /* Add URL to response */ + resp.data.url = url; + return resp.data; + })); + } + + + /** + * Deactivate identifier authorization + * + * https://tools.ietf.org/html/rfc8555#section-7.5.2 + * + * @param {object} authz Identifier authorization + * @returns {Promise} Authorization + * + * @example Deactivate identifier authorization + * ```js + * const authz = { ... }; // Identifier authorization resolved from previously created order + * const result = await client.deactivateAuthorization(authz); + * ``` + */ + + async deactivateAuthorization(authz) { + if (!authz.url) { + throw new Error('Unable to deactivate identifier authorization, URL not found'); + } + + const data = { + status: 'deactivated' + }; + + const resp = await this.api.updateAuthorization(authz.url, data); + + /* Add URL to response */ + resp.data.url = authz.url; + return resp.data; + } + + + /** + * Get key authorization for ACME challenge + * + * https://tools.ietf.org/html/rfc8555#section-8.1 + * + * @param {object} challenge Challenge object returned by API + * @returns {Promise} Key authorization + * + * @example Get challenge key authorization + * ```js + * const challenge = { ... }; // Challenge from previously resolved identifier authorization + * const key = await client.getChallengeKeyAuthorization(challenge); + * + * // Write key somewhere to satisfy challenge + * ``` + */ + + async getChallengeKeyAuthorization(challenge) { + const jwk = this.http.getJwk(); + const keysum = createHash('sha256').update(JSON.stringify(jwk)); + const thumbprint = keysum.digest('base64url'); + const result = `${challenge.token}.${thumbprint}`; + + /** + * https://tools.ietf.org/html/rfc8555#section-8.3 + */ + + if (challenge.type === 'http-01') { + return result; + } + + /** + * https://tools.ietf.org/html/rfc8555#section-8.4 + * https://tools.ietf.org/html/draft-ietf-acme-tls-alpn-01 + */ + + if ((challenge.type === 'dns-01') || (challenge.type === 'tls-alpn-01')) { + const shasum = createHash('sha256').update(result); + return shasum.digest('base64url'); + } + + throw new Error(`Unable to produce key authorization, unknown challenge type: ${challenge.type}`); + } + + + /** + * Verify that ACME challenge is satisfied + * + * @param {object} authz Identifier authorization + * @param {object} challenge Authorization challenge + * @returns {Promise} + * + * @example Verify satisfied ACME challenge + * ```js + * const authz = { ... }; // Identifier authorization + * const challenge = { ... }; // Satisfied challenge + * await client.verifyChallenge(authz, challenge); + * ``` + */ + + async verifyChallenge(authz, challenge) { + if (!authz.url || !challenge.url) { + throw new Error('Unable to verify ACME challenge, URL not found'); + } + + if (typeof verify[challenge.type] === 'undefined') { + throw new Error(`Unable to verify ACME challenge, unknown type: ${challenge.type}`); + } + + const keyAuthorization = await this.getChallengeKeyAuthorization(challenge); + + const verifyFn = async () => { + await verify[challenge.type](authz, challenge, keyAuthorization); + }; + + log('Waiting for ACME challenge verification', this.backoffOpts); + return util.retry(verifyFn, this.backoffOpts); + } + + + /** + * Notify CA that challenge has been completed + * + * https://tools.ietf.org/html/rfc8555#section-7.5.1 + * + * @param {object} challenge Challenge object returned by API + * @returns {Promise} Challenge + * + * @example Notify CA that challenge has been completed + * ```js + * const challenge = { ... }; // Satisfied challenge + * const result = await client.completeChallenge(challenge); + * ``` + */ + + async completeChallenge(challenge) { + const resp = await this.api.completeChallenge(challenge.url, {}); + return resp.data; + } + + + /** + * Wait for ACME provider to verify status on a order, authorization or challenge + * + * https://tools.ietf.org/html/rfc8555#section-7.5.1 + * + * @param {object} item An order, authorization or challenge object + * @returns {Promise} Valid order, authorization or challenge + * + * @example Wait for valid challenge status + * ```js + * const challenge = { ... }; + * await client.waitForValidStatus(challenge); + * ``` + * + * @example Wait for valid authoriation status + * ```js + * const authz = { ... }; + * await client.waitForValidStatus(authz); + * ``` + * + * @example Wait for valid order status + * ```js + * const order = { ... }; + * await client.waitForValidStatus(order); + * ``` + */ + + async waitForValidStatus(item) { + if (!item.url) { + throw new Error('Unable to verify status of item, URL not found'); + } + + const verifyFn = async (abort) => { + const resp = await this.api.apiRequest(item.url, null, [200]); + + /* Verify status */ + log(`Item has status: ${resp.data.status}`); + + if (invalidStates.includes(resp.data.status)) { + abort(); + throw new Error(util.formatResponseError(resp)); + } + else if (pendingStates.includes(resp.data.status)) { + throw new Error('Operation is pending or processing'); + } + else if (validStates.includes(resp.data.status)) { + return resp.data; + } + + throw new Error(`Unexpected item status: ${resp.data.status}`); + }; + + log(`Waiting for valid status from: ${item.url}`, this.backoffOpts); + return util.retry(verifyFn, this.backoffOpts); + } + + + /** + * Get certificate from ACME order + * + * https://tools.ietf.org/html/rfc8555#section-7.4.2 + * + * @param {object} order Order object + * @param {string} [preferredChain] Indicate which certificate chain is preferred if a CA offers multiple, by exact issuer common name, default: `null` + * @returns {Promise} Certificate + * + * @example Get certificate + * ```js + * const order = { ... }; // Previously created order + * const certificate = await client.getCertificate(order); + * ``` + * + * @example Get certificate with preferred chain + * ```js + * const order = { ... }; // Previously created order + * const certificate = await client.getCertificate(order, 'DST Root CA X3'); + * ``` + */ + + async getCertificate(order, preferredChain = null) { + if (!validStates.includes(order.status)) { + order = await this.waitForValidStatus(order); + } + + if (!order.certificate) { + throw new Error('Unable to download certificate, URL not found'); + } + + const resp = await this.api.apiRequest(order.certificate, null, [200]); + + /* Handle alternate certificate chains */ + if (preferredChain && resp.headers.link) { + const alternateLinks = util.parseLinkHeader(resp.headers.link); + const alternates = await Promise.all(alternateLinks.map(async (link) => this.api.apiRequest(link, null, [200]))); + const certificates = [resp].concat(alternates).map((c) => c.data); + + return util.findCertificateChainForIssuer(certificates, preferredChain); + } + + /* Return default certificate chain */ + return resp.data; + } + + + /** + * Revoke certificate + * + * https://tools.ietf.org/html/rfc8555#section-7.6 + * + * @param {buffer|string} cert PEM encoded certificate + * @param {object} [data] Additional request data + * @returns {Promise} + * + * @example Revoke certificate + * ```js + * const certificate = { ... }; // Previously created certificate + * const result = await client.revokeCertificate(certificate); + * ``` + * + * @example Revoke certificate with reason + * ```js + * const certificate = { ... }; // Previously created certificate + * const result = await client.revokeCertificate(certificate, { + * reason: 4 + * }); + * ``` + */ + + async revokeCertificate(cert, data = {}) { + data.certificate = getPemBodyAsB64u(cert); + const resp = await this.api.revokeCert(data); + return resp.data; + } + + + /** + * Auto mode + * + * @param {object} opts + * @param {buffer|string} opts.csr Certificate Signing Request + * @param {function} opts.challengeCreateFn Function returning Promise triggered before completing ACME challenge + * @param {function} opts.challengeRemoveFn Function returning Promise triggered after completing ACME challenge + * @param {string} [opts.email] Account email address + * @param {boolean} [opts.termsOfServiceAgreed] Agree to Terms of Service, default: `false` + * @param {boolean} [opts.skipChallengeVerification] Skip internal challenge verification before notifying ACME provider, default: `false` + * @param {string[]} [opts.challengePriority] Array defining challenge type priority, default: `['http-01', 'dns-01']` + * @param {string} [opts.preferredChain] Indicate which certificate chain is preferred if a CA offers multiple, by exact issuer common name, default: `null` + * @returns {Promise} Certificate + * + * @example Order a certificate using auto mode + * ```js + * const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + * commonName: 'test.example.com' + * }); + * + * const certificate = await client.auto({ + * csr: certificateRequest, + * email: 'test@example.com', + * termsOfServiceAgreed: true, + * challengeCreateFn: async (authz, challenge, keyAuthorization) => { + * // Satisfy challenge here + * }, + * challengeRemoveFn: async (authz, challenge, keyAuthorization) => { + * // Clean up challenge here + * } + * }); + * ``` + * + * @example Order a certificate using auto mode with preferred chain + * ```js + * const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + * commonName: 'test.example.com' + * }); + * + * const certificate = await client.auto({ + * csr: certificateRequest, + * email: 'test@example.com', + * termsOfServiceAgreed: true, + * preferredChain: 'DST Root CA X3', + * challengeCreateFn: async () => {}, + * challengeRemoveFn: async () => {} + * }); + * ``` + */ + + auto(opts) { + return auto(this, opts); + } +} + + +/* Export client */ +module.exports = AcmeClient; diff --git a/packages/core/acme-client/src/crypto/forge.js b/packages/core/acme-client/src/crypto/forge.js new file mode 100644 index 00000000..f22425de --- /dev/null +++ b/packages/core/acme-client/src/crypto/forge.js @@ -0,0 +1,448 @@ +/** + * Legacy node-forge crypto interface + * + * DEPRECATION WARNING: This crypto interface is deprecated and will be removed from acme-client in a future + * major release. Please migrate to the new `acme.crypto` interface at your earliest convenience. + * + * @namespace forge + */ + +const net = require('net'); +const { promisify } = require('util'); +const forge = require('node-forge'); + +const generateKeyPair = promisify(forge.pki.rsa.generateKeyPair); + + +/** + * Attempt to parse forge object from PEM encoded string + * + * @private + * @param {string} input PEM string + * @return {object} + */ + +function forgeObjectFromPem(input) { + const msg = forge.pem.decode(input)[0]; + let result; + + switch (msg.type) { + case 'PRIVATE KEY': + case 'RSA PRIVATE KEY': + result = forge.pki.privateKeyFromPem(input); + break; + + case 'PUBLIC KEY': + case 'RSA PUBLIC KEY': + result = forge.pki.publicKeyFromPem(input); + break; + + case 'CERTIFICATE': + case 'X509 CERTIFICATE': + case 'TRUSTED CERTIFICATE': + result = forge.pki.certificateFromPem(input).publicKey; + break; + + case 'CERTIFICATE REQUEST': + result = forge.pki.certificationRequestFromPem(input).publicKey; + break; + + default: + throw new Error('Unable to detect forge message type'); + } + + return result; +} + + +/** + * Parse domain names from a certificate or CSR + * + * @private + * @param {object} obj Forge certificate or CSR + * @returns {object} {commonName, altNames} + */ + +function parseDomains(obj) { + let commonName = null; + let altNames = []; + let altNamesDict = []; + + const commonNameObject = (obj.subject.attributes || []).find((a) => a.name === 'commonName'); + const rootAltNames = (obj.extensions || []).find((e) => 'altNames' in e); + const rootExtensions = (obj.attributes || []).find((a) => 'extensions' in a); + + if (rootAltNames && rootAltNames.altNames && rootAltNames.altNames.length) { + altNamesDict = rootAltNames.altNames; + } + else if (rootExtensions && rootExtensions.extensions && rootExtensions.extensions.length) { + const extAltNames = rootExtensions.extensions.find((e) => 'altNames' in e); + + if (extAltNames && extAltNames.altNames && extAltNames.altNames.length) { + altNamesDict = extAltNames.altNames; + } + } + + if (commonNameObject) { + commonName = commonNameObject.value; + } + + if (altNamesDict) { + altNames = altNamesDict.map((a) => a.value); + } + + return { + commonName, + altNames + }; +} + + +/** + * Generate a private RSA key + * + * @param {number} [size] Size of the key, default: `2048` + * @returns {Promise} PEM encoded private RSA key + * + * @example Generate private RSA key + * ```js + * const privateKey = await acme.forge.createPrivateKey(); + * ``` + * + * @example Private RSA key with defined size + * ```js + * const privateKey = await acme.forge.createPrivateKey(4096); + * ``` + */ + +async function createPrivateKey(size = 2048) { + const keyPair = await generateKeyPair({ bits: size }); + const pemKey = forge.pki.privateKeyToPem(keyPair.privateKey); + return Buffer.from(pemKey); +} + +exports.createPrivateKey = createPrivateKey; + + +/** + * Create public key from a private RSA key + * + * @param {buffer|string} key PEM encoded private RSA key + * @returns {Promise} PEM encoded public RSA key + * + * @example Create public key + * ```js + * const publicKey = await acme.forge.createPublicKey(privateKey); + * ``` + */ + +exports.createPublicKey = async function(key) { + const privateKey = forge.pki.privateKeyFromPem(key); + const publicKey = forge.pki.rsa.setPublicKey(privateKey.n, privateKey.e); + const pemKey = forge.pki.publicKeyToPem(publicKey); + return Buffer.from(pemKey); +}; + + +/** + * Parse body of PEM encoded object from buffer or string + * If multiple objects are chained, the first body will be returned + * + * @param {buffer|string} str PEM encoded buffer or string + * @returns {string} PEM body + */ + +exports.getPemBody = (str) => { + const msg = forge.pem.decode(str)[0]; + return forge.util.encode64(msg.body); +}; + + +/** + * Split chain of PEM encoded objects from buffer or string into array + * + * @param {buffer|string} str PEM encoded buffer or string + * @returns {string[]} Array of PEM bodies + */ + +exports.splitPemChain = (str) => forge.pem.decode(str).map(forge.pem.encode); + + +/** + * Get modulus + * + * @param {buffer|string} input PEM encoded private key, certificate or CSR + * @returns {Promise} Modulus + * + * @example Get modulus + * ```js + * const m1 = await acme.forge.getModulus(privateKey); + * const m2 = await acme.forge.getModulus(certificate); + * const m3 = await acme.forge.getModulus(certificateRequest); + * ``` + */ + +exports.getModulus = async function(input) { + if (!Buffer.isBuffer(input)) { + input = Buffer.from(input); + } + + const obj = forgeObjectFromPem(input); + return Buffer.from(forge.util.hexToBytes(obj.n.toString(16)), 'binary'); +}; + + +/** + * Get public exponent + * + * @param {buffer|string} input PEM encoded private key, certificate or CSR + * @returns {Promise} Exponent + * + * @example Get public exponent + * ```js + * const e1 = await acme.forge.getPublicExponent(privateKey); + * const e2 = await acme.forge.getPublicExponent(certificate); + * const e3 = await acme.forge.getPublicExponent(certificateRequest); + * ``` + */ + +exports.getPublicExponent = async function(input) { + if (!Buffer.isBuffer(input)) { + input = Buffer.from(input); + } + + const obj = forgeObjectFromPem(input); + return Buffer.from(forge.util.hexToBytes(obj.e.toString(16)), 'binary'); +}; + + +/** + * Read domains from a Certificate Signing Request + * + * @param {buffer|string} csr PEM encoded Certificate Signing Request + * @returns {Promise} {commonName, altNames} + * + * @example Read Certificate Signing Request domains + * ```js + * const { commonName, altNames } = await acme.forge.readCsrDomains(certificateRequest); + * + * console.log(`Common name: ${commonName}`); + * console.log(`Alt names: ${altNames.join(', ')}`); + * ``` + */ + +exports.readCsrDomains = async function(csr) { + if (!Buffer.isBuffer(csr)) { + csr = Buffer.from(csr); + } + + const obj = forge.pki.certificationRequestFromPem(csr); + return parseDomains(obj); +}; + + +/** + * Read information from a certificate + * + * @param {buffer|string} cert PEM encoded certificate + * @returns {Promise} Certificate info + * + * @example Read certificate information + * ```js + * const info = await acme.forge.readCertificateInfo(certificate); + * const { commonName, altNames } = info.domains; + * + * console.log(`Not after: ${info.notAfter}`); + * console.log(`Not before: ${info.notBefore}`); + * + * console.log(`Common name: ${commonName}`); + * console.log(`Alt names: ${altNames.join(', ')}`); + * ``` + */ + +exports.readCertificateInfo = async function(cert) { + if (!Buffer.isBuffer(cert)) { + cert = Buffer.from(cert); + } + + const obj = forge.pki.certificateFromPem(cert); + const issuerCn = (obj.issuer.attributes || []).find((a) => a.name === 'commonName'); + + return { + issuer: { + commonName: issuerCn ? issuerCn.value : null + }, + domains: parseDomains(obj), + notAfter: obj.validity.notAfter, + notBefore: obj.validity.notBefore + }; +}; + + +/** + * Determine ASN.1 type for CSR subject short name + * Note: https://tools.ietf.org/html/rfc5280 + * + * @private + * @param {string} shortName CSR subject short name + * @returns {forge.asn1.Type} ASN.1 type + */ + +function getCsrValueTagClass(shortName) { + switch (shortName) { + case 'C': + return forge.asn1.Type.PRINTABLESTRING; + case 'E': + return forge.asn1.Type.IA5STRING; + default: + return forge.asn1.Type.UTF8; + } +} + + +/** + * Create array of short names and values for Certificate Signing Request subjects + * + * @private + * @param {object} subjectObj Key-value of short names and values + * @returns {object[]} Certificate Signing Request subject array + */ + +function createCsrSubject(subjectObj) { + return Object.entries(subjectObj).reduce((result, [shortName, value]) => { + if (value) { + const valueTagClass = getCsrValueTagClass(shortName); + result.push({ shortName, value, valueTagClass }); + } + + return result; + }, []); +} + + +/** + * Create array of alt names for Certificate Signing Requests + * Note: https://github.com/digitalbazaar/forge/blob/dfdde475677a8a25c851e33e8f81dca60d90cfb9/lib/x509.js#L1444-L1454 + * + * @private + * @param {string[]} altNames Alt names + * @returns {object[]} Certificate Signing Request alt names array + */ + +function formatCsrAltNames(altNames) { + return altNames.map((value) => { + const type = net.isIP(value) ? 7 : 2; + return { type, value }; + }); +} + + +/** + * Create a Certificate Signing Request + * + * @param {object} data + * @param {number} [data.keySize] Size of newly created private key, default: `2048` + * @param {string} [data.commonName] + * @param {array} [data.altNames] default: `[]` + * @param {string} [data.country] + * @param {string} [data.state] + * @param {string} [data.locality] + * @param {string} [data.organization] + * @param {string} [data.organizationUnit] + * @param {string} [data.emailAddress] + * @param {buffer|string} [key] CSR private key + * @returns {Promise} [privateKey, certificateSigningRequest] + * + * @example Create a Certificate Signing Request + * ```js + * const [certificateKey, certificateRequest] = await acme.forge.createCsr({ + * commonName: 'test.example.com' + * }); + * ``` + * + * @example Certificate Signing Request with both common and alternative names + * ```js + * const [certificateKey, certificateRequest] = await acme.forge.createCsr({ + * keySize: 4096, + * commonName: 'test.example.com', + * altNames: ['foo.example.com', 'bar.example.com'] + * }); + * ``` + * + * @example Certificate Signing Request with additional information + * ```js + * const [certificateKey, certificateRequest] = await acme.forge.createCsr({ + * commonName: 'test.example.com', + * country: 'US', + * state: 'California', + * locality: 'Los Angeles', + * organization: 'The Company Inc.', + * organizationUnit: 'IT Department', + * emailAddress: 'contact@example.com' + * }); + * ``` + * + * @example Certificate Signing Request with predefined private key + * ```js + * const certificateKey = await acme.forge.createPrivateKey(); + * + * const [, certificateRequest] = await acme.forge.createCsr({ + * commonName: 'test.example.com' + * }, certificateKey); + */ + +exports.createCsr = async function(data, key = null) { + if (!key) { + key = await createPrivateKey(data.keySize); + } + else if (!Buffer.isBuffer(key)) { + key = Buffer.from(key); + } + + if (typeof data.altNames === 'undefined') { + data.altNames = []; + } + + const csr = forge.pki.createCertificationRequest(); + + /* Public key */ + const privateKey = forge.pki.privateKeyFromPem(key); + const publicKey = forge.pki.rsa.setPublicKey(privateKey.n, privateKey.e); + csr.publicKey = publicKey; + + /* Ensure subject common name is present in SAN - https://cabforum.org/wp-content/uploads/BRv1.2.3.pdf */ + if (data.commonName && !data.altNames.includes(data.commonName)) { + data.altNames.unshift(data.commonName); + } + + /* Subject */ + const subject = createCsrSubject({ + CN: data.commonName, + C: data.country, + ST: data.state, + L: data.locality, + O: data.organization, + OU: data.organizationUnit, + E: data.emailAddress + }); + + csr.setSubject(subject); + + /* SAN extension */ + if (data.altNames.length) { + csr.setAttributes([{ + name: 'extensionRequest', + extensions: [{ + name: 'subjectAltName', + altNames: formatCsrAltNames(data.altNames) + }] + }]); + } + + /* Sign CSR using SHA-256 */ + csr.sign(privateKey, forge.md.sha256.create()); + + /* Done */ + const pemCsr = forge.pki.certificationRequestToPem(csr); + return [key, Buffer.from(pemCsr)]; +}; diff --git a/packages/core/acme-client/src/crypto/index.js b/packages/core/acme-client/src/crypto/index.js new file mode 100644 index 00000000..582b2d11 --- /dev/null +++ b/packages/core/acme-client/src/crypto/index.js @@ -0,0 +1,526 @@ +/** + * Native Node.js crypto interface + * + * @namespace crypto + */ + +const net = require('net'); +const { promisify } = require('util'); +const crypto = require('crypto'); +const jsrsasign = require('jsrsasign'); + +const generateKeyPair = promisify(crypto.generateKeyPair); + + +/** + * Determine key type and info by attempting to derive public key + * + * @private + * @param {buffer|string} keyPem PEM encoded private or public key + * @returns {object} + */ + +function getKeyInfo(keyPem) { + const result = { + isRSA: false, + isECDSA: false, + signatureAlgorithm: null, + publicKey: crypto.createPublicKey(keyPem) + }; + + if (result.publicKey.asymmetricKeyType === 'rsa') { + result.isRSA = true; + result.signatureAlgorithm = 'SHA256withRSA'; + } + else if (result.publicKey.asymmetricKeyType === 'ec') { + result.isECDSA = true; + result.signatureAlgorithm = 'SHA256withECDSA'; + } + else { + throw new Error('Unable to parse key information, unknown format'); + } + + return result; +} + + +/** + * Generate a private RSA key + * + * @param {number} [modulusLength] Size of the keys modulus in bits, default: `2048` + * @returns {Promise} PEM encoded private RSA key + * + * @example Generate private RSA key + * ```js + * const privateKey = await acme.crypto.createPrivateRsaKey(); + * ``` + * + * @example Private RSA key with modulus size 4096 + * ```js + * const privateKey = await acme.crypto.createPrivateRsaKey(4096); + * ``` + */ + +async function createPrivateRsaKey(modulusLength = 2048) { + const pair = await generateKeyPair('rsa', { + modulusLength, + privateKeyEncoding: { + type: 'pkcs8', + format: 'pem' + } + }); + + return Buffer.from(pair.privateKey); +} + +exports.createPrivateRsaKey = createPrivateRsaKey; + + +/** + * Alias of `createPrivateRsaKey()` + * + * @function + */ + +exports.createPrivateKey = createPrivateRsaKey; + + +/** + * Generate a private ECDSA key + * + * @param {string} [namedCurve] ECDSA curve name (P-256, P-384 or P-521), default `P-256` + * @returns {Promise} PEM encoded private ECDSA key + * + * @example Generate private ECDSA key + * ```js + * const privateKey = await acme.crypto.createPrivateEcdsaKey(); + * ``` + * + * @example Private ECDSA key using P-384 curve + * ```js + * const privateKey = await acme.crypto.createPrivateEcdsaKey('P-384'); + * ``` + */ + +exports.createPrivateEcdsaKey = async (namedCurve = 'P-256') => { + const pair = await generateKeyPair('ec', { + namedCurve, + privateKeyEncoding: { + type: 'pkcs8', + format: 'pem' + } + }); + + return Buffer.from(pair.privateKey); +}; + + +/** + * Get a public key derived from a RSA or ECDSA key + * + * @param {buffer|string} keyPem PEM encoded private or public key + * @returns {buffer} PEM encoded public key + * + * @example Get public key + * ```js + * const publicKey = acme.crypto.getPublicKey(privateKey); + * ``` + */ + +exports.getPublicKey = (keyPem) => { + const info = getKeyInfo(keyPem); + + const publicKey = info.publicKey.export({ + type: info.isECDSA ? 'spki' : 'pkcs1', + format: 'pem' + }); + + return Buffer.from(publicKey); +}; + + +/** + * Get a JSON Web Key derived from a RSA or ECDSA key + * + * https://datatracker.ietf.org/doc/html/rfc7517 + * + * @param {buffer|string} keyPem PEM encoded private or public key + * @returns {object} JSON Web Key + * + * @example Get JWK + * ```js + * const jwk = acme.crypto.getJwk(privateKey); + * ``` + */ + +function getJwk(keyPem) { + const jwk = crypto.createPublicKey(keyPem).export({ + format: 'jwk' + }); + + /* Sort keys */ + return Object.keys(jwk).sort().reduce((result, k) => { + result[k] = jwk[k]; + return result; + }, {}); +} + +exports.getJwk = getJwk; + + +/** + * Fix missing support for NIST curve names in jsrsasign + * + * @private + * @param {string} crv NIST curve name + * @returns {string} SECG curve name + */ + +function convertNistCurveNameToSecg(nistName) { + switch (nistName) { + case 'P-256': + return 'secp256r1'; + case 'P-384': + return 'secp384r1'; + case 'P-521': + return 'secp521r1'; + default: + return nistName; + } +} + + +/** + * Split chain of PEM encoded objects from string into array + * + * @param {buffer|string} chainPem PEM encoded object chain + * @returns {array} Array of PEM objects including headers + */ + +function splitPemChain(chainPem) { + if (Buffer.isBuffer(chainPem)) { + chainPem = chainPem.toString(); + } + + return chainPem + /* Split chain into chunks, starting at every header */ + .split(/\s*(?=-----BEGIN [A-Z0-9- ]+-----\r?\n?)/g) + /* Match header, PEM body and footer */ + .map((pem) => pem.match(/\s*-----BEGIN ([A-Z0-9- ]+)-----\r?\n?([\S\s]+)\r?\n?-----END \1-----/)) + /* Filter out non-matches or empty bodies */ + .filter((pem) => pem && pem[2] && pem[2].replace(/[\r\n]+/g, '').trim()) + /* Decode to hex, and back to PEM for formatting etc */ + .map(([pem, header]) => jsrsasign.hextopem(jsrsasign.pemtohex(pem, header), header)); +} + +exports.splitPemChain = splitPemChain; + + +/** + * Parse body of PEM encoded object and return a Base64URL string + * If multiple objects are chained, the first body will be returned + * + * @param {buffer|string} pem PEM encoded chain or object + * @returns {string} Base64URL-encoded body + */ + +exports.getPemBodyAsB64u = (pem) => { + const chain = splitPemChain(pem); + + if (!chain.length) { + throw new Error('Unable to parse PEM body from string'); + } + + /* First object, hex and back to b64 without new lines */ + return jsrsasign.hextob64u(jsrsasign.pemtohex(chain[0])); +}; + + +/** + * Parse common name from a subject object + * + * @private + * @param {object} subj Subject returned from jsrsasign + * @returns {string} Common name value + */ + +function parseCommonName(subj) { + const subjectArr = (subj && subj.array) ? subj.array : []; + const cnArr = subjectArr.find((s) => (s[0] && s[0].type && s[0].value && (s[0].type === 'CN'))); + return (cnArr && cnArr.length && cnArr[0].value) ? cnArr[0].value : null; +} + + +/** + * Parse domains from a certificate or CSR + * + * @private + * @param {object} params Certificate or CSR params returned from jsrsasign + * @returns {object} {commonName, altNames} + */ + +function parseDomains(params) { + const commonName = parseCommonName(params.subject); + const extensionArr = (params.ext || params.extreq || []); + let altNames = []; + + if (extensionArr && extensionArr.length) { + const altNameExt = extensionArr.find((e) => (e.extname && (e.extname === 'subjectAltName'))); + const altNameArr = (altNameExt && altNameExt.array && altNameExt.array.length) ? altNameExt.array : []; + altNames = altNameArr.map((a) => Object.values(a)[0] || null).filter((a) => a); + } + + return { + commonName, + altNames + }; +} + + +/** + * Read domains from a Certificate Signing Request + * + * @param {buffer|string} csrPem PEM encoded Certificate Signing Request + * @returns {object} {commonName, altNames} + * + * @example Read Certificate Signing Request domains + * ```js + * const { commonName, altNames } = acme.crypto.readCsrDomains(certificateRequest); + * + * console.log(`Common name: ${commonName}`); + * console.log(`Alt names: ${altNames.join(', ')}`); + * ``` + */ + +exports.readCsrDomains = (csrPem) => { + if (Buffer.isBuffer(csrPem)) { + csrPem = csrPem.toString(); + } + + /* Parse CSR */ + const params = jsrsasign.KJUR.asn1.csr.CSRUtil.getParam(csrPem); + return parseDomains(params); +}; + + +/** + * Read information from a certificate + * If multiple certificates are chained, the first will be read + * + * @param {buffer|string} certPem PEM encoded certificate or chain + * @returns {object} Certificate info + * + * @example Read certificate information + * ```js + * const info = acme.crypto.readCertificateInfo(certificate); + * const { commonName, altNames } = info.domains; + * + * console.log(`Not after: ${info.notAfter}`); + * console.log(`Not before: ${info.notBefore}`); + * + * console.log(`Common name: ${commonName}`); + * console.log(`Alt names: ${altNames.join(', ')}`); + * ``` + */ + +exports.readCertificateInfo = (certPem) => { + const chain = splitPemChain(certPem); + + if (!chain.length) { + throw new Error('Unable to parse PEM body from string'); + } + + /* Parse certificate */ + const obj = new jsrsasign.X509(); + obj.readCertPEM(chain[0]); + const params = obj.getParam(); + + return { + issuer: { + commonName: parseCommonName(params.issuer) + }, + domains: parseDomains(params), + notBefore: jsrsasign.zulutodate(params.notbefore), + notAfter: jsrsasign.zulutodate(params.notafter) + }; +}; + + +/** + * Determine ASN.1 character string type for CSR subject field + * + * https://tools.ietf.org/html/rfc5280 + * https://github.com/kjur/jsrsasign/blob/2613c64559768b91dde9793dfa318feacb7c3b8a/src/x509-1.1.js#L2404-L2412 + * https://github.com/kjur/jsrsasign/blob/2613c64559768b91dde9793dfa318feacb7c3b8a/src/asn1x509-1.0.js#L3526-L3535 + * + * @private + * @param {string} field CSR subject field + * @returns {string} ASN.1 jsrsasign character string type + */ + +function getCsrAsn1CharStringType(field) { + switch (field) { + case 'C': + return 'prn'; + case 'E': + return 'ia5'; + default: + return 'utf8'; + } +} + + +/** + * Create array of subject fields for a Certificate Signing Request + * + * @private + * @param {object} input Key-value of subject fields + * @returns {object[]} Certificate Signing Request subject array + */ + +function createCsrSubject(input) { + return Object.entries(input).reduce((result, [type, value]) => { + if (value) { + const ds = getCsrAsn1CharStringType(type); + result.push([{ type, value, ds }]); + } + + return result; + }, []); +} + + +/** + * Create array of alt names for Certificate Signing Requests + * + * https://github.com/kjur/jsrsasign/blob/3edc0070846922daea98d9588978e91d855577ec/src/x509-1.1.js#L1355-L1410 + * + * @private + * @param {string[]} altNames Array of alt names + * @returns {object[]} Certificate Signing Request alt names array + */ + +function formatCsrAltNames(altNames) { + return altNames.map((value) => { + const key = net.isIP(value) ? 'ip' : 'dns'; + return { [key]: value }; + }); +} + + +/** + * Create a Certificate Signing Request + * + * @param {object} data + * @param {number} [data.keySize] Size of newly created RSA private key modulus in bits, default: `2048` + * @param {string} [data.commonName] FQDN of your server + * @param {array} [data.altNames] SAN (Subject Alternative Names), default: `[]` + * @param {string} [data.country] 2 letter country code + * @param {string} [data.state] State or province + * @param {string} [data.locality] City + * @param {string} [data.organization] Organization name + * @param {string} [data.organizationUnit] Organizational unit name + * @param {string} [data.emailAddress] Email address + * @param {string} [keyPem] PEM encoded CSR private key + * @returns {Promise} [privateKey, certificateSigningRequest] + * + * @example Create a Certificate Signing Request + * ```js + * const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + * commonName: 'test.example.com' + * }); + * ``` + * + * @example Certificate Signing Request with both common and alternative names + * ```js + * const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + * keySize: 4096, + * commonName: 'test.example.com', + * altNames: ['foo.example.com', 'bar.example.com'] + * }); + * ``` + * + * @example Certificate Signing Request with additional information + * ```js + * const [certificateKey, certificateRequest] = await acme.crypto.createCsr({ + * commonName: 'test.example.com', + * country: 'US', + * state: 'California', + * locality: 'Los Angeles', + * organization: 'The Company Inc.', + * organizationUnit: 'IT Department', + * emailAddress: 'contact@example.com' + * }); + * ``` + * + * @example Certificate Signing Request with ECDSA private key + * ```js + * const certificateKey = await acme.crypto.createPrivateEcdsaKey(); + * + * const [, certificateRequest] = await acme.crypto.createCsr({ + * commonName: 'test.example.com' + * }, certificateKey); + */ + +exports.createCsr = async (data, keyPem = null) => { + if (!keyPem) { + keyPem = await createPrivateRsaKey(data.keySize); + } + else if (!Buffer.isBuffer(keyPem)) { + keyPem = Buffer.from(keyPem); + } + + if (typeof data.altNames === 'undefined') { + data.altNames = []; + } + + /* Get key info and JWK */ + const info = getKeyInfo(keyPem); + const jwk = getJwk(keyPem); + const extensionRequests = []; + + /* Missing support for NIST curve names in jsrsasign - https://github.com/kjur/jsrsasign/blob/master/src/asn1x509-1.0.js#L4388-L4393 */ + if (jwk.crv && (jwk.kty === 'EC')) { + jwk.crv = convertNistCurveNameToSecg(jwk.crv); + } + + /* Ensure subject common name is present in SAN - https://cabforum.org/wp-content/uploads/BRv1.2.3.pdf */ + if (data.commonName && !data.altNames.includes(data.commonName)) { + data.altNames.unshift(data.commonName); + } + + /* Subject */ + const subject = createCsrSubject({ + CN: data.commonName, + C: data.country, + ST: data.state, + L: data.locality, + O: data.organization, + OU: data.organizationUnit, + E: data.emailAddress + }); + + /* SAN extension */ + if (data.altNames.length) { + extensionRequests.push({ + extname: 'subjectAltName', + array: formatCsrAltNames(data.altNames) + }); + } + + /* Create CSR */ + const csr = new jsrsasign.KJUR.asn1.csr.CertificationRequest({ + subject: { array: subject }, + sigalg: info.signatureAlgorithm, + sbjprvkey: keyPem.toString(), + sbjpubkey: jwk, + extreq: extensionRequests + }); + + /* Sign CSR, get PEM */ + csr.sign(); + const pem = csr.getPEM(); + + /* Done */ + return [keyPem, Buffer.from(pem)]; +}; diff --git a/packages/core/acme-client/src/http.js b/packages/core/acme-client/src/http.js new file mode 100644 index 00000000..49f79322 --- /dev/null +++ b/packages/core/acme-client/src/http.js @@ -0,0 +1,318 @@ +/** + * ACME HTTP client + */ + +const { createHmac, createSign, constants: { RSA_PKCS1_PADDING } } = require('crypto'); +const { getJwk } = require('./crypto'); +const { log } = require('./logger'); +const axios = require('./axios'); + + +/** + * ACME HTTP client + * + * @class + * @param {string} directoryUrl ACME directory URL + * @param {buffer} accountKey PEM encoded account private key + * @param {object} [opts.externalAccountBinding] + * @param {string} [opts.externalAccountBinding.kid] External account binding KID + * @param {string} [opts.externalAccountBinding.hmacKey] External account binding HMAC key + */ + +class HttpClient { + constructor(directoryUrl, accountKey, externalAccountBinding = {}) { + this.directoryUrl = directoryUrl; + this.accountKey = accountKey; + this.externalAccountBinding = externalAccountBinding; + + this.maxBadNonceRetries = 5; + this.directory = null; + this.jwk = null; + } + + + /** + * HTTP request + * + * @param {string} url HTTP URL + * @param {string} method HTTP method + * @param {object} [opts] Request options + * @returns {Promise} HTTP response + */ + + async request(url, method, opts = {}) { + opts.url = url; + opts.method = method; + opts.validateStatus = null; + + /* Headers */ + if (typeof opts.headers === 'undefined') { + opts.headers = {}; + } + + opts.headers['Content-Type'] = 'application/jose+json'; + + /* Request */ + log(`HTTP request: ${method} ${url}`); + const resp = await axios.request(opts); + + log(`RESP ${resp.status} ${method} ${url}`); + return resp; + } + + + /** + * Ensure provider directory exists + * + * https://tools.ietf.org/html/rfc8555#section-7.1.1 + * + * @returns {Promise} + */ + + async getDirectory() { + if (!this.directory) { + const resp = await this.request(this.directoryUrl, 'get'); + + if (resp.status >= 400) { + throw new Error(`Attempting to read ACME directory returned error ${resp.status}: ${this.directoryUrl}`); + } + + if (!resp.data) { + throw new Error('Attempting to read ACME directory returned no data'); + } + + this.directory = resp.data; + } + } + + + /** + * Get JSON Web Key + * + * @returns {object} JSON Web Key + */ + + getJwk() { + if (!this.jwk) { + this.jwk = getJwk(this.accountKey); + } + + return this.jwk; + } + + + /** + * Get nonce from directory API endpoint + * + * https://tools.ietf.org/html/rfc8555#section-7.2 + * + * @returns {Promise} nonce + */ + + async getNonce() { + const url = await this.getResourceUrl('newNonce'); + const resp = await this.request(url, 'head'); + + if (!resp.headers['replay-nonce']) { + throw new Error('Failed to get nonce from ACME provider'); + } + + return resp.headers['replay-nonce']; + } + + + /** + * Get URL for a directory resource + * + * @param {string} resource API resource name + * @returns {Promise} URL + */ + + async getResourceUrl(resource) { + await this.getDirectory(); + + if (!this.directory[resource]) { + throw new Error(`Unable to locate API resource URL in ACME directory: "${resource}"`); + } + + return this.directory[resource]; + } + + + /** + * Get directory meta field + * + * @param {string} field Meta field name + * @returns {Promise} Meta field value + */ + + async getMetaField(field) { + await this.getDirectory(); + + if (('meta' in this.directory) && (field in this.directory.meta)) { + return this.directory.meta[field]; + } + + return null; + } + + + /** + * Prepare HTTP request body for signature + * + * @param {string} alg JWS algorithm + * @param {string} url Request URL + * @param {object} [payload] Request payload + * @param {object} [opts] + * @param {string} [opts.nonce] JWS anti-replay nonce + * @param {string} [opts.kid] JWS KID + * @returns {object} Signed HTTP request body + */ + + prepareSignedBody(alg, url, payload = null, { nonce = null, kid = null } = {}) { + const header = { alg, url }; + + /* Nonce */ + if (nonce) { + log(`Using nonce: ${nonce}`); + header.nonce = nonce; + } + + /* KID or JWK */ + if (kid) { + header.kid = kid; + } + else { + header.jwk = this.getJwk(); + } + + /* Body */ + return { + payload: payload ? Buffer.from(JSON.stringify(payload)).toString('base64url') : '', + protected: Buffer.from(JSON.stringify(header)).toString('base64url') + }; + } + + + /** + * Create JWS HTTP request body using HMAC + * + * @param {string} hmacKey HMAC key + * @param {string} url Request URL + * @param {object} [payload] Request payload + * @param {object} [opts] + * @param {string} [opts.nonce] JWS anti-replay nonce + * @param {string} [opts.kid] JWS KID + * @returns {object} Signed HMAC request body + */ + + createSignedHmacBody(hmacKey, url, payload = null, { nonce = null, kid = null } = {}) { + const result = this.prepareSignedBody('HS256', url, payload, { nonce, kid }); + + /* Signature */ + const signer = createHmac('SHA256', Buffer.from(hmacKey, 'base64')).update(`${result.protected}.${result.payload}`, 'utf8'); + result.signature = signer.digest().toString('base64url'); + + return result; + } + + + /** + * Create JWS HTTP request body using RSA or ECC + * + * https://datatracker.ietf.org/doc/html/rfc7515 + * + * @param {string} url Request URL + * @param {object} [payload] Request payload + * @param {object} [opts] + * @param {string} [opts.nonce] JWS nonce + * @param {string} [opts.kid] JWS KID + * @returns {object} JWS request body + */ + + createSignedBody(url, payload = null, { nonce = null, kid = null } = {}) { + const jwk = this.getJwk(); + let headerAlg = 'RS256'; + let signerAlg = 'SHA256'; + + /* https://datatracker.ietf.org/doc/html/rfc7518#section-3.1 */ + if (jwk.crv && (jwk.kty === 'EC')) { + headerAlg = 'ES256'; + + if (jwk.crv === 'P-384') { + headerAlg = 'ES384'; + signerAlg = 'SHA384'; + } + else if (jwk.crv === 'P-521') { + headerAlg = 'ES512'; + signerAlg = 'SHA512'; + } + } + + /* Prepare body and signer */ + const result = this.prepareSignedBody(headerAlg, url, payload, { nonce, kid }); + const signer = createSign(signerAlg).update(`${result.protected}.${result.payload}`, 'utf8'); + + /* Signature - https://stackoverflow.com/questions/39554165 */ + result.signature = signer.sign({ + key: this.accountKey, + padding: RSA_PKCS1_PADDING, + dsaEncoding: 'ieee-p1363' + }, 'base64url'); + + return result; + } + + + /** + * Signed HTTP request + * + * https://tools.ietf.org/html/rfc8555#section-6.2 + * + * @param {string} url Request URL + * @param {object} payload Request payload + * @param {object} [opts] + * @param {string} [opts.kid] JWS KID + * @param {string} [opts.nonce] JWS anti-replay nonce + * @param {boolean} [opts.includeExternalAccountBinding] Include EAB in request + * @param {number} [attempts] Request attempt counter + * @returns {Promise} HTTP response + */ + + async signedRequest(url, payload, { kid = null, nonce = null, includeExternalAccountBinding = false } = {}, attempts = 0) { + if (!nonce) { + nonce = await this.getNonce(); + } + + /* External account binding */ + if (includeExternalAccountBinding && this.externalAccountBinding) { + if (this.externalAccountBinding.kid && this.externalAccountBinding.hmacKey) { + const jwk = this.getJwk(); + const eabKid = this.externalAccountBinding.kid; + const eabHmacKey = this.externalAccountBinding.hmacKey; + + payload.externalAccountBinding = this.createSignedHmacBody(eabHmacKey, url, jwk, { kid: eabKid }); + } + } + + /* Sign body and send request */ + const data = this.createSignedBody(url, payload, { nonce, kid }); + const resp = await this.request(url, 'post', { data }); + + /* Retry on bad nonce - https://tools.ietf.org/html/draft-ietf-acme-acme-10#section-6.4 */ + if (resp.data && resp.data.type && (resp.status === 400) && (resp.data.type === 'urn:ietf:params:acme:error:badNonce') && (attempts < this.maxBadNonceRetries)) { + nonce = resp.headers['replay-nonce'] || null; + attempts += 1; + + log(`Caught invalid nonce error, retrying (${attempts}/${this.maxBadNonceRetries}) signed request to: ${url}`); + return this.signedRequest(url, payload, { kid, nonce, includeExternalAccountBinding }, attempts); + } + + /* Return response */ + return resp; + } +} + + +/* Export client */ +module.exports = HttpClient; diff --git a/packages/core/acme-client/src/index.js b/packages/core/acme-client/src/index.js new file mode 100644 index 00000000..a2552e11 --- /dev/null +++ b/packages/core/acme-client/src/index.js @@ -0,0 +1,46 @@ +/** + * acme-client + */ + +exports.Client = require('./client'); + + +/** + * Directory URLs + */ + +exports.directory = { + buypass: { + staging: 'https://api.test4.buypass.no/acme/directory', + production: 'https://api.buypass.com/acme/directory' + }, + letsencrypt: { + staging: 'https://acme-staging-v02.api.letsencrypt.org/directory', + production: 'https://acme-v02.api.letsencrypt.org/directory' + }, + zerossl: { + production: 'https://acme.zerossl.com/v2/DV90' + } +}; + + +/** + * Crypto + */ + +exports.crypto = require('./crypto'); +exports.forge = require('./crypto/forge'); + + +/** + * Axios + */ + +exports.axios = require('./axios'); + + +/** + * Logger + */ + +exports.setLogger = require('./logger').setLogger; diff --git a/packages/core/acme-client/src/logger.js b/packages/core/acme-client/src/logger.js new file mode 100644 index 00000000..3d592409 --- /dev/null +++ b/packages/core/acme-client/src/logger.js @@ -0,0 +1,30 @@ +/** + * ACME logger + */ + +const debug = require('debug')('acme-client'); + +let logger = () => {}; + + +/** + * Set logger function + * + * @param {function} fn Logger function + */ + +exports.setLogger = (fn) => { + logger = fn; +}; + + +/** + * Log message + * + * @param {string} Message + */ + +exports.log = (msg) => { + debug(msg); + logger(msg); +}; diff --git a/packages/core/acme-client/src/util.js b/packages/core/acme-client/src/util.js new file mode 100644 index 00000000..95d08e81 --- /dev/null +++ b/packages/core/acme-client/src/util.js @@ -0,0 +1,258 @@ +/** + * Utility methods + */ + +const dns = require('dns').promises; +const { readCertificateInfo, splitPemChain } = require('./crypto'); +const { log } = require('./logger'); + + +/** + * Exponential backoff + * + * https://github.com/mokesmokes/backo + * + * @class + * @param {object} [opts] + * @param {number} [opts.min] Minimum backoff duration in ms + * @param {number} [opts.max] Maximum backoff duration in ms + */ + +class Backoff { + constructor({ min = 100, max = 10000 } = {}) { + this.min = min; + this.max = max; + this.attempts = 0; + } + + + /** + * Get backoff duration + * + * @returns {number} Backoff duration in ms + */ + + duration() { + const ms = this.min * (2 ** this.attempts); + this.attempts += 1; + return Math.min(ms, this.max); + } +} + + +/** + * Retry promise + * + * @param {function} fn Function returning promise that should be retried + * @param {number} attempts Maximum number of attempts + * @param {Backoff} backoff Backoff instance + * @returns {Promise} + */ + +async function retryPromise(fn, attempts, backoff) { + let aborted = false; + + try { + const data = await fn(() => { aborted = true; }); + return data; + } + catch (e) { + if (aborted || ((backoff.attempts + 1) >= attempts)) { + throw e; + } + + const duration = backoff.duration(); + log(`Promise rejected attempt #${backoff.attempts}, retrying in ${duration}ms: ${e.message}`); + + await new Promise((resolve) => { setTimeout(resolve, duration); }); + return retryPromise(fn, attempts, backoff); + } +} + + +/** + * Retry promise + * + * @param {function} fn Function returning promise that should be retried + * @param {object} [backoffOpts] Backoff options + * @param {number} [backoffOpts.attempts] Maximum number of attempts, default: `5` + * @param {number} [backoffOpts.min] Minimum attempt delay in milliseconds, default: `5000` + * @param {number} [backoffOpts.max] Maximum attempt delay in milliseconds, default: `30000` + * @returns {Promise} + */ + +function retry(fn, { attempts = 5, min = 5000, max = 30000 } = {}) { + const backoff = new Backoff({ min, max }); + return retryPromise(fn, attempts, backoff); +} + + +/** + * Parse URLs from link header + * + * @param {string} header Link header contents + * @param {string} rel Link relation, default: `alternate` + * @returns {array} Array of URLs + */ + +function parseLinkHeader(header, rel = 'alternate') { + const relRe = new RegExp(`\\s*rel\\s*=\\s*"?${rel}"?`, 'i'); + + const results = (header || '').split(/,\s* { + const [, linkUrl, linkParts] = link.match(/]*)>;(.*)/) || []; + return (linkUrl && linkParts && linkParts.match(relRe)) ? linkUrl : null; + }); + + return results.filter((r) => r); +} + + +/** + * Find certificate chain with preferred issuer common name + * - If issuer is found in multiple chains, the closest to root wins + * - If issuer can not be located, the first chain will be returned + * + * @param {array} certificates Array of PEM encoded certificate chains + * @param {string} issuer Preferred certificate issuer + * @returns {string} PEM encoded certificate chain + */ + +function findCertificateChainForIssuer(chains, issuer) { + log(`Attempting to find match for issuer="${issuer}" in ${chains.length} certificate chains`); + let bestMatch = null; + let bestDistance = null; + + chains.forEach((chain) => { + /* Look up all issuers */ + const certs = splitPemChain(chain); + const infoCollection = certs.map((c) => readCertificateInfo(c)); + const issuerCollection = infoCollection.map((i) => i.issuer.commonName); + + /* Found issuer match, get distance from root - lower is better */ + if (issuerCollection.includes(issuer)) { + const distance = (issuerCollection.length - issuerCollection.indexOf(issuer)); + log(`Found matching chain for preferred issuer="${issuer}" distance=${distance} issuers=${JSON.stringify(issuerCollection)}`); + + /* Chain wins, use it */ + if (!bestDistance || (distance < bestDistance)) { + log(`Issuer is closer to root than previous match, using it (${distance} < ${bestDistance || 'undefined'})`); + bestMatch = chain; + bestDistance = distance; + } + } + else { + /* No match */ + log(`Unable to match certificate for preferred issuer="${issuer}", issuers=${JSON.stringify(issuerCollection)}`); + } + }); + + /* Return found match */ + if (bestMatch) { + return bestMatch; + } + + /* No chains matched, return default */ + log(`Found no match in ${chains.length} certificate chains for preferred issuer="${issuer}", returning default certificate chain`); + return chains[0]; +} + + +/** + * Find and format error in response object + * + * @param {object} resp HTTP response + * @returns {string} Error message + */ + +function formatResponseError(resp) { + let result; + + if (resp.data.error) { + result = resp.data.error.detail || resp.data.error; + } + else { + result = resp.data.detail || JSON.stringify(resp.data); + } + + return result.replace(/\n/g, ''); +} + + +/** + * Resolve root domain name by looking for SOA record + * + * @param {string} recordName DNS record name + * @returns {Promise} Root domain name + */ + +async function resolveDomainBySoaRecord(recordName) { + try { + await dns.resolveSoa(recordName); + log(`Found SOA record, considering domain to be: ${recordName}`); + return recordName; + } + catch (e) { + log(`Unable to locate SOA record for name: ${recordName}`); + const parentRecordName = recordName.split('.').slice(1).join('.'); + + if (!parentRecordName.includes('.')) { + throw new Error('Unable to resolve domain by SOA record'); + } + + return resolveDomainBySoaRecord(parentRecordName); + } +} + + +/** + * Get DNS resolver using domains authoritative NS records + * + * @param {string} recordName DNS record name + * @returns {Promise} DNS resolver + */ + +async function getAuthoritativeDnsResolver(recordName) { + log(`Locating authoritative NS records for name: ${recordName}`); + const resolver = new dns.Resolver(); + + try { + /* Resolve root domain by SOA */ + const domain = await resolveDomainBySoaRecord(recordName); + + /* Resolve authoritative NS addresses */ + log(`Looking up authoritative NS records for domain: ${domain}`); + const nsRecords = await dns.resolveNs(domain); + const nsAddrArray = await Promise.all(nsRecords.map(async (r) => dns.resolve4(r))); + const nsAddresses = [].concat(...nsAddrArray).filter((a) => a); + + if (!nsAddresses.length) { + throw new Error(`Unable to locate any valid authoritative NS addresses for domain: ${domain}`); + } + + /* Authoritative NS success */ + log(`Found ${nsAddresses.length} authoritative NS addresses for domain: ${domain}`); + resolver.setServers(nsAddresses); + } + catch (e) { + log(`Authoritative NS lookup error: ${e.message}`); + } + + /* Return resolver */ + const addresses = resolver.getServers(); + log(`DNS resolver addresses: ${addresses.join(', ')}`); + + return resolver; +} + + +/** + * Export utils + */ + +module.exports = { + retry, + parseLinkHeader, + findCertificateChainForIssuer, + formatResponseError, + getAuthoritativeDnsResolver +}; diff --git a/packages/core/acme-client/src/verify.js b/packages/core/acme-client/src/verify.js new file mode 100644 index 00000000..fe76cab8 --- /dev/null +++ b/packages/core/acme-client/src/verify.js @@ -0,0 +1,127 @@ +/** + * ACME challenge verification + */ + +const dns = require('dns').promises; +const { log } = require('./logger'); +const axios = require('./axios'); +const util = require('./util'); + + +/** + * Verify ACME HTTP challenge + * + * https://tools.ietf.org/html/rfc8555#section-8.3 + * + * @param {object} authz Identifier authorization + * @param {object} challenge Authorization challenge + * @param {string} keyAuthorization Challenge key authorization + * @param {string} [suffix] URL suffix + * @returns {Promise} + */ + +async function verifyHttpChallenge(authz, challenge, keyAuthorization, suffix = `/.well-known/acme-challenge/${challenge.token}`) { + const httpPort = axios.defaults.acmeSettings.httpChallengePort || 80; + const challengeUrl = `http://${authz.identifier.value}:${httpPort}${suffix}`; + + log(`Sending HTTP query to ${authz.identifier.value}, suffix: ${suffix}, port: ${httpPort}`); + const resp = await axios.get(challengeUrl); + const data = (resp.data || '').replace(/\s+$/, ''); + + log(`Query successful, HTTP status code: ${resp.status}`); + + if (!data || (data !== keyAuthorization)) { + throw new Error(`Authorization not found in HTTP response from ${authz.identifier.value}`); + } + + log(`Key authorization match for ${challenge.type}/${authz.identifier.value}, ACME challenge verified`); + return true; +} + + +/** + * Walk DNS until TXT records are found + */ + +async function walkDnsChallengeRecord(recordName, resolver = dns) { + /* Resolve CNAME record first */ + try { + log(`Checking name for CNAME records: ${recordName}`); + const cnameRecords = await resolver.resolveCname(recordName); + + if (cnameRecords.length) { + log(`CNAME record found at ${recordName}, new challenge record name: ${cnameRecords[0]}`); + return walkDnsChallengeRecord(cnameRecords[0]); + } + } + catch (e) { + log(`No CNAME records found for name: ${recordName}`); + } + + /* Resolve TXT records */ + try { + log(`Checking name for TXT records: ${recordName}`); + const txtRecords = await resolver.resolveTxt(recordName); + + if (txtRecords.length) { + log(`Found ${txtRecords.length} TXT records at ${recordName}`); + return [].concat(...txtRecords); + } + } + catch (e) { + log(`No TXT records found for name: ${recordName}`); + } + + /* Found nothing */ + throw new Error(`No TXT records found for name: ${recordName}`); +} + + +/** + * Verify ACME DNS challenge + * + * https://tools.ietf.org/html/rfc8555#section-8.4 + * + * @param {object} authz Identifier authorization + * @param {object} challenge Authorization challenge + * @param {string} keyAuthorization Challenge key authorization + * @param {string} [prefix] DNS prefix + * @returns {Promise} + */ + +async function verifyDnsChallenge(authz, challenge, keyAuthorization, prefix = '_acme-challenge.') { + let recordValues = []; + const recordName = `${prefix}${authz.identifier.value}`; + log(`Resolving DNS TXT from record: ${recordName}`); + + try { + /* Default DNS resolver first */ + log('Attempting to resolve TXT with default DNS resolver first'); + recordValues = await walkDnsChallengeRecord(recordName); + } + catch (e) { + /* Authoritative DNS resolver */ + log(`Error using default resolver, attempting to resolve TXT with authoritative NS: ${e.message}`); + const authoritativeResolver = await util.getAuthoritativeDnsResolver(recordName); + recordValues = await walkDnsChallengeRecord(recordName, authoritativeResolver); + } + + log(`DNS query finished successfully, found ${recordValues.length} TXT records`); + + if (!recordValues.length || !recordValues.includes(keyAuthorization)) { + throw new Error(`Authorization not found in DNS TXT record: ${recordName}`); + } + + log(`Key authorization match for ${challenge.type}/${recordName}, ACME challenge verified`); + return true; +} + + +/** + * Export API + */ + +module.exports = { + 'http-01': verifyHttpChallenge, + 'dns-01': verifyDnsChallenge +}; diff --git a/packages/core/acme-client/test/00-pebble.spec.js b/packages/core/acme-client/test/00-pebble.spec.js new file mode 100644 index 00000000..789c0a4c --- /dev/null +++ b/packages/core/acme-client/test/00-pebble.spec.js @@ -0,0 +1,121 @@ +/** + * Pebble Challenge Test Server tests + */ + +const dns = require('dns').promises; +const { assert } = require('chai'); +const { v4: uuid } = require('uuid'); +const cts = require('./challtestsrv'); +const axios = require('./../src/axios'); + +const domainName = process.env.ACME_DOMAIN_NAME || 'example.com'; +const httpPort = axios.defaults.acmeSettings.httpChallengePort || 80; + + +describe('pebble', () => { + const testAHost = `${uuid()}.${domainName}`; + const testARecords = ['1.1.1.1', '2.2.2.2']; + const testCnameHost = `${uuid()}.${domainName}`; + const testCnameRecord = `${uuid()}.${domainName}`; + + const testHttp01ChallengeHost = `${uuid()}.${domainName}`; + const testHttp01ChallengeToken = uuid(); + const testHttp01ChallengeContent = uuid(); + const testDns01ChallengeHost = `_acme-challenge.${uuid()}.${domainName}.`; + const testDns01ChallengeValue = uuid(); + + + /** + * Pebble CTS required + */ + + before(function() { + if (!cts.isEnabled()) { + this.skip(); + } + }); + + + /** + * DNS mocking + */ + + describe('dns', () => { + it('should not locate a records', async () => { + const resp = await dns.resolve4(testAHost); + + assert.isArray(resp); + assert.notDeepEqual(resp, testARecords); + }); + + it('should add dns a records', async () => { + const resp = await cts.addDnsARecord(testAHost, testARecords); + assert.isTrue(resp); + }); + + it('should locate a records', async () => { + const resp = await dns.resolve4(testAHost); + + assert.isArray(resp); + assert.deepStrictEqual(resp, testARecords); + }); + + it('should not locate cname records', async () => { + await assert.isRejected(dns.resolveCname(testCnameHost)); + }); + + it('should set dns cname record', async () => { + const resp = await cts.setDnsCnameRecord(testCnameHost, testCnameRecord); + assert.isTrue(resp); + }); + + it('should locate cname record', async () => { + const resp = await dns.resolveCname(testCnameHost); + + assert.isArray(resp); + assert.deepStrictEqual(resp, [testCnameRecord]); + }); + }); + + + /** + * Challenge response + */ + + describe('challenges', () => { + it('should not locate http-01 challenge response', async () => { + const resp = await axios.get(`http://${testHttp01ChallengeHost}:${httpPort}/.well-known/acme-challenge/${testHttp01ChallengeToken}`); + + assert.isString(resp.data); + assert.notEqual(resp.data, testHttp01ChallengeContent); + }); + + it('should add http-01 challenge response', async () => { + const resp = await cts.addHttp01ChallengeResponse(testHttp01ChallengeToken, testHttp01ChallengeContent); + assert.isTrue(resp); + }); + + it('should locate http-01 challenge response', async () => { + const resp = await axios.get(`http://${testHttp01ChallengeHost}:${httpPort}/.well-known/acme-challenge/${testHttp01ChallengeToken}`); + + assert.isString(resp.data); + assert.strictEqual(resp.data, testHttp01ChallengeContent); + }); + + it('should not locate dns-01 challenge response', async () => { + await assert.isRejected(dns.resolveTxt(testDns01ChallengeHost)); + }); + + it('should add dns-01 challenge response', async () => { + const resp = await cts.addDns01ChallengeResponse(testDns01ChallengeHost, testDns01ChallengeValue); + assert.isTrue(resp); + }); + + it('should locate dns-01 challenge response', async () => { + const resp = await dns.resolveTxt(testDns01ChallengeHost); + + assert.isArray(resp); + assert.deepStrictEqual(resp, [[testDns01ChallengeValue]]); + }); + }); +}); diff --git a/packages/core/acme-client/test/10-http.spec.js b/packages/core/acme-client/test/10-http.spec.js new file mode 100644 index 00000000..e8163af5 --- /dev/null +++ b/packages/core/acme-client/test/10-http.spec.js @@ -0,0 +1,101 @@ +/** + * HTTP client tests + */ + +const { assert } = require('chai'); +const { v4: uuid } = require('uuid'); +const nock = require('nock'); +const axios = require('./../src/axios'); +const HttpClient = require('./../src/http'); +const pkg = require('./../package.json'); + + +describe('http', () => { + let testClient; + + const defaultUserAgent = `node-${pkg.name}/${pkg.version}`; + const customUserAgent = 'custom-ua-123'; + + const primaryEndpoint = `http://${uuid()}.example.com`; + const defaultUaEndpoint = `http://${uuid()}.example.com`; + const customUaEndpoint = `http://${uuid()}.example.com`; + + + /** + * HTTP mocking + */ + + before(() => { + axios.defaults.acmeSettings.bypassCustomDnsResolver = true; + + const defaultUaOpts = { reqheaders: { 'User-Agent': defaultUserAgent } }; + const customUaOpts = { reqheaders: { 'User-Agent': customUserAgent } }; + + nock(primaryEndpoint) + .persist().get('/').reply(200, 'ok'); + + nock(defaultUaEndpoint, defaultUaOpts) + .persist().get('/').reply(200, 'ok'); + + nock(customUaEndpoint, customUaOpts) + .persist().get('/').reply(200, 'ok'); + }); + + after(() => { + axios.defaults.headers.common['User-Agent'] = defaultUserAgent; + axios.defaults.acmeSettings.bypassCustomDnsResolver = false; + }); + + + /** + * Initialize + */ + + it('should initialize clients', () => { + testClient = new HttpClient(); + }); + + + /** + * HTTP verbs + */ + + it('should http get', async () => { + const resp = await testClient.request(primaryEndpoint, 'get'); + + assert.isObject(resp); + assert.strictEqual(resp.status, 200); + assert.strictEqual(resp.data, 'ok'); + }); + + + /** + * User-Agent + */ + + it('should request using default user-agent', async () => { + const resp = await testClient.request(defaultUaEndpoint, 'get'); + + assert.isObject(resp); + assert.strictEqual(resp.status, 200); + assert.strictEqual(resp.data, 'ok'); + }); + + it('should not request using custom user-agent', async () => { + await assert.isRejected(testClient.request(customUaEndpoint, 'get')); + }); + + it('should request using custom user-agent', async () => { + axios.defaults.headers.common['User-Agent'] = customUserAgent; + const resp = await testClient.request(customUaEndpoint, 'get'); + + assert.isObject(resp); + assert.strictEqual(resp.status, 200); + assert.strictEqual(resp.data, 'ok'); + }); + + it('should not request using default user-agent', async () => { + axios.defaults.headers.common['User-Agent'] = customUserAgent; + await assert.isRejected(testClient.request(defaultUaEndpoint, 'get')); + }); +}); diff --git a/packages/core/acme-client/test/10-logger.spec.js b/packages/core/acme-client/test/10-logger.spec.js new file mode 100644 index 00000000..ac9200bc --- /dev/null +++ b/packages/core/acme-client/test/10-logger.spec.js @@ -0,0 +1,35 @@ +/** + * Logger tests + */ + +const { assert } = require('chai'); +const logger = require('./../src/logger'); + + +describe('logger', () => { + let lastLogMessage = null; + + function customLoggerFn(msg) { + lastLogMessage = msg; + } + + + /** + * Logger + */ + + it('should log without custom logger', () => { + logger.log('something'); + assert.isNull(lastLogMessage); + }); + + + it('should log with custom logger', () => { + logger.setLogger(customLoggerFn); + + ['abc123', 'def456', 'ghi789'].forEach((m) => { + logger.log(m); + assert.strictEqual(lastLogMessage, m); + }); + }); +}); diff --git a/packages/core/acme-client/test/10-verify.spec.js b/packages/core/acme-client/test/10-verify.spec.js new file mode 100644 index 00000000..adbd370e --- /dev/null +++ b/packages/core/acme-client/test/10-verify.spec.js @@ -0,0 +1,106 @@ +/** + * Challenge verification tests + */ + +const { assert } = require('chai'); +const { v4: uuid } = require('uuid'); +const cts = require('./challtestsrv'); +const verify = require('./../src/verify'); + +const domainName = process.env.ACME_DOMAIN_NAME || 'example.com'; + + +describe('verify', () => { + const challengeTypes = ['http-01', 'dns-01']; + + const testHttp01Authz = { identifier: { type: 'dns', value: `${uuid()}.${domainName}` } }; + const testHttp01Challenge = { type: 'http-01', status: 'pending', token: uuid() }; + const testHttp01Key = uuid(); + + const testDns01Authz = { identifier: { type: 'dns', value: `${uuid()}.${domainName}` } }; + const testDns01Challenge = { type: 'dns-01', status: 'pending', token: uuid() }; + const testDns01Key = uuid(); + const testDns01Cname = `${uuid()}.${domainName}`; + + + /** + * Pebble CTS required + */ + + before(function() { + if (!cts.isEnabled()) { + this.skip(); + } + }); + + + /** + * API + */ + + it('should expose verification api', async () => { + assert.containsAllKeys(verify, challengeTypes); + }); + + + /** + * http-01 + */ + + describe('http-01', () => { + it('should reject challenge', async () => { + await assert.isRejected(verify['http-01'](testHttp01Authz, testHttp01Challenge, testHttp01Key)); + }); + + it('should mock challenge response', async () => { + const resp = await cts.addHttp01ChallengeResponse(testHttp01Challenge.token, testHttp01Key); + assert.isTrue(resp); + }); + + it('should verify challenge', async () => { + const resp = await verify['http-01'](testHttp01Authz, testHttp01Challenge, testHttp01Key); + assert.isTrue(resp); + }); + + it('should mock challenge response with trailing newline', async () => { + const resp = await cts.addHttp01ChallengeResponse(testHttp01Challenge.token, `${testHttp01Key}\n`); + assert.isTrue(resp); + }); + + it('should verify challenge with trailing newline', async () => { + const resp = await verify['http-01'](testHttp01Authz, testHttp01Challenge, testHttp01Key); + assert.isTrue(resp); + }); + }); + + + /** + * dns-01 + */ + + describe('dns-01', () => { + it('should reject challenge', async () => { + await assert.isRejected(verify['dns-01'](testDns01Authz, testDns01Challenge, testDns01Key)); + }); + + it('should mock challenge response', async () => { + const resp = await cts.addDns01ChallengeResponse(`_acme-challenge.${testDns01Authz.identifier.value}.`, testDns01Key); + assert.isTrue(resp); + }); + + it('should add cname to challenge response', async () => { + const resp = await cts.setDnsCnameRecord(testDns01Cname, `_acme-challenge.${testDns01Authz.identifier.value}.`); + assert.isTrue(resp); + }); + + it('should verify challenge', async () => { + const resp = await verify['dns-01'](testDns01Authz, testDns01Challenge, testDns01Key); + assert.isTrue(resp); + }); + + it('should verify challenge using cname', async () => { + const resp = await verify['dns-01'](testDns01Authz, testDns01Challenge, testDns01Key); + assert.isTrue(resp); + }); + }); +}); diff --git a/packages/core/acme-client/test/20-crypto-legacy.spec.js b/packages/core/acme-client/test/20-crypto-legacy.spec.js new file mode 100644 index 00000000..b039e74a --- /dev/null +++ b/packages/core/acme-client/test/20-crypto-legacy.spec.js @@ -0,0 +1,276 @@ +/** + * Legacy crypto tests + */ + +const fs = require('fs').promises; +const path = require('path'); +const { assert } = require('chai'); +const spec = require('./spec'); +const forge = require('./../src/crypto/forge'); + +const cryptoEngines = { + forge +}; + + +describe('crypto-legacy', () => { + let testPemKey; + let testCert; + let testSanCert; + + const modulusStore = []; + const exponentStore = []; + const publicKeyStore = []; + + const testCsrDomain = 'example.com'; + const testSanCsrDomains = ['example.com', 'test.example.com', 'abc.example.com']; + const testKeyPath = path.join(__dirname, 'fixtures', 'private.key'); + const testCertPath = path.join(__dirname, 'fixtures', 'certificate.crt'); + const testSanCertPath = path.join(__dirname, 'fixtures', 'san-certificate.crt'); + + + /** + * Fixtures + */ + + describe('fixtures', () => { + it('should read private key fixture', async () => { + testPemKey = await fs.readFile(testKeyPath); + assert.isTrue(Buffer.isBuffer(testPemKey)); + }); + + it('should read certificate fixture', async () => { + testCert = await fs.readFile(testCertPath); + assert.isTrue(Buffer.isBuffer(testCert)); + }); + + it('should read san certificate fixture', async () => { + testSanCert = await fs.readFile(testSanCertPath); + assert.isTrue(Buffer.isBuffer(testSanCert)); + }); + }); + + + /** + * Engines + */ + + Object.entries(cryptoEngines).forEach(([name, engine]) => { + describe(`engine/${name}`, () => { + let testCsr; + let testSanCsr; + let testNonCnCsr; + let testNonAsciiCsr; + + + /** + * Key generation + */ + + it('should generate a private key', async () => { + const key = await engine.createPrivateKey(); + assert.isTrue(Buffer.isBuffer(key)); + }); + + it('should generate a private key with size=1024', async () => { + const key = await engine.createPrivateKey(1024); + assert.isTrue(Buffer.isBuffer(key)); + }); + + it('should generate a public key', async () => { + const key = await engine.createPublicKey(testPemKey); + assert.isTrue(Buffer.isBuffer(key)); + publicKeyStore.push(key.toString().replace(/[\r\n]/gm, '')); + }); + + + /** + * Certificate Signing Request + */ + + it('should generate a csr', async () => { + const [key, csr] = await engine.createCsr({ + commonName: testCsrDomain + }); + + assert.isTrue(Buffer.isBuffer(key)); + assert.isTrue(Buffer.isBuffer(csr)); + + testCsr = csr; + }); + + it('should generate a san csr', async () => { + const [key, csr] = await engine.createCsr({ + commonName: testSanCsrDomains[0], + altNames: testSanCsrDomains.slice(1, testSanCsrDomains.length) + }); + + assert.isTrue(Buffer.isBuffer(key)); + assert.isTrue(Buffer.isBuffer(csr)); + + testSanCsr = csr; + }); + + it('should generate a csr without common name', async () => { + const [key, csr] = await engine.createCsr({ + altNames: testSanCsrDomains + }); + + assert.isTrue(Buffer.isBuffer(key)); + assert.isTrue(Buffer.isBuffer(csr)); + + testNonCnCsr = csr; + }); + + it('should generate a non-ascii csr', async () => { + const [key, csr] = await engine.createCsr({ + commonName: testCsrDomain, + organization: '大安區', + organizationUnit: '中文部門' + }); + + assert.isTrue(Buffer.isBuffer(key)); + assert.isTrue(Buffer.isBuffer(csr)); + + testNonAsciiCsr = csr; + }); + + it('should resolve domains from csr', async () => { + const result = await engine.readCsrDomains(testCsr); + + spec.crypto.csrDomains(result); + assert.strictEqual(result.commonName, testCsrDomain); + assert.deepStrictEqual(result.altNames, [testCsrDomain]); + }); + + it('should resolve domains from san csr', async () => { + const result = await engine.readCsrDomains(testSanCsr); + + spec.crypto.csrDomains(result); + assert.strictEqual(result.commonName, testSanCsrDomains[0]); + assert.deepStrictEqual(result.altNames, testSanCsrDomains); + }); + + it('should resolve domains from san without common name', async () => { + const result = await engine.readCsrDomains(testNonCnCsr); + + spec.crypto.csrDomains(result); + assert.isNull(result.commonName); + assert.deepStrictEqual(result.altNames, testSanCsrDomains); + }); + + it('should resolve domains from non-ascii csr', async () => { + const result = await engine.readCsrDomains(testNonAsciiCsr); + + spec.crypto.csrDomains(result); + assert.strictEqual(result.commonName, testCsrDomain); + assert.deepStrictEqual(result.altNames, [testCsrDomain]); + }); + + + /** + * Certificate + */ + + it('should read info from certificate', async () => { + const info = await engine.readCertificateInfo(testCert); + + spec.crypto.certificateInfo(info); + assert.strictEqual(info.domains.commonName, testCsrDomain); + assert.strictEqual(info.domains.altNames.length, 0); + }); + + it('should read info from san certificate', async () => { + const info = await engine.readCertificateInfo(testSanCert); + + spec.crypto.certificateInfo(info); + assert.strictEqual(info.domains.commonName, testSanCsrDomains[0]); + assert.deepEqual(info.domains.altNames, testSanCsrDomains.slice(1, testSanCsrDomains.length)); + }); + + + /** + * PEM utils + */ + + it('should get pem body', () => { + [testPemKey, testCert, testSanCert].forEach((pem) => { + const body = engine.getPemBody(pem); + + assert.isString(body); + assert.notInclude(body, '\r'); + assert.notInclude(body, '\n'); + assert.notInclude(body, '\r\n'); + }); + }); + + it('should split pem chain', () => { + [testPemKey, testCert, testSanCert].forEach((pem) => { + const chain = engine.splitPemChain(pem); + + assert.isArray(chain); + assert.isNotEmpty(chain); + chain.forEach((c) => assert.isString(c)); + }); + }); + + + /** + * Modulus and exponent + */ + + it('should get modulus', async () => { + const result = await Promise.all([testPemKey, testCert, testSanCert].map(async (item) => { + const mod = await engine.getModulus(item); + assert.isTrue(Buffer.isBuffer(mod)); + + return mod; + })); + + modulusStore.push(result); + }); + + it('should get public exponent', async () => { + const result = await Promise.all([testPemKey, testCert, testSanCert].map(async (item) => { + const exp = await engine.getPublicExponent(item); + assert.isTrue(Buffer.isBuffer(exp)); + + const b64exp = exp.toString('base64'); + assert.strictEqual(b64exp, 'AQAB'); + + return b64exp; + })); + + exponentStore.push(result); + }); + }); + }); + + + /** + * Verify identical results + */ + + describe('verification', () => { + it('should have identical public keys', () => { + if (publicKeyStore.length > 1) { + const reference = publicKeyStore.shift(); + publicKeyStore.forEach((item) => assert.strictEqual(reference, item)); + } + }); + + it('should have identical moduli', () => { + if (modulusStore.length > 1) { + const reference = modulusStore.shift(); + modulusStore.forEach((item) => assert.deepStrictEqual(reference, item)); + } + }); + + it('should have identical public exponents', () => { + if (exponentStore.length > 1) { + const reference = exponentStore.shift(); + exponentStore.forEach((item) => assert.deepStrictEqual(reference, item)); + } + }); + }); +}); diff --git a/packages/core/acme-client/test/20-crypto.spec.js b/packages/core/acme-client/test/20-crypto.spec.js new file mode 100644 index 00000000..8441af55 --- /dev/null +++ b/packages/core/acme-client/test/20-crypto.spec.js @@ -0,0 +1,317 @@ +/** + * Crypto tests + */ + +const fs = require('fs').promises; +const path = require('path'); +const { assert } = require('chai'); +const spec = require('./spec'); +const { crypto } = require('./../'); + +const emptyBodyChain1 = ` +-----BEGIN TEST----- +a +-----END TEST----- +-----BEGIN TEST----- +b +-----END TEST----- + +-----BEGIN TEST----- + +-----END TEST----- + + +-----BEGIN TEST----- +c +-----END TEST----- +`; + +const emptyBodyChain2 = ` + + +-----BEGIN TEST----- +-----END TEST----- +-----BEGIN TEST----- + + + +-----END TEST----- + +-----BEGIN TEST----- +a +-----END TEST----- + + +-----BEGIN TEST----- +b +-----END TEST----- +-----BEGIN TEST----- +c +-----END TEST----- +`; + + +describe('crypto', () => { + const testCsrDomain = 'example.com'; + const testSanCsrDomains = ['example.com', 'test.example.com', 'abc.example.com']; + const testKeyPath = path.join(__dirname, 'fixtures', 'private.key'); + const testCertPath = path.join(__dirname, 'fixtures', 'certificate.crt'); + const testSanCertPath = path.join(__dirname, 'fixtures', 'san-certificate.crt'); + + + /** + * Key types + */ + + Object.entries({ + rsa: { + createKeyFns: { + s1024: () => crypto.createPrivateRsaKey(1024), + s2048: () => crypto.createPrivateRsaKey(), + s4096: () => crypto.createPrivateRsaKey(4096) + }, + jwkSpecFn: spec.jwk.rsa + }, + ecdsa: { + createKeyFns: { + p256: () => crypto.createPrivateEcdsaKey(), + p384: () => crypto.createPrivateEcdsaKey('P-384'), + p521: () => crypto.createPrivateEcdsaKey('P-521') + }, + jwkSpecFn: spec.jwk.ecdsa + } + }).forEach(([name, { createKeyFns, jwkSpecFn }]) => { + describe(name, () => { + const testPrivateKeys = {}; + const testPublicKeys = {}; + + + /** + * Iterate through all generator variations + */ + + Object.entries(createKeyFns).forEach(([n, createFn]) => { + let testCsr; + let testSanCsr; + let testNonCnCsr; + let testNonAsciiCsr; + + + /** + * Keys and JWK + */ + + it(`${n}/should generate private key`, async () => { + testPrivateKeys[n] = await createFn(); + assert.isTrue(Buffer.isBuffer(testPrivateKeys[n])); + }); + + it(`${n}/should get public key`, () => { + testPublicKeys[n] = crypto.getPublicKey(testPrivateKeys[n]); + assert.isTrue(Buffer.isBuffer(testPublicKeys[n])); + }); + + it(`${n}/should get jwk from private key`, () => { + const jwk = crypto.getJwk(testPrivateKeys[n]); + jwkSpecFn(jwk); + }); + + it(`${n}/should get jwk from public key`, () => { + const jwk = crypto.getJwk(testPublicKeys[n]); + jwkSpecFn(jwk); + }); + + + /** + * Certificate Signing Request + */ + + it(`${n}/should generate a csr`, async () => { + const [key, csr] = await crypto.createCsr({ + commonName: testCsrDomain + }, testPrivateKeys[n]); + + assert.isTrue(Buffer.isBuffer(key)); + assert.isTrue(Buffer.isBuffer(csr)); + + testCsr = csr; + }); + + it(`${n}/should generate a san csr`, async () => { + const [key, csr] = await crypto.createCsr({ + commonName: testSanCsrDomains[0], + altNames: testSanCsrDomains.slice(1, testSanCsrDomains.length) + }, testPrivateKeys[n]); + + assert.isTrue(Buffer.isBuffer(key)); + assert.isTrue(Buffer.isBuffer(csr)); + + testSanCsr = csr; + }); + + it(`${n}/should generate a csr without common name`, async () => { + const [key, csr] = await crypto.createCsr({ + altNames: testSanCsrDomains + }, testPrivateKeys[n]); + + assert.isTrue(Buffer.isBuffer(key)); + assert.isTrue(Buffer.isBuffer(csr)); + + testNonCnCsr = csr; + }); + + it(`${n}/should generate a non-ascii csr`, async () => { + const [key, csr] = await crypto.createCsr({ + commonName: testCsrDomain, + organization: '大安區', + organizationUnit: '中文部門' + }, testPrivateKeys[n]); + + assert.isTrue(Buffer.isBuffer(key)); + assert.isTrue(Buffer.isBuffer(csr)); + + testNonAsciiCsr = csr; + }); + + it(`${n}/should throw with invalid key`, async () => { + await assert.isRejected(crypto.createCsr({ + commonName: testCsrDomain + }, testPublicKeys[n])); + }); + + + /** + * Domain and info resolver + */ + + it(`${n}/should resolve domains from csr`, () => { + const result = crypto.readCsrDomains(testCsr); + + spec.crypto.csrDomains(result); + assert.strictEqual(result.commonName, testCsrDomain); + assert.deepStrictEqual(result.altNames, [testCsrDomain]); + }); + + it(`${n}/should resolve domains from san csr`, () => { + const result = crypto.readCsrDomains(testSanCsr); + + spec.crypto.csrDomains(result); + assert.strictEqual(result.commonName, testSanCsrDomains[0]); + assert.deepStrictEqual(result.altNames, testSanCsrDomains); + }); + + it(`${n}/should resolve domains from csr without common name`, () => { + const result = crypto.readCsrDomains(testNonCnCsr); + + spec.crypto.csrDomains(result); + assert.isNull(result.commonName); + assert.deepStrictEqual(result.altNames, testSanCsrDomains); + }); + + it(`${n}/should resolve domains from non-ascii csr`, () => { + const result = crypto.readCsrDomains(testNonAsciiCsr); + + spec.crypto.csrDomains(result); + assert.strictEqual(result.commonName, testCsrDomain); + assert.deepStrictEqual(result.altNames, [testCsrDomain]); + }); + }); + }); + }); + + + /** + * Common functionality + */ + + describe('common', () => { + let testPemKey; + let testCert; + let testSanCert; + + + it('should read private key fixture', async () => { + testPemKey = await fs.readFile(testKeyPath); + assert.isTrue(Buffer.isBuffer(testPemKey)); + }); + + it('should read certificate fixture', async () => { + testCert = await fs.readFile(testCertPath); + assert.isTrue(Buffer.isBuffer(testCert)); + }); + + it('should read san certificate fixture', async () => { + testSanCert = await fs.readFile(testSanCertPath); + assert.isTrue(Buffer.isBuffer(testSanCert)); + }); + + + /** + * CSR with auto-generated key + */ + + it('should generate a csr with auto-generated key', async () => { + const [key, csr] = await crypto.createCsr({ + commonName: testCsrDomain + }); + + assert.isTrue(Buffer.isBuffer(key)); + assert.isTrue(Buffer.isBuffer(csr)); + }); + + + /** + * Certificate + */ + + it('should read certificate info', () => { + const info = crypto.readCertificateInfo(testCert); + + spec.crypto.certificateInfo(info); + assert.strictEqual(info.domains.commonName, testCsrDomain); + assert.strictEqual(info.domains.altNames.length, 0); + }); + + it('should read certificate info with san', () => { + const info = crypto.readCertificateInfo(testSanCert); + + spec.crypto.certificateInfo(info); + assert.strictEqual(info.domains.commonName, testSanCsrDomains[0]); + assert.deepEqual(info.domains.altNames, testSanCsrDomains.slice(1, testSanCsrDomains.length)); + }); + + + /** + * PEM utils + */ + + it('should get pem body as b64u', () => { + [testPemKey, testCert, testSanCert].forEach((pem) => { + const body = crypto.getPemBodyAsB64u(pem); + + assert.isString(body); + assert.notInclude(body, '\r'); + assert.notInclude(body, '\n'); + assert.notInclude(body, '\r\n'); + }); + }); + + it('should split pem chain', () => { + [testPemKey, testCert, testSanCert].forEach((pem) => { + const chain = crypto.splitPemChain(pem); + + assert.isArray(chain); + assert.isNotEmpty(chain); + chain.forEach((c) => assert.isString(c)); + }); + }); + + it('should split pem chain with empty bodies', () => { + const c1 = crypto.splitPemChain(emptyBodyChain1); + const c2 = crypto.splitPemChain(emptyBodyChain2); + + assert.strictEqual(c1.length, 3); + assert.strictEqual(c2.length, 3); + }); + }); +}); diff --git a/packages/core/acme-client/test/50-client.spec.js b/packages/core/acme-client/test/50-client.spec.js new file mode 100644 index 00000000..cb162644 --- /dev/null +++ b/packages/core/acme-client/test/50-client.spec.js @@ -0,0 +1,574 @@ +/** + * ACME client tests + */ + +const { assert } = require('chai'); +const { v4: uuid } = require('uuid'); +const cts = require('./challtestsrv'); +const getCertIssuers = require('./get-cert-issuers'); +const spec = require('./spec'); +const acme = require('./../'); + +const domainName = process.env.ACME_DOMAIN_NAME || 'example.com'; +const directoryUrl = process.env.ACME_DIRECTORY_URL || acme.directory.letsencrypt.staging; +const capEabEnabled = (('ACME_CAP_EAB_ENABLED' in process.env) && (process.env.ACME_CAP_EAB_ENABLED === '1')); +const capMetaTosField = !(('ACME_CAP_META_TOS_FIELD' in process.env) && (process.env.ACME_CAP_META_TOS_FIELD === '0')); +const capUpdateAccountKey = !(('ACME_CAP_UPDATE_ACCOUNT_KEY' in process.env) && (process.env.ACME_CAP_UPDATE_ACCOUNT_KEY === '0')); +const capAlternateCertRoots = !(('ACME_CAP_ALTERNATE_CERT_ROOTS' in process.env) && (process.env.ACME_CAP_ALTERNATE_CERT_ROOTS === '0')); + +const clientOpts = { + directoryUrl, + backoffAttempts: 5, + backoffMin: 1000, + backoffMax: 5000 +}; + +if (capEabEnabled && process.env.ACME_EAB_KID && process.env.ACME_EAB_HMAC_KEY) { + clientOpts.externalAccountBinding = { + kid: process.env.ACME_EAB_KID, + hmacKey: process.env.ACME_EAB_HMAC_KEY + }; +} + + +describe('client', () => { + const testDomain = `${uuid()}.${domainName}`; + const testDomainWildcard = `*.${testDomain}`; + const testContact = `mailto:test-${uuid()}@nope.com`; + + + /** + * Pebble CTS required + */ + + before(function() { + if (!cts.isEnabled()) { + this.skip(); + } + }); + + + /** + * Key types + */ + + Object.entries({ + rsa: { + createKeyFn: () => acme.crypto.createPrivateRsaKey(), + createKeyAltFns: { + s1024: () => acme.crypto.createPrivateRsaKey(1024), + s4096: () => acme.crypto.createPrivateRsaKey(4096) + }, + jwkSpecFn: spec.jwk.rsa + }, + ecdsa: { + createKeyFn: () => acme.crypto.createPrivateEcdsaKey(), + createKeyAltFns: { + p384: () => acme.crypto.createPrivateEcdsaKey('P-384'), + p521: () => acme.crypto.createPrivateEcdsaKey('P-521') + }, + jwkSpecFn: spec.jwk.ecdsa + } + }).forEach(([name, { createKeyFn, createKeyAltFns, jwkSpecFn }]) => { + describe(name, () => { + let testIssuers; + let testAccountKey; + let testAccountSecondaryKey; + let testClient; + let testAccount; + let testAccountUrl; + let testOrder; + let testOrderWildcard; + let testAuthz; + let testAuthzWildcard; + let testChallenge; + let testChallengeWildcard; + let testKeyAuthorization; + let testKeyAuthorizationWildcard; + let testCsr; + let testCsrWildcard; + let testCertificate; + let testCertificateWildcard; + + + /** + * Fixtures + */ + + it('should generate a private key', async () => { + testAccountKey = await createKeyFn(); + assert.isTrue(Buffer.isBuffer(testAccountKey)); + }); + + it('should create a second private key', async () => { + testAccountSecondaryKey = await createKeyFn(); + assert.isTrue(Buffer.isBuffer(testAccountSecondaryKey)); + }); + + it('should generate certificate signing request', async () => { + [, testCsr] = await acme.crypto.createCsr({ commonName: testDomain }, await createKeyFn()); + [, testCsrWildcard] = await acme.crypto.createCsr({ commonName: testDomainWildcard }, await createKeyFn()); + }); + + it('should resolve certificate issuers [ACME_CAP_ALTERNATE_CERT_ROOTS]', async function() { + if (!capAlternateCertRoots) { + this.skip(); + } + + testIssuers = await getCertIssuers(); + + assert.isArray(testIssuers); + assert.isTrue(testIssuers.length > 1); + + testIssuers.forEach((i) => { + assert.isString(i); + assert.strictEqual(1, testIssuers.filter((c) => (c === i)).length); + }); + }); + + + /** + * Initialize clients + */ + + it('should initialize client', () => { + testClient = new acme.Client({ + ...clientOpts, + accountKey: testAccountKey + }); + }); + + it('should produce a valid jwk', () => { + const jwk = testClient.http.getJwk(); + jwkSpecFn(jwk); + }); + + + /** + * Terms of Service + */ + + it('should produce tos url [ACME_CAP_META_TOS_FIELD]', async function() { + if (!capMetaTosField) { + this.skip(); + } + + const tos = await testClient.getTermsOfServiceUrl(); + assert.isString(tos); + }); + + it('should not produce tos url [!ACME_CAP_META_TOS_FIELD]', async function() { + if (capMetaTosField) { + this.skip(); + } + + const tos = await testClient.getTermsOfServiceUrl(); + assert.isNull(tos); + }); + + + /** + * Create account + */ + + it('should refuse account creation without tos [ACME_CAP_META_TOS_FIELD]', async function() { + if (!capMetaTosField) { + this.skip(); + } + + await assert.isRejected(testClient.createAccount()); + }); + + it('should refuse account creation without eab [ACME_CAP_EAB_ENABLED]', async function() { + if (!capEabEnabled) { + this.skip(); + } + + const client = new acme.Client({ + ...clientOpts, + accountKey: testAccountKey, + externalAccountBinding: null + }); + + await assert.isRejected(client.createAccount({ + termsOfServiceAgreed: true + })); + }); + + it('should create an account', async () => { + testAccount = await testClient.createAccount({ + termsOfServiceAgreed: true + }); + + spec.rfc8555.account(testAccount); + assert.strictEqual(testAccount.status, 'valid'); + }); + + it('should produce an account url', () => { + testAccountUrl = testClient.getAccountUrl(); + assert.isString(testAccountUrl); + }); + + + /** + * Create account with alternate key sizes + */ + + Object.entries(createKeyAltFns).forEach(([k, altKeyFn]) => { + it(`should create account with key=${k}`, async () => { + const client = new acme.Client({ + ...clientOpts, + accountKey: await altKeyFn() + }); + + const account = await client.createAccount({ + termsOfServiceAgreed: true + }); + + spec.rfc8555.account(account); + assert.strictEqual(account.status, 'valid'); + }); + }); + + + /** + * Find existing account using secondary client + */ + + it('should throw when trying to find account using invalid account key', async () => { + const client = new acme.Client({ + ...clientOpts, + accountKey: testAccountSecondaryKey + }); + + await assert.isRejected(client.createAccount({ + onlyReturnExisting: true + })); + }); + + it('should find existing account using account key', async () => { + const client = new acme.Client({ + ...clientOpts, + accountKey: testAccountKey + }); + + const account = await client.createAccount({ + onlyReturnExisting: true + }); + + spec.rfc8555.account(account); + assert.strictEqual(account.status, 'valid'); + assert.deepStrictEqual(account.key, testAccount.key); + }); + + + /** + * Account URL + */ + + it('should refuse invalid account url', async () => { + const client = new acme.Client({ + ...clientOpts, + accountKey: testAccountKey, + accountUrl: 'https://acme-staging-v02.api.letsencrypt.org/acme/acct/1' + }); + + await assert.isRejected(client.updateAccount()); + }); + + it('should find existing account using account url', async () => { + const client = new acme.Client({ + ...clientOpts, + accountKey: testAccountKey, + accountUrl: testAccountUrl + }); + + const account = await client.createAccount({ + onlyReturnExisting: true + }); + + spec.rfc8555.account(account); + assert.strictEqual(account.status, 'valid'); + assert.deepStrictEqual(account.key, testAccount.key); + }); + + + /** + * Update account contact info + */ + + it('should update account contact info', async () => { + const data = { contact: [testContact] }; + const account = await testClient.updateAccount(data); + + spec.rfc8555.account(account); + assert.strictEqual(account.status, 'valid'); + assert.deepStrictEqual(account.key, testAccount.key); + assert.isArray(account.contact); + assert.include(account.contact, testContact); + }); + + + /** + * Change account private key + */ + + it('should change account private key [ACME_CAP_UPDATE_ACCOUNT_KEY]', async function() { + if (!capUpdateAccountKey) { + this.skip(); + } + + await testClient.updateAccountKey(testAccountSecondaryKey); + + const account = await testClient.createAccount({ + onlyReturnExisting: true + }); + + spec.rfc8555.account(account); + assert.strictEqual(account.status, 'valid'); + assert.notDeepEqual(account.key, testAccount.key); + }); + + + /** + * Create new certificate order + */ + + it('should create new order', async () => { + const data1 = { identifiers: [{ type: 'dns', value: testDomain }] }; + const data2 = { identifiers: [{ type: 'dns', value: testDomainWildcard }] }; + + testOrder = await testClient.createOrder(data1); + testOrderWildcard = await testClient.createOrder(data2); + + [testOrder, testOrderWildcard].forEach((item) => { + spec.rfc8555.order(item); + assert.strictEqual(item.status, 'pending'); + }); + }); + + + /** + * Get status of existing certificate order + */ + + it('should get existing order', async () => { + await Promise.all([testOrder, testOrderWildcard].map(async (existing) => { + const result = await testClient.getOrder(existing); + + spec.rfc8555.order(result); + assert.deepStrictEqual(existing, result); + })); + }); + + + /** + * Get identifier authorization + */ + + it('should get identifier authorization', async () => { + const orderAuthzCollection = await testClient.getAuthorizations(testOrder); + const wildcardAuthzCollection = await testClient.getAuthorizations(testOrderWildcard); + + [orderAuthzCollection, wildcardAuthzCollection].forEach((collection) => { + assert.isArray(collection); + assert.isNotEmpty(collection); + + collection.forEach((authz) => { + spec.rfc8555.authorization(authz); + assert.strictEqual(authz.status, 'pending'); + }); + }); + + testAuthz = orderAuthzCollection.pop(); + testAuthzWildcard = wildcardAuthzCollection.pop(); + + testAuthz.challenges.concat(testAuthzWildcard.challenges).forEach((item) => { + spec.rfc8555.challenge(item); + assert.strictEqual(item.status, 'pending'); + }); + }); + + + /** + * Generate challenge key authorization + */ + + it('should get challenge key authorization', async () => { + testChallenge = testAuthz.challenges.find((c) => (c.type === 'http-01')); + testChallengeWildcard = testAuthzWildcard.challenges.find((c) => (c.type === 'dns-01')); + + testKeyAuthorization = await testClient.getChallengeKeyAuthorization(testChallenge); + testKeyAuthorizationWildcard = await testClient.getChallengeKeyAuthorization(testChallengeWildcard); + + [testKeyAuthorization, testKeyAuthorizationWildcard].forEach((k) => assert.isString(k)); + }); + + + /** + * Deactivate identifier authorization + */ + + it('should deactivate identifier authorization', async () => { + const order = await testClient.createOrder({ + identifiers: [ + { type: 'dns', value: `${uuid()}.${domainName}` }, + { type: 'dns', value: `${uuid()}.${domainName}` } + ] + }); + + const authzCollection = await testClient.getAuthorizations(order); + + const results = await Promise.all(authzCollection.map(async (authz) => { + spec.rfc8555.authorization(authz); + assert.strictEqual(authz.status, 'pending'); + return testClient.deactivateAuthorization(authz); + })); + + results.forEach((authz) => { + spec.rfc8555.authorization(authz); + assert.strictEqual(authz.status, 'deactivated'); + }); + }); + + + /** + * Verify satisfied challenge + */ + + it('should verify challenge', async () => { + await cts.assertHttpChallengeCreateFn(testAuthz, testChallenge, testKeyAuthorization); + await cts.assertDnsChallengeCreateFn(testAuthzWildcard, testChallengeWildcard, testKeyAuthorizationWildcard); + + await testClient.verifyChallenge(testAuthz, testChallenge); + await testClient.verifyChallenge(testAuthzWildcard, testChallengeWildcard); + }); + + + /** + * Complete challenge + */ + + it('should complete challenge', async () => { + await Promise.all([testChallenge, testChallengeWildcard].map(async (challenge) => { + const result = await testClient.completeChallenge(challenge); + + spec.rfc8555.challenge(result); + assert.strictEqual(challenge.url, result.url); + })); + }); + + + /** + * Wait for valid challenge + */ + + it('should wait for valid challenge status', async () => { + await Promise.all([testChallenge, testChallengeWildcard].map(async (c) => testClient.waitForValidStatus(c))); + }); + + + /** + * Finalize order + */ + + it('should finalize order', async () => { + const finalize = await testClient.finalizeOrder(testOrder, testCsr); + const finalizeWildcard = await testClient.finalizeOrder(testOrderWildcard, testCsrWildcard); + + [finalize, finalizeWildcard].forEach((f) => spec.rfc8555.order(f)); + + assert.strictEqual(testOrder.url, finalize.url); + assert.strictEqual(testOrderWildcard.url, finalizeWildcard.url); + }); + + + /** + * Wait for valid order + */ + + it('should wait for valid order status', async () => { + await Promise.all([testOrder, testOrderWildcard].map(async (o) => testClient.waitForValidStatus(o))); + }); + + + /** + * Get certificate + */ + + it('should get certificate', async () => { + testCertificate = await testClient.getCertificate(testOrder); + testCertificateWildcard = await testClient.getCertificate(testOrderWildcard); + + [testCertificate, testCertificateWildcard].forEach((cert) => { + assert.isString(cert); + acme.crypto.readCertificateInfo(cert); + }); + }); + + it('should get alternate certificate chain [ACME_CAP_ALTERNATE_CERT_ROOTS]', async function() { + if (!capAlternateCertRoots) { + this.skip(); + } + + await Promise.all(testIssuers.map(async (issuer) => { + const cert = await testClient.getCertificate(testOrder, issuer); + const rootCert = acme.crypto.splitPemChain(cert).pop(); + const info = acme.crypto.readCertificateInfo(rootCert); + + assert.strictEqual(issuer, info.issuer.commonName); + })); + }); + + it('should get default chain with invalid preference [ACME_CAP_ALTERNATE_CERT_ROOTS]', async function() { + if (!capAlternateCertRoots) { + this.skip(); + } + + const cert = await testClient.getCertificate(testOrder, uuid()); + const rootCert = acme.crypto.splitPemChain(cert).pop(); + const info = acme.crypto.readCertificateInfo(rootCert); + + assert.strictEqual(testIssuers[0], info.issuer.commonName); + }); + + + /** + * Revoke certificate + */ + + it('should revoke certificate', async () => { + await testClient.revokeCertificate(testCertificate); + await testClient.revokeCertificate(testCertificateWildcard, { reason: 4 }); + }); + + it('should not allow getting revoked certificate', async () => { + await assert.isRejected(testClient.getCertificate(testOrder)); + await assert.isRejected(testClient.getCertificate(testOrderWildcard)); + }); + + + /** + * Deactivate account + */ + + it('should deactivate account', async () => { + const data = { status: 'deactivated' }; + const account = await testClient.updateAccount(data); + + spec.rfc8555.account(account); + assert.strictEqual(account.status, 'deactivated'); + }); + + + /** + * Verify that no new orders can be made + */ + + it('should not allow new orders from deactivated account', async () => { + const data = { identifiers: [{ type: 'dns', value: 'nope.com' }] }; + await assert.isRejected(testClient.createOrder(data)); + }); + }); + }); +}); diff --git a/packages/core/acme-client/test/70-auto.spec.js b/packages/core/acme-client/test/70-auto.spec.js new file mode 100644 index 00000000..5b0b6f18 --- /dev/null +++ b/packages/core/acme-client/test/70-auto.spec.js @@ -0,0 +1,384 @@ +/** + * ACME client.auto tests + */ + +const { assert } = require('chai'); +const { v4: uuid } = require('uuid'); +const cts = require('./challtestsrv'); +const getCertIssuers = require('./get-cert-issuers'); +const spec = require('./spec'); +const acme = require('./../'); + +const domainName = process.env.ACME_DOMAIN_NAME || 'example.com'; +const directoryUrl = process.env.ACME_DIRECTORY_URL || acme.directory.letsencrypt.staging; +const capEabEnabled = (('ACME_CAP_EAB_ENABLED' in process.env) && (process.env.ACME_CAP_EAB_ENABLED === '1')); +const capAlternateCertRoots = !(('ACME_CAP_ALTERNATE_CERT_ROOTS' in process.env) && (process.env.ACME_CAP_ALTERNATE_CERT_ROOTS === '0')); + +const clientOpts = { + directoryUrl, + backoffAttempts: 5, + backoffMin: 1000, + backoffMax: 5000 +}; + +if (capEabEnabled && process.env.ACME_EAB_KID && process.env.ACME_EAB_HMAC_KEY) { + clientOpts.externalAccountBinding = { + kid: process.env.ACME_EAB_KID, + hmacKey: process.env.ACME_EAB_HMAC_KEY + }; +} + + +describe('client.auto', () => { + const testDomain = `${uuid()}.${domainName}`; + const testHttpDomain = `${uuid()}.${domainName}`; + const testDnsDomain = `${uuid()}.${domainName}`; + const testWildcardDomain = `${uuid()}.${domainName}`; + + const testSanDomains = [ + `${uuid()}.${domainName}`, + `${uuid()}.${domainName}`, + `${uuid()}.${domainName}` + ]; + + + /** + * Pebble CTS required + */ + + before(function() { + if (!cts.isEnabled()) { + this.skip(); + } + }); + + + /** + * Key types + */ + + Object.entries({ + rsa: { + createKeyFn: () => acme.crypto.createPrivateRsaKey(), + createKeyAltFns: { + s1024: () => acme.crypto.createPrivateRsaKey(1024), + s4096: () => acme.crypto.createPrivateRsaKey(4096) + } + }, + ecdsa: { + createKeyFn: () => acme.crypto.createPrivateEcdsaKey(), + createKeyAltFns: { + p384: () => acme.crypto.createPrivateEcdsaKey('P-384'), + p521: () => acme.crypto.createPrivateEcdsaKey('P-521') + } + } + }).forEach(([name, { createKeyFn, createKeyAltFns }]) => { + describe(name, () => { + let testIssuers; + let testClient; + let testCertificate; + let testSanCertificate; + let testWildcardCertificate; + + + /** + * Fixtures + */ + + it('should resolve certificate issuers [ACME_CAP_ALTERNATE_CERT_ROOTS]', async function() { + if (!capAlternateCertRoots) { + this.skip(); + } + + testIssuers = await getCertIssuers(); + + assert.isArray(testIssuers); + assert.isTrue(testIssuers.length > 1); + + testIssuers.forEach((i) => { + assert.isString(i); + assert.strictEqual(1, testIssuers.filter((c) => (c === i)).length); + }); + }); + + + /** + * Initialize client + */ + + it('should initialize client', async () => { + testClient = new acme.Client({ + ...clientOpts, + accountKey: await createKeyFn() + }); + }); + + + /** + * Invalid challenge response + */ + + it('should throw on invalid challenge response', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: `${uuid()}.${domainName}` + }, await createKeyFn()); + + await assert.isRejected(testClient.auto({ + csr, + termsOfServiceAgreed: true, + challengeCreateFn: cts.challengeNoopFn, + challengeRemoveFn: cts.challengeNoopFn + }), /^authorization not found/i); + }); + + it('should throw on invalid challenge response with opts.skipChallengeVerification=true', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: `${uuid()}.${domainName}` + }, await createKeyFn()); + + await assert.isRejected(testClient.auto({ + csr, + termsOfServiceAgreed: true, + skipChallengeVerification: true, + challengeCreateFn: cts.challengeNoopFn, + challengeRemoveFn: cts.challengeNoopFn + })); + }); + + + /** + * Challenge function exceptions + */ + + it('should throw on challengeCreate exception', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: `${uuid()}.${domainName}` + }, await createKeyFn()); + + await assert.isRejected(testClient.auto({ + csr, + termsOfServiceAgreed: true, + challengeCreateFn: cts.challengeThrowFn, + challengeRemoveFn: cts.challengeNoopFn + }), /^oops$/); + }); + + it('should not throw on challengeRemove exception', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: `${uuid()}.${domainName}` + }, await createKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + challengeCreateFn: cts.challengeCreateFn, + challengeRemoveFn: cts.challengeThrowFn + }); + + assert.isString(cert); + }); + + + /** + * Order certificates + */ + + it('should order certificate', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: testDomain + }, await createKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + challengeCreateFn: cts.challengeCreateFn, + challengeRemoveFn: cts.challengeRemoveFn + }); + + assert.isString(cert); + testCertificate = cert; + }); + + it('should order certificate using http-01', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: testHttpDomain + }, await createKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + challengeCreateFn: cts.assertHttpChallengeCreateFn, + challengeRemoveFn: cts.challengeRemoveFn, + challengePriority: ['http-01'] + }); + + assert.isString(cert); + }); + + it('should order certificate using dns-01', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: testDnsDomain + }, await createKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + challengeCreateFn: cts.assertDnsChallengeCreateFn, + challengeRemoveFn: cts.challengeRemoveFn, + challengePriority: ['dns-01'] + }); + + assert.isString(cert); + }); + + it('should order san certificate', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: testSanDomains[0], + altNames: testSanDomains + }, await createKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + challengeCreateFn: cts.challengeCreateFn, + challengeRemoveFn: cts.challengeRemoveFn + }); + + assert.isString(cert); + testSanCertificate = cert; + }); + + it('should order wildcard certificate', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: testWildcardDomain, + altNames: [`*.${testWildcardDomain}`] + }, await createKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + challengeCreateFn: cts.challengeCreateFn, + challengeRemoveFn: cts.challengeRemoveFn + }); + + assert.isString(cert); + testWildcardCertificate = cert; + }); + + it('should order certificate with opts.skipChallengeVerification=true', async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: `${uuid()}.${domainName}` + }, await createKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + skipChallengeVerification: true, + challengeCreateFn: cts.challengeCreateFn, + challengeRemoveFn: cts.challengeRemoveFn + }); + + assert.isString(cert); + }); + + it('should order alternate certificate chain [ACME_CAP_ALTERNATE_CERT_ROOTS]', async function() { + if (!capAlternateCertRoots) { + this.skip(); + } + + await Promise.all(testIssuers.map(async (issuer) => { + const [, csr] = await acme.crypto.createCsr({ + commonName: `${uuid()}.${domainName}` + }, await createKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + preferredChain: issuer, + challengeCreateFn: cts.challengeCreateFn, + challengeRemoveFn: cts.challengeRemoveFn + }); + + const rootCert = acme.crypto.splitPemChain(cert).pop(); + const info = acme.crypto.readCertificateInfo(rootCert); + + assert.strictEqual(issuer, info.issuer.commonName); + })); + }); + + it('should get default chain with invalid preference [ACME_CAP_ALTERNATE_CERT_ROOTS]', async function() { + if (!capAlternateCertRoots) { + this.skip(); + } + + const [, csr] = await acme.crypto.createCsr({ + commonName: `${uuid()}.${domainName}` + }, await createKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + preferredChain: uuid(), + challengeCreateFn: cts.challengeCreateFn, + challengeRemoveFn: cts.challengeRemoveFn + }); + + const rootCert = acme.crypto.splitPemChain(cert).pop(); + const info = acme.crypto.readCertificateInfo(rootCert); + + assert.strictEqual(testIssuers[0], info.issuer.commonName); + }); + + + /** + * Order certificate with alternate key sizes + */ + + Object.entries(createKeyAltFns).forEach(([k, altKeyFn]) => { + it(`should order certificate with key=${k}`, async () => { + const [, csr] = await acme.crypto.createCsr({ + commonName: testDomain + }, await altKeyFn()); + + const cert = await testClient.auto({ + csr, + termsOfServiceAgreed: true, + challengeCreateFn: cts.challengeCreateFn, + challengeRemoveFn: cts.challengeRemoveFn + }); + + assert.isString(cert); + }); + }); + + + /** + * Read certificates + */ + + it('should read certificate info', () => { + const info = acme.crypto.readCertificateInfo(testCertificate); + + spec.crypto.certificateInfo(info); + assert.strictEqual(info.domains.commonName, testDomain); + assert.deepStrictEqual(info.domains.altNames, [testDomain]); + }); + + it('should read san certificate info', () => { + const info = acme.crypto.readCertificateInfo(testSanCertificate); + + spec.crypto.certificateInfo(info); + assert.strictEqual(info.domains.commonName, testSanDomains[0]); + assert.deepStrictEqual(info.domains.altNames, testSanDomains); + }); + + it('should read wildcard certificate info', () => { + const info = acme.crypto.readCertificateInfo(testWildcardCertificate); + + spec.crypto.certificateInfo(info); + assert.strictEqual(info.domains.commonName, testWildcardDomain); + assert.deepStrictEqual(info.domains.altNames, [testWildcardDomain, `*.${testWildcardDomain}`]); + }); + }); + }); +}); diff --git a/packages/core/acme-client/test/challtestsrv.js b/packages/core/acme-client/test/challtestsrv.js new file mode 100644 index 00000000..1a372959 --- /dev/null +++ b/packages/core/acme-client/test/challtestsrv.js @@ -0,0 +1,93 @@ +/** + * Pebble Challenge Test Server integration + */ + +const { assert } = require('chai'); +const axios = require('./../src/axios'); + +const apiBaseUrl = process.env.ACME_CHALLTESTSRV_URL || null; + + +/** + * Send request + */ + +async function request(apiPath, data = {}) { + if (!apiBaseUrl) { + throw new Error('No Pebble Challenge Test Server URL found'); + } + + await axios.request({ + url: `${apiBaseUrl}/${apiPath}`, + method: 'post', + data + }); + + return true; +} + + +/** + * State + */ + +exports.isEnabled = () => !!apiBaseUrl; + + +/** + * DNS + */ + +exports.addDnsARecord = async (host, addresses) => request('add-a', { host, addresses }); +exports.setDnsCnameRecord = async (host, target) => request('set-cname', { host, target }); + + +/** + * Challenge response + */ + +async function addHttp01ChallengeResponse(token, content) { + return request('add-http01', { token, content }); +} + +async function addDns01ChallengeResponse(host, value) { + return request('set-txt', { host, value }); +} + +exports.addHttp01ChallengeResponse = addHttp01ChallengeResponse; +exports.addDns01ChallengeResponse = addDns01ChallengeResponse; + + +/** + * Challenge response mock functions + */ + +async function assertHttpChallengeCreateFn(authz, challenge, keyAuthorization) { + assert.strictEqual(challenge.type, 'http-01'); + return addHttp01ChallengeResponse(challenge.token, keyAuthorization); +} + +async function assertDnsChallengeCreateFn(authz, challenge, keyAuthorization) { + assert.strictEqual(challenge.type, 'dns-01'); + return addDns01ChallengeResponse(`_acme-challenge.${authz.identifier.value}.`, keyAuthorization); +} + +async function challengeCreateFn(authz, challenge, keyAuthorization) { + if (challenge.type === 'http-01') { + return assertHttpChallengeCreateFn(authz, challenge, keyAuthorization); + } + + if (challenge.type === 'dns-01') { + return assertDnsChallengeCreateFn(authz, challenge, keyAuthorization); + } + + throw new Error(`Unsupported challenge type ${challenge.type}`); +} + +exports.challengeRemoveFn = async () => true; +exports.challengeNoopFn = async () => true; +exports.challengeThrowFn = async () => { throw new Error('oops'); }; + +exports.assertHttpChallengeCreateFn = assertHttpChallengeCreateFn; +exports.assertDnsChallengeCreateFn = assertDnsChallengeCreateFn; +exports.challengeCreateFn = challengeCreateFn; diff --git a/packages/core/acme-client/test/fixtures/certificate.crt b/packages/core/acme-client/test/fixtures/certificate.crt new file mode 100644 index 00000000..b7d44533 --- /dev/null +++ b/packages/core/acme-client/test/fixtures/certificate.crt @@ -0,0 +1,30 @@ +-----BEGIN CERTIFICATE----- +MIIFMjCCAxoCCQCVordquLnq8TANBgkqhkiG9w0BAQUFADBbMQswCQYDVQQGEwJB +VTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0 +cyBQdHkgTHRkMRQwEgYDVQQDEwtleGFtcGxlLmNvbTAeFw0xNzA5MTQxNDMzMTRa +Fw0xODA5MTQxNDMzMTRaMFsxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0 +YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxFDASBgNVBAMT +C2V4YW1wbGUuY29tMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAwi2P +YBNGl1n78niRGDKgcsWK03TcTeVbQ1HztA57Rr1iDHAZNx3Mv4E/Sha8VKbKoshc +mUcOS3AlmbIZX+7+9c7lL2oD+vtUZF1YUR/69fWuO72wk6fKj/eofxH9Ud5KFje8 +qrYZdJWKkPMdWlYgjD6qpA5wl60NiuxmUr44ADZDytqHzNThN3wrFruz74PcMfak +cSUMxkh98LuNeGtqHpEAw+wliko3oDD4PanvDvp5mRgiQVKHEGT7dm85Up+W1iJK +J65fkc/j940MaLbdISZYYCT5dtPgCGKCHgVuVrY+OXFJrD3TTm94ILsR/BkS/VSK +NigGVPXg3q8tgIS++k13CzLUO0PNRMuod1RD9j5NEc2CVic9rcH06ugZyHlOcuVv +vRsPGd52BPn+Jf1aePKPPQHxT9i5GOs80CJw0eduZCDZB32biRYNwUtjFkHbu8ii +2IGkvhnWonjd4w5wOldG+RPr+XoFCIaHp5TszQ+HnUTLIXKtBgzzCKjK4eZqrck7 +xpo5B5m5V7EUxBze2LYVky+GsDsqL8CggQqJL4ZKuZVoxgPwhnDy5nMs057NCU9E +nXcauMW9UEqEHu5NXnmGJrCvQ56wjYN3lgvCHEtmIpsRjCCWaBJYiawu1J5ZAf1y +GTVNh8pEvO//zL9ImUxrSfOGUeFiN1tzSFlTfbcCAwEAATANBgkqhkiG9w0BAQUF +AAOCAgEAdZZpgWv79CgF5ny6HmMaYgsXJKJyQE9RhJ1cmzDY8KAF+nzT7q4Pgt3W +bA9bpdji7C0WqKjX7hLipqhgFnqb8qZcodEKhX788qBj4X45+4nT6QipyJlz5x6K +cCn/v9gQNKks7U+dBlqquiVfbXaa1EAKMeGtqinf+Y51nR/fBcr/P9TBnSJqH61K +DO3qrE5KGTwHQ9VXoeKyeppGt5sYf8G0vwoHhtPTOO8TuLEIlFcXtzbC3zAtmQj6 +Su//fI5yjuYTkiayxMx8nCGrQhQSXdC8gYpYd0os7UY01DVu4BTCXEvf0GYXtiGJ +eG8lQT/eu7WdK83uJ93U/BMYzoq4lSVcqY4LNxlfAQXKhaAbioA5XyT7co7FQ0g+ +s2CGBUKa11wPDe8M2GVLPsxT2bXDQap5DQyVIuTwjtgL0tykGxPJPAnL2zuUy6T3 +/YzrWaJ9Os+6mUCVdLnXtDgZ10Ujel7mq6wo9Ns+u07grXZkXpmJYnJXBrwOsY8K +Za5vFwgJrDXhWe+Fmgt1EP5VIqRCQAxH2iYvAaELi8udbN/ZiUU3K9t79MP/M3U/ +tEWAubHXsaAv03jRy43X0VjlZHmagU/4dU7RBWfyuwRarYIXLNT2FCd2z4kd3fsL +3rB5iI+RH0uoNuOa1+UApfFCv0O65TYkp5jEWSlU8PhKYD43nXA= +-----END CERTIFICATE----- diff --git a/packages/core/acme-client/test/fixtures/private.key b/packages/core/acme-client/test/fixtures/private.key new file mode 100644 index 00000000..b709b9c6 --- /dev/null +++ b/packages/core/acme-client/test/fixtures/private.key @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEowIBAAKCAQEAo0nBEFBeo2XnR1kx0jV00W9EszE5Ei/zuJKLXXwTeUGMhy9h +CqPFWQnTOD5PQUcja98p96LCdRZpfsfoL1RewksD6BCJN+9hZucImBASpmg2M432 +wsF7fa3/FMtICrEmQh+LJ48zOottr93YcipY1fNxHWzFr8Hvv+OZCMmQvL4W5u5U +rxdi7jptbAbFvv470TN8lpVwneG7kG3cemPhW6RmfTTUQ2Qp/QP6fptpWIIy5kQe +zvgpql2xRPBjqb4VDy1kVTTCe/Lpt7bNGe2eZOzXJcjrU+d5LEOrfQoX5ZO4H5UC +9YlT6wqyPv9VZ5g2slz198LGV8hdGEVix8XPiQIDAQABAoIBAQCaoo4jVPlK5IZS +GzYDTHyEmksFJ+hUQPUeJim1LnuCqYDbxRKxcMbDu3o8GUYVG7l/vqePzKM7Hy5o +0gggSlYyybe5XW+VeS1UthZ9azs+PBKYYCj/5xt7ufuHRbvD5F/G3vh5TjPFjaUi +l4UTGOdoNlM4+nl8KL1Ti8axe7GGCztxmjJL7VnN4RWc5yzBrU6oiQED0BM/6KFx +nJHPuwzRemRRjz8Lk1ryMsCymtZx70slxVJeHPdoMc9vkseOulooBMZtXqOixoHO +UtFuKGgIkg6KA9qI+8RmqSPUeXrbrPeRZtu3N9NcsPUYVptNo1ZjLpa9Eigd0tkq +1+/TyGDBAoGBANCnK/+uXIZWt4QoF+7AUGeckOmRAbJnWf8KrScSa/TSGNObGP00 +LpeM10eNDqvfY9RepM6RH5R75vDWltJd4+fyQPaHqG4AhlMk1JglZn71F91FWstx +K/qrPfnBQP7qq4yuQ0zavPkgIUWzryLk0JnQ4wPNLiXFAfQYDt+F8Vg3AoGBAMhX +S+sej87zRHbV/wj7zLa/QwnDLiU7wswv9zUf2Ot+49pfwEzzSGuLHFHoIXVrGo2y +QQl6sovJ6dFi7GFPikiwj9em/EF4JgTmWZhoYH1HmThTUeziLa2/VT4eIZn7Viwb +/goxKAvGvHkcdQIeNPPFaEi0m7vDkTAv/WG/prY/AoGAcKWwVWuXPFfY4BqdQSLG +xgl7Gv5UgjLWHaFv9iY17oj3KlcT2K+xb9Rz7Yc0IoqKZP9rzrH+8LUr616PMqfK +AVGCzRZUUn8qBf1eYX3fpi9AYQ+ugyNocP6+iPZS1s1vLJZwcy+s0nsMO4tUxGvw +SvrBdS3y+iUwds3+SaMQt2UCgYAg0BuBIPpQ3QtDo30oDYXUELN8L9mpA4a+RsTo +kJTIzXmoVLJ8aAReiORUjf6c6rPorV91nAEOYD3Jq7gnoA14JmMI4TLDzlf7yXa3 +PbFAE7AGx67Na6YrpQDjMbAzNjVA+Dy9kpuKgjxwYbbQZ/4oRxbzgZFYSYnIKLQJ +hIhbpQKBgEc8fYYc3UqyNIGNupYBZhb0pF7FPMwldzv4UufMjkYzKREaCT2D3HIC +FEKiJxatIhOtCW5oa5sXK/mGR9EEzW1ltlljymu0u+slIoWvWWGfQU9DxFBnZ2x5 +4/nzeq4zI+qYt8qXZTnhY/bpZI0pdQqWT9+AoFJJn8Bfdk1mLuIs +-----END RSA PRIVATE KEY----- diff --git a/packages/core/acme-client/test/fixtures/san-certificate.crt b/packages/core/acme-client/test/fixtures/san-certificate.crt new file mode 100644 index 00000000..f4f32041 --- /dev/null +++ b/packages/core/acme-client/test/fixtures/san-certificate.crt @@ -0,0 +1,18 @@ +-----BEGIN CERTIFICATE----- +MIIC3zCCAcegAwIBAgIJAPZkD9qD+FX8MA0GCSqGSIb3DQEBBQUAMBYxFDASBgNV +BAMMC2V4YW1wbGUuY29tMB4XDTE3MDkyMTIwMzY1MFoXDTE4MDkyMTIwMzY1MFow +FjEUMBIGA1UEAwwLZXhhbXBsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQDNygRzPEyGP90Q3ms1DzUIj597u4t22TU08TQywMTt+/Sd+LNDvgwI +yhCbbwetVq+rvEayAMaQjFzqgoQOxY8GDrrqfPfQ50ED79vu5VPaqVSTN5FwK7hq +6Bl+kT2MUMIwhhGTfrn7inGhxB1hhYtAaUJDuLN2JjB6Ax9BfVv5NJLPeN1V6qdV +edtmNrUV5eWwEPfl4kCJ8Ytes6YttN2UDnet/B19po3/JEdy5YgPmeAfW1wbA+kl +oU475uPpKPV79M+6hrKNlS2hPFcGOiL/7glKgXURg7Ih+e53Qx6tgqKrgmjRM8Jq +0bLwM1+xY0O/2C9wbkpElBLU9CKS9I+PAgMBAAGjMDAuMCwGA1UdEQQlMCOCEHRl +c3QuZXhhbXBsZS5jb22CD2FiYy5leGFtcGxlLmNvbTANBgkqhkiG9w0BAQUFAAOC +AQEAGCVsiJZOe0LVYQ40a/N/PaVVs1zj1KXmVDrKEWW8fhjEMao/j/Bb4rXuKCkC +DQIZR1jsFC4IWyL4eOpUp4SPFn6kbdzhxjl+42kuzQLqTc1EiEobwEbroQSoUJpT +xj2j0YnrFn/9hVBHUgsA3tONNXL5McEtiHOQ+iXUmoPw9sRvs0DEshS1XeYvTuzY +Jua6uev1QBXxll3+pw7i2Wbt9ifeX6NBe+MOGIYxn6aMwwmgtoLbxDMThtVJJGCH +V0JrSBhEkVlfK1LukSUeSO1RpCsV+97Xx2jEsNwbiji/xKnXk44sVJhJ/yQnWkiC +wZLUm/SNOOtPT68U5RopRC0IXA== +-----END CERTIFICATE----- diff --git a/packages/core/acme-client/test/get-cert-issuers.js b/packages/core/acme-client/test/get-cert-issuers.js new file mode 100644 index 00000000..8813b06e --- /dev/null +++ b/packages/core/acme-client/test/get-cert-issuers.js @@ -0,0 +1,40 @@ +/** + * Get ACME certificate issuers + */ + +const acme = require('./../'); +const util = require('./../src/util'); + +const pebbleManagementUrl = process.env.ACME_PEBBLE_MANAGEMENT_URL || null; + + +/** + * Pebble + */ + +async function getPebbleCertIssuers() { + /* Get intermediate certificate and resolve alternates */ + const root = await acme.axios.get(`${pebbleManagementUrl}/intermediates/0`); + const links = util.parseLinkHeader(root.headers.link || ''); + const alternates = await Promise.all(links.map(async (link) => acme.axios.get(link))); + + /* Get certificate info */ + const certs = [root].concat(alternates).map((c) => c.data); + const info = certs.map((c) => acme.crypto.readCertificateInfo(c)); + + /* Return issuers */ + return info.map((i) => i.issuer.commonName); +} + + +/** + * Get certificate issuers + */ + +module.exports = async () => { + if (pebbleManagementUrl) { + return getPebbleCertIssuers(); + } + + throw new Error('Unable to resolve list of certificate issuers'); +}; diff --git a/packages/core/acme-client/test/setup.js b/packages/core/acme-client/test/setup.js new file mode 100644 index 00000000..e6f18647 --- /dev/null +++ b/packages/core/acme-client/test/setup.js @@ -0,0 +1,87 @@ +/** + * Setup testing + */ + +const url = require('url'); +const net = require('net'); +const fs = require('fs'); +const dns = require('dns').promises; +const chai = require('chai'); +const chaiAsPromised = require('chai-as-promised'); +const axios = require('./../src/axios'); + + +/** + * Add promise support to Chai + */ + +chai.use(chaiAsPromised); + + +/** + * HTTP challenge port + */ + +if (process.env.ACME_HTTP_PORT) { + axios.defaults.acmeSettings.httpChallengePort = process.env.ACME_HTTP_PORT; +} + + +/** + * External account binding + */ + +if (('ACME_CAP_EAB_ENABLED' in process.env) && (process.env.ACME_CAP_EAB_ENABLED === '1')) { + const pebbleConfig = JSON.parse(fs.readFileSync('/etc/pebble/pebble.json').toString()); + const [kid, hmacKey] = Object.entries(pebbleConfig.pebble.externalAccountMACKeys)[0]; + + process.env.ACME_EAB_KID = kid; + process.env.ACME_EAB_HMAC_KEY = hmacKey; +} + + +/** + * Custom DNS resolver + */ + +if (process.env.ACME_DNS_RESOLVER) { + dns.setServers([process.env.ACME_DNS_RESOLVER]); + + + /** + * Axios DNS resolver + */ + + axios.interceptors.request.use(async (config) => { + const urlObj = url.parse(config.url); + + /* Bypass */ + if (axios.defaults.acmeSettings.bypassCustomDnsResolver === true) { + return config; + } + + /* Skip IP addresses and localhost */ + if (net.isIP(urlObj.hostname) || (urlObj.hostname === 'localhost')) { + return config; + } + + /* Lookup hostname */ + const result = await dns.resolve4(urlObj.hostname); + + if (!result.length) { + throw new Error(`Unable to lookup address: ${urlObj.hostname}`); + } + + /* Place hostname in header */ + config.headers = config.headers || {}; + config.headers.Host = urlObj.hostname; + + /* Inject address into URL */ + delete urlObj.host; + urlObj.hostname = result[0]; + config.url = url.format(urlObj); + + /* Done */ + return config; + }); +} diff --git a/packages/core/acme-client/test/spec.js b/packages/core/acme-client/test/spec.js new file mode 100644 index 00000000..3663e4f2 --- /dev/null +++ b/packages/core/acme-client/test/spec.js @@ -0,0 +1,178 @@ +/** + * Assertions + */ + +const { assert } = require('chai'); + +const spec = {}; +module.exports = spec; + + +/** + * ACME + */ + +spec.rfc8555 = {}; + +spec.rfc8555.account = (obj) => { + assert.isObject(obj); + + assert.isString(obj.status); + assert.include(['valid', 'deactivated', 'revoked'], obj.status); + + assert.isString(obj.orders); + + if ('contact' in obj) { + assert.isArray(obj.contact); + obj.contact.forEach((c) => assert.isString(c)); + } + + if ('termsOfServiceAgreed' in obj) { + assert.isBoolean(obj.termsOfServiceAgreed); + } + + if ('externalAccountBinding' in obj) { + assert.isObject(obj.externalAccountBinding); + } +}; + +spec.rfc8555.order = (obj) => { + assert.isObject(obj); + + assert.isString(obj.status); + assert.include(['pending', 'ready', 'processing', 'valid', 'invalid'], obj.status); + + assert.isArray(obj.identifiers); + obj.identifiers.forEach((i) => spec.rfc8555.identifier(i)); + + assert.isArray(obj.authorizations); + obj.authorizations.forEach((a) => assert.isString(a)); + + assert.isString(obj.finalize); + + if ('expires' in obj) { + assert.isString(obj.expires); + } + + if ('notBefore' in obj) { + assert.isString(obj.notBefore); + } + + if ('notAfter' in obj) { + assert.isString(obj.notAfter); + } + + if ('error' in obj) { + assert.isObject(obj.error); + } + + if ('certificate' in obj) { + assert.isString(obj.certificate); + } + + /* Augmentations */ + assert.isString(obj.url); +}; + +spec.rfc8555.authorization = (obj) => { + assert.isObject(obj); + + spec.rfc8555.identifier(obj.identifier); + + assert.isString(obj.status); + assert.include(['pending', 'valid', 'invalid', 'deactivated', 'expires', 'revoked'], obj.status); + + assert.isArray(obj.challenges); + obj.challenges.forEach((c) => spec.rfc8555.challenge(c)); + + if ('expires' in obj) { + assert.isString(obj.expires); + } + + if ('wildcard' in obj) { + assert.isBoolean(obj.wildcard); + } + + /* Augmentations */ + assert.isString(obj.url); +}; + +spec.rfc8555.identifier = (obj) => { + assert.isObject(obj); + assert.isString(obj.type); + assert.isString(obj.value); +}; + +spec.rfc8555.challenge = (obj) => { + assert.isObject(obj); + assert.isString(obj.type); + assert.isString(obj.url); + + assert.isString(obj.status); + assert.include(['pending', 'processing', 'valid', 'invalid'], obj.status); + + if ('validated' in obj) { + assert.isString(obj.validated); + } + + if ('error' in obj) { + assert.isObject(obj.error); + } +}; + + +/** + * Crypto + */ + +spec.crypto = {}; + +spec.crypto.csrDomains = (obj) => { + assert.isObject(obj); + + assert.isDefined(obj.commonName); + assert.isArray(obj.altNames); + obj.altNames.forEach((a) => assert.isString(a)); +}; + +spec.crypto.certificateInfo = (obj) => { + assert.isObject(obj); + + assert.isObject(obj.issuer); + assert.isDefined(obj.issuer.commonName); + + assert.isObject(obj.domains); + assert.isDefined(obj.domains.commonName); + assert.isArray(obj.domains.altNames); + obj.domains.altNames.forEach((a) => assert.isString(a)); + + assert.strictEqual(Object.prototype.toString.call(obj.notBefore), '[object Date]'); + assert.strictEqual(Object.prototype.toString.call(obj.notAfter), '[object Date]'); +}; + + +/** + * JWK + */ + +spec.jwk = {}; + +spec.jwk.rsa = (obj) => { + assert.isObject(obj); + assert.isString(obj.e); + assert.isString(obj.kty); + assert.isString(obj.n); + + assert.strictEqual(obj.e, 'AQAB'); + assert.strictEqual(obj.kty, 'RSA'); +}; + +spec.jwk.ecdsa = (obj) => { + assert.isObject(obj); + assert.isString(obj.crv); + assert.isString(obj.kty); + assert.isString(obj.x); + assert.isString(obj.y); + + assert.strictEqual(obj.kty, 'EC'); +}; diff --git a/packages/core/acme-client/types/index.d.ts b/packages/core/acme-client/types/index.d.ts new file mode 100644 index 00000000..1e3aa2ef --- /dev/null +++ b/packages/core/acme-client/types/index.d.ts @@ -0,0 +1,190 @@ +/** + * acme-client type definitions + */ + +import { AxiosInstance } from 'axios'; +import * as rfc8555 from './rfc8555'; + +export type PrivateKeyBuffer = Buffer; +export type PublicKeyBuffer = Buffer; +export type CertificateBuffer = Buffer; +export type CsrBuffer = Buffer; + +export type PrivateKeyString = string; +export type PublicKeyString = string; +export type CertificateString = string; +export type CsrString = string; + + +/** + * Augmented ACME interfaces + */ + +export interface Order extends rfc8555.Order { + url: string; +} + +export interface Authorization extends rfc8555.Authorization { + url: string; +} + + +/** + * Client + */ + +export interface ClientOptions { + directoryUrl: string; + accountKey: PrivateKeyBuffer | PrivateKeyString; + accountUrl?: string; + externalAccountBinding?: ClientExternalAccountBindingOptions; + backoffAttempts?: number; + backoffMin?: number; + backoffMax?: number; +} + +export interface ClientExternalAccountBindingOptions { + kid: string; + hmacKey: string; +} + +export interface ClientAutoOptions { + csr: CsrBuffer | CsrString; + challengeCreateFn: (authz: Authorization, challenge: rfc8555.Challenge, keyAuthorization: string) => Promise; + challengeRemoveFn: (authz: Authorization, challenge: rfc8555.Challenge, keyAuthorization: string) => Promise; + email?: string; + termsOfServiceAgreed?: boolean; + skipChallengeVerification?: boolean; + challengePriority?: string[]; + preferredChain?: string; +} + +export class Client { + constructor(opts: ClientOptions); + getTermsOfServiceUrl(): Promise; + getAccountUrl(): string; + createAccount(data?: rfc8555.AccountCreateRequest): Promise; + updateAccount(data?: rfc8555.AccountUpdateRequest): Promise; + updateAccountKey(newAccountKey: PrivateKeyBuffer | PrivateKeyString, data?: object): Promise; + createOrder(data: rfc8555.OrderCreateRequest): Promise; + getOrder(order: Order): Promise; + finalizeOrder(order: Order, csr: CsrBuffer | CsrString): Promise; + getAuthorizations(order: Order): Promise; + deactivateAuthorization(authz: Authorization): Promise; + getChallengeKeyAuthorization(challenge: rfc8555.Challenge): Promise; + verifyChallenge(authz: Authorization, challenge: rfc8555.Challenge): Promise; + completeChallenge(challenge: rfc8555.Challenge): Promise; + waitForValidStatus(item: T): Promise; + getCertificate(order: Order, preferredChain?: string): Promise; + revokeCertificate(cert: CertificateBuffer | CertificateString, data?: rfc8555.CertificateRevocationRequest): Promise; + auto(opts: ClientAutoOptions): Promise; +} + + +/** + * Directory URLs + */ + +export const directory: { + buypass: { + staging: string, + production: string + }, + letsencrypt: { + staging: string, + production: string + }, + zerossl: { + production: string + } +}; + + +/** + * Crypto + */ + +export interface CertificateDomains { + commonName: string; + altNames: string[]; +} + +export interface CertificateIssuer { + commonName: string; +} + +export interface CertificateInfo { + issuer: CertificateIssuer; + domains: CertificateDomains; + notAfter: Date; + notBefore: Date; +} + +export interface CsrOptions { + keySize?: number; + commonName?: string; + altNames?: string[]; + country?: string; + state?: string; + locality?: string; + organization?: string; + organizationUnit?: string; + emailAddress?: string; +} + +export interface RsaPublicJwk { + e: string; + kty: string; + n: string; +} + +export interface EcdsaPublicJwk { + crv: string; + kty: string; + x: string; + y: string; +} + +export interface CryptoInterface { + createPrivateKey(keySize?: number): Promise; + createPrivateRsaKey(keySize?: number): Promise; + createPrivateEcdsaKey(namedCurve?: 'P-256' | 'P-384' | 'P-521'): Promise; + getPublicKey(keyPem: PrivateKeyBuffer | PrivateKeyString | PublicKeyBuffer | PublicKeyString): PublicKeyBuffer; + getJwk(keyPem: PrivateKeyBuffer | PrivateKeyString | PublicKeyBuffer | PublicKeyString): RsaPublicJwk | EcdsaPublicJwk; + splitPemChain(chainPem: CertificateBuffer | CertificateString): string[]; + getPemBodyAsB64u(pem: CertificateBuffer | CertificateString): string; + readCsrDomains(csrPem: CsrBuffer | CsrString): CertificateDomains; + readCertificateInfo(certPem: CertificateBuffer | CertificateString): CertificateInfo; + createCsr(data: CsrOptions, keyPem?: PrivateKeyBuffer | PrivateKeyString): Promise<[PrivateKeyBuffer, CsrBuffer]>; +} + +export const crypto: CryptoInterface; + +/* TODO: LEGACY */ +export interface CryptoLegacyInterface { + createPrivateKey(size?: number): Promise; + createPublicKey(key: PrivateKeyBuffer | PrivateKeyString): Promise; + getPemBody(str: string): string; + splitPemChain(str: string): string[]; + getModulus(input: PrivateKeyBuffer | PrivateKeyString | PublicKeyBuffer | PublicKeyString | CertificateBuffer | CertificateString | CsrBuffer | CsrString): Promise; + getPublicExponent(input: PrivateKeyBuffer | PrivateKeyString | PublicKeyBuffer | PublicKeyString | CertificateBuffer | CertificateString | CsrBuffer | CsrString): Promise; + readCsrDomains(csr: CsrBuffer | CsrString): Promise; + readCertificateInfo(cert: CertificateBuffer | CertificateString): Promise; + createCsr(data: CsrOptions, key?: PrivateKeyBuffer | PrivateKeyString): Promise<[PrivateKeyBuffer, CsrBuffer]>; +} + +export const forge: CryptoLegacyInterface; + + +/** + * Axios + */ + +export const axios: AxiosInstance; + + +/** + * Logger + */ + +export function setLogger(fn: (msg: string) => void): void; diff --git a/packages/core/acme-client/types/rfc8555.d.ts b/packages/core/acme-client/types/rfc8555.d.ts new file mode 100644 index 00000000..51b6f3d9 --- /dev/null +++ b/packages/core/acme-client/types/rfc8555.d.ts @@ -0,0 +1,127 @@ +/** + * Account + * + * https://tools.ietf.org/html/rfc8555#section-7.1.2 + * https://tools.ietf.org/html/rfc8555#section-7.3 + * https://tools.ietf.org/html/rfc8555#section-7.3.2 + */ + +export interface Account { + status: 'valid' | 'deactivated' | 'revoked'; + orders: string; + contact?: string[]; + termsOfServiceAgreed?: boolean; + externalAccountBinding?: object; +} + +export interface AccountCreateRequest { + contact?: string[]; + termsOfServiceAgreed?: boolean; + onlyReturnExisting?: boolean; + externalAccountBinding?: object; +} + +export interface AccountUpdateRequest { + status?: string; + contact?: string[]; + termsOfServiceAgreed?: boolean; +} + + +/** + * Order + * + * https://tools.ietf.org/html/rfc8555#section-7.1.3 + * https://tools.ietf.org/html/rfc8555#section-7.4 + */ + +export interface Order { + status: 'pending' | 'ready' | 'processing' | 'valid' | 'invalid'; + identifiers: Identifier[]; + authorizations: string[]; + finalize: string; + expires?: string; + notBefore?: string; + notAfter?: string; + error?: object; + certificate?: string; +} + +export interface OrderCreateRequest { + identifiers: Identifier[]; + notBefore?: string; + notAfter?: string; +} + + +/** + * Authorization + * + * https://tools.ietf.org/html/rfc8555#section-7.1.4 + */ + +export interface Authorization { + identifier: Identifier; + status: 'pending' | 'valid' | 'invalid' | 'deactivated' | 'expired' | 'revoked'; + challenges: Challenge[]; + expires?: string; + wildcard?: boolean; +} + +export interface Identifier { + type: string; + value: string; +} + + +/** + * Challenge + * + * https://tools.ietf.org/html/rfc8555#section-8 + * https://tools.ietf.org/html/rfc8555#section-8.3 + * https://tools.ietf.org/html/rfc8555#section-8.4 + */ + +export interface ChallengeAbstract { + type: string; + url: string; + status: 'pending' | 'processing' | 'valid' | 'invalid'; + validated?: string; + error?: object; +} + +export interface HttpChallenge extends ChallengeAbstract { + type: 'http-01'; + token: string; +} + +export interface DnsChallenge extends ChallengeAbstract { + type: 'dns-01'; + token: string; +} + +export type Challenge = HttpChallenge | DnsChallenge; + + +/** + * Certificate + * + * https://tools.ietf.org/html/rfc8555#section-7.6 + */ + +export enum CertificateRevocationReason { + Unspecified = 0, + KeyCompromise = 1, + CACompromise = 2, + AffiliationChanged = 3, + Superseded = 4, + CessationOfOperation = 5, + CertificateHold = 6, + RemoveFromCRL = 8, + PrivilegeWithdrawn = 9, + AACompromise = 10, +} + +export interface CertificateRevocationRequest { + reason?: CertificateRevocationReason; +} diff --git a/packages/core/acme-client/types/test.ts b/packages/core/acme-client/types/test.ts new file mode 100644 index 00000000..5f19212a --- /dev/null +++ b/packages/core/acme-client/types/test.ts @@ -0,0 +1,70 @@ +/** + * acme-client type definition tests + */ + +import * as acme from 'acme-client'; + + +(async () => { + /* Client */ + const accountKey = await acme.crypto.createPrivateKey(); + + const client = new acme.Client({ + accountKey, + directoryUrl: acme.directory.letsencrypt.staging + }); + + /* Account */ + await client.createAccount({ + termsOfServiceAgreed: true, + contact: ['mailto:test@example.com'] + }); + + /* Order */ + const order = await client.createOrder({ + identifiers: [ + { type: 'dns', value: 'example.com' }, + { type: 'dns', value: '*.example.com' }, + ] + }); + + await client.getOrder(order); + + /* Authorizations / Challenges */ + const authorizations = await client.getAuthorizations(order); + const authorization = authorizations[0]; + const challenge = authorization.challenges[0]; + + await client.getChallengeKeyAuthorization(challenge); + await client.verifyChallenge(authorization, challenge); + await client.completeChallenge(challenge); + await client.waitForValidStatus(challenge); + + /* Finalize */ + const [certKey, certCsr] = await acme.crypto.createCsr({ + commonName: 'example.com', + altNames: ['example.com', '*.example.com'] + }); + + await client.finalizeOrder(order, certCsr); + await client.getCertificate(order); + await client.getCertificate(order, 'DST Root CA X3'); + + /* Auto */ + await client.auto({ + csr: certCsr, + challengeCreateFn: async (authz, challenge, keyAuthorization) => {}, + challengeRemoveFn: async (authz, challenge, keyAuthorization) => {} + }); + + await client.auto({ + csr: certCsr, + email: 'test@example.com', + termsOfServiceAgreed: false, + skipChallengeVerification: false, + challengePriority: ['http-01', 'dns-01'], + preferredChain: 'DST Root CA X3', + challengeCreateFn: async (authz, challenge, keyAuthorization) => {}, + challengeRemoveFn: async (authz, challenge, keyAuthorization) => {} + }); +})(); diff --git a/packages/core/acme-client/types/tsconfig.json b/packages/core/acme-client/types/tsconfig.json new file mode 100644 index 00000000..18b4e398 --- /dev/null +++ b/packages/core/acme-client/types/tsconfig.json @@ -0,0 +1,11 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": ["es6"], + "strict": true, + "noEmit": true, + "esModuleInterop": true, + "baseUrl": ".", + "paths": { "acme-client": ["."] } + } +} diff --git a/packages/core/acme-client/types/tslint.json b/packages/core/acme-client/types/tslint.json new file mode 100644 index 00000000..e650aab5 --- /dev/null +++ b/packages/core/acme-client/types/tslint.json @@ -0,0 +1,6 @@ +{ + "extends": "dtslint/dtslint.json", + "rules": { + "no-consecutive-blank-lines": [true, 2] + } +}