Validate that a ALPN certificate contains the expected key authorization
+
@@ -138,11 +145,11 @@ const jwk = acme.crypto.getJwk(privateKey);
```
-## splitPemChain(chainPem) ⇒ array
+## splitPemChain(chainPem) ⇒ Array.<string>
Split chain of PEM encoded objects from string into array
**Kind**: global function
-**Returns**: array - Array of PEM objects including headers
+**Returns**: Array.<string> - Array of PEM objects including headers
| Param | Type | Description |
| --- | --- | --- |
@@ -219,14 +226,14 @@ Create a Certificate Signing Request
| 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.altNames] | Array.<string> | 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 |
+| [keyPem] | buffer \| string | PEM encoded CSR private key |
**Example**
Create a Certificate Signing Request
@@ -265,3 +272,42 @@ const certificateKey = await acme.crypto.createPrivateEcdsaKey();
const [, certificateRequest] = await acme.crypto.createCsr({
commonName: 'test.example.com'
}, certificateKey);
+
+
+## createAlpnCertificate(authz, keyAuthorization, [keyPem]) ⇒ Promise.<Array.<buffer>>
+Create a self-signed ALPN certificate for TLS-ALPN-01 challenges
+
+https://datatracker.ietf.org/doc/html/rfc8737
+
+**Kind**: global function
+**Returns**: Promise.<Array.<buffer>> - [privateKey, certificate]
+
+| Param | Type | Description |
+| --- | --- | --- |
+| authz | object | Identifier authorization |
+| keyAuthorization | string | Challenge key authorization |
+| [keyPem] | buffer \| string | PEM encoded CSR private key |
+
+**Example**
+Create a ALPN certificate
+```js
+const [alpnKey, alpnCertificate] = await acme.crypto.createAlpnCertificate(authz, keyAuthorization);
+```
+**Example**
+Create a ALPN certificate with ECDSA private key
+```js
+const alpnKey = await acme.crypto.createPrivateEcdsaKey();
+const [, alpnCertificate] = await acme.crypto.createAlpnCertificate(authz, keyAuthorization, alpnKey);
+
+
+## isAlpnCertificateAuthorizationValid(certPem, keyAuthorization) ⇒ boolean
+Validate that a ALPN certificate contains the expected key authorization
+
+**Kind**: global function
+**Returns**: boolean - True when valid
+
+| Param | Type | Description |
+| --- | --- | --- |
+| certPem | buffer \| string | PEM encoded certificate |
+| keyAuthorization | string | Expected challenge key authorization |
+
diff --git a/packages/core/acme-client/docs/forge.md b/packages/core/acme-client/docs/forge.md
index 2d7601fd..09a44de1 100644
--- a/packages/core/acme-client/docs/forge.md
+++ b/packages/core/acme-client/docs/forge.md
@@ -209,7 +209,7 @@ Create a Certificate Signing Request
| data | object | |
| [data.keySize] | number | Size of newly created private key, default: `2048` |
| [data.commonName] | string | |
-| [data.altNames] | array | default: `[]` |
+| [data.altNames] | Array.<string> | default: `[]` |
| [data.country] | string | |
| [data.state] | string | |
| [data.locality] | string | |
diff --git a/packages/core/acme-client/docs/upgrade-v5.md b/packages/core/acme-client/docs/upgrade-v5.md
index a9156244..f34fd6e6 100644
--- a/packages/core/acme-client/docs/upgrade-v5.md
+++ b/packages/core/acme-client/docs/upgrade-v5.md
@@ -4,10 +4,9 @@ This document outlines the breaking changes introduced in v5 of `acme-client`, w
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.
+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 [@peculiar/x509](https://www.npmjs.com/package/@peculiar/x509) module is used to handle generation and parsing of Certificate Signing Requests.
Full documentation of `acme.crypto` can be [found here](crypto.md).
@@ -17,9 +16,9 @@ Below you will find a table summarizing the current `acme.forge` methods, and th
*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
+* :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 |
| ----------------------------- | ----------------------------- | --------------------- |
@@ -33,7 +32,6 @@ Below you will find a table summarizing the current `acme.forge` methods, and th
| `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()`
@@ -49,7 +47,6 @@ const publicKey = await acme.forge.createPublicKey(privateKey);
const publicKey = acme.crypto.getPublicKey(privateKey);
```
-
### 2. `getPemBody` renamed, now returns Base64URL
* Method `getPemBody()` has been renamed to `getPemBodyAsB64u()`
@@ -64,7 +61,6 @@ const body = acme.forge.getPemBody(pem);
const body = acme.crypto.getPemBodyAsB64u(pem);
```
-
### 3. `getModulus` and `getPublicExponent` merged into `getJwk`
* Methods `getModulus()` and `getPublicExponent()` have been removed
@@ -80,7 +76,6 @@ const exp = await acme.forge.getPublicExponent(key);
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
diff --git a/packages/core/acme-client/examples/README.md b/packages/core/acme-client/examples/README.md
new file mode 100644
index 00000000..1c26d611
--- /dev/null
+++ b/packages/core/acme-client/examples/README.md
@@ -0,0 +1,19 @@
+# Disclaimer
+
+These examples should not be used as is for any production environment, as they are just proof of concepts meant for testing and to get you started. The examples are naively written and purposefully avoids important topics since they will be specific to your application and how you choose to use `acme-client`, like for example:
+
+1. **Concurrency control**
+ * If implementing on-demand certificate generation
+ * What happens when multiple requests hit your domain at the same time?
+ * Ensure your application does not place multiple cert orders for the same domain at the same time by implementing some sort of exclusive lock
+2. **Domain allow lists**
+ * If implementing on-demand certificate generation
+ * What happens when someone manipulates the `ServerName` or `Host` header to your service?
+ * Ensure your application is unable to place certificate orders for domains you do not intend, as this can quickly rate limit your account and cause a DoS
+3. **Clustering**
+ * If using `acme-client` across a cluster of servers
+ * Ensure challenge responses are known to all servers in your cluster, perhaps using a database or shared storage
+4. **Certificate and key storage**
+ * Where and how should the account key be stored and read?
+ * Where and how should certificates and cert keys be stored and read?
+ * How and when should they be renewed?
diff --git a/packages/core/acme-client/examples/api.js b/packages/core/acme-client/examples/api.js
index 998201e6..d2b7162a 100644
--- a/packages/core/acme-client/examples/api.js
+++ b/packages/core/acme-client/examples/api.js
@@ -4,7 +4,6 @@
const acme = require('./../');
-
function log(m) {
process.stdout.write(`${m}\n`);
}
diff --git a/packages/core/acme-client/examples/auto.js b/packages/core/acme-client/examples/auto.js
index 1495043b..cd4295d7 100644
--- a/packages/core/acme-client/examples/auto.js
+++ b/packages/core/acme-client/examples/auto.js
@@ -5,7 +5,6 @@
// const fs = require('fs').promises;
const acme = require('./../');
-
function log(m) {
process.stdout.write(`${m}\n`);
}
diff --git a/packages/core/acme-client/examples/dns-01/README.md b/packages/core/acme-client/examples/dns-01/README.md
new file mode 100644
index 00000000..4b55dc4c
--- /dev/null
+++ b/packages/core/acme-client/examples/dns-01/README.md
@@ -0,0 +1,21 @@
+# dns-01
+
+The greatest benefit of `dns-01` is that it is the only challenge type that can be used to issue ACME wildcard certificates, however it also has a few downsides. Your DNS provider needs to offer some sort of API you can use to automate adding and removing the required `TXT` DNS records. Additionally, solving DNS challenges will be much slower than the other challenge types because of DNS propagation delays.
+
+## How it works
+
+When solving `dns-01` challenges, you prove ownership of a domain by serving a specific payload within a specific DNS `TXT` record from the domains authoritative nameservers. The ACME authority provides the client with a token that, along with a thumbprint of your account key, is used to generate a `base64url` encoded `SHA256` digest. This payload is then placed as a `TXT` record under DNS name `_acme-challenge.$YOUR_DOMAIN`.
+
+Once the order is finalized, the ACME authority will lookup your domains DNS record to verify that the payload is correct. `CNAME` and `NS` records are followed, should you wish to delegate challenge response to another DNS zone or record.
+
+## Pros and cons
+
+* Only challenge type that can be used to issue wildcard certificates
+* Your DNS provider needs to supply an API that can be used
+* DNS propagation time may be slow
+* Useful in instances where both port 80 and 443 are unavailable
+
+## External links
+
+* [https://letsencrypt.org/docs/challenge-types/#dns-01-challenge](https://letsencrypt.org/docs/challenge-types/#dns-01-challenge)
+* [https://datatracker.ietf.org/doc/html/rfc8555#section-8.4](https://datatracker.ietf.org/doc/html/rfc8555#section-8.4)
diff --git a/packages/core/acme-client/examples/dns-01/dns-01.js b/packages/core/acme-client/examples/dns-01/dns-01.js
new file mode 100644
index 00000000..68bed46e
--- /dev/null
+++ b/packages/core/acme-client/examples/dns-01/dns-01.js
@@ -0,0 +1,92 @@
+/**
+ * Example using dns-01 challenge to generate certificates
+ *
+ * NOTE: This example is incomplete as the DNS challenge response implementation
+ * will be specific to your DNS providers API.
+ *
+ * NOTE: This example does not order certificates on-demand, as solving dns-01
+ * will likely be too slow for it to make sense. Instead, it orders a wildcard
+ * certificate on init before starting the HTTPS server as a demonstration.
+ */
+
+const https = require('https');
+const acme = require('./../../');
+
+const HTTPS_SERVER_PORT = 443;
+const WILDCARD_DOMAIN = 'example.com';
+
+function log(m) {
+ process.stdout.write(`${(new Date()).toISOString()} ${m}\n`);
+}
+
+
+/**
+ * Main
+ */
+
+(async () => {
+ try {
+ /**
+ * Initialize ACME client
+ */
+
+ log('Initializing ACME client');
+ const client = new acme.Client({
+ directoryUrl: acme.directory.letsencrypt.staging,
+ accountKey: await acme.crypto.createPrivateKey()
+ });
+
+
+ /**
+ * Order wildcard certificate
+ */
+
+ log(`Creating CSR for ${WILDCARD_DOMAIN}`);
+ const [key, csr] = await acme.crypto.createCsr({
+ commonName: WILDCARD_DOMAIN,
+ altNames: [`*.${WILDCARD_DOMAIN}`]
+ });
+
+ log(`Ordering certificate for ${WILDCARD_DOMAIN}`);
+ const cert = await client.auto({
+ csr,
+ email: 'test@example.com',
+ termsOfServiceAgreed: true,
+ challengePriority: ['dns-01'],
+ challengeCreateFn: (authz, challenge, keyAuthorization) => {
+ /* TODO: Implement this */
+ log(`[TODO] Add TXT record key=_acme-challenge.${authz.identifier.value} value=${keyAuthorization}`);
+ },
+ challengeRemoveFn: (authz, challenge, keyAuthorization) => {
+ /* TODO: Implement this */
+ log(`[TODO] Remove TXT record key=_acme-challenge.${authz.identifier.value} value=${keyAuthorization}`);
+ }
+ });
+
+ log(`Certificate for ${WILDCARD_DOMAIN} created successfully`);
+
+
+ /**
+ * HTTPS server
+ */
+
+ const requestListener = (req, res) => {
+ log(`HTTP 200 ${req.headers.host}${req.url}`);
+ res.writeHead(200);
+ res.end('Hello world\n');
+ };
+
+ const httpsServer = https.createServer({
+ key,
+ cert
+ }, requestListener);
+
+ httpsServer.listen(HTTPS_SERVER_PORT, () => {
+ log(`HTTPS server listening on port ${HTTPS_SERVER_PORT}`);
+ });
+ }
+ catch (e) {
+ log(`[FATAL] ${e.message}`);
+ process.exit(1);
+ }
+})();
diff --git a/packages/core/acme-client/examples/fallback.crt b/packages/core/acme-client/examples/fallback.crt
new file mode 100644
index 00000000..100e4781
--- /dev/null
+++ b/packages/core/acme-client/examples/fallback.crt
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDCTCCAfGgAwIBAgIUGwI6ZLE3HN7oRZ9BvWLde0Tsu7EwDQYJKoZIhvcNAQEL
+BQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTIyMDgwMTAwNTMzMVoXDTIyMDgz
+MTAwNTMzMVowFDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEF
+AAOCAQ8AMIIBCgKCAQEA4c7zSiY6OEp9xYZHY42FUfOLREm03NstZhd9IxFFePwe
+CTTirJjmi5teKQwzBmEok0SJkanJUaMsMlOHjEykWSc4SBO4QjD349Q60044i9WS
+7KHzeSqpWTG+V9jF3HOJPw843VG9hXy3ulXKcysTXzumTVQwfatCODBNkpWqMju2
+N33biLgmpqwLbDSfKXS3uSVTfoHAKGT/oRepko7/0Hwr5oEmjXEbpRWRhU09KYjH
+7jokRaiQRn0h216a0r4AKzSNGihNQtKJZIuwJvLFPMQYafsu9qBaCLPqDBXCwQWG
+aYh6Cm3kTkADKzG1LVPB/7/Uh2d4Fck/ejR9qXRK3QIDAQABo1MwUTAdBgNVHQ4E
+FgQUvyceAVDMPbW7wHwNF9px5dWfgd4wHwYDVR0jBBgwFoAUvyceAVDMPbW7wHwN
+F9px5dWfgd4wDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAaYkz
+AOHrRirPwfkwjb+uMliGHfANrmak8r5VDQA73RLTQLRhMpf1yrb1uhH7p/CUYKap
+x1C8RGQAXujoQbQOslyZA7cVLA9ASSZS6Noq7NerfGBiqxeuye+x3lIIk1EOL/rH
+aBu9rrYGmlU49PlGAQSfFHkwzXti2Mp1VQv8eMOBLR49ezZIXHiPE8S3gjNymZ0G
+UA13wzZCT7SG1BLmQ/cBVASG2wvhlC8IG/4vF0Xe+boSOb1vGWUtHS+MnvvRK4n5
+TMUtrnxSQ/LA8AtobvzqgvQVKBSPLK6RzLE7I+Q9pWsbKTBqfyStuQrQFqafBOqN
+eYfPUgiID9uvfrxLvA==
+-----END CERTIFICATE-----
diff --git a/packages/core/acme-client/examples/fallback.key b/packages/core/acme-client/examples/fallback.key
new file mode 100644
index 00000000..1cbd8f66
--- /dev/null
+++ b/packages/core/acme-client/examples/fallback.key
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDhzvNKJjo4Sn3F
+hkdjjYVR84tESbTc2y1mF30jEUV4/B4JNOKsmOaLm14pDDMGYSiTRImRqclRoywy
+U4eMTKRZJzhIE7hCMPfj1DrTTjiL1ZLsofN5KqlZMb5X2MXcc4k/DzjdUb2FfLe6
+VcpzKxNfO6ZNVDB9q0I4ME2SlaoyO7Y3fduIuCamrAtsNJ8pdLe5JVN+gcAoZP+h
+F6mSjv/QfCvmgSaNcRulFZGFTT0piMfuOiRFqJBGfSHbXprSvgArNI0aKE1C0olk
+i7Am8sU8xBhp+y72oFoIs+oMFcLBBYZpiHoKbeROQAMrMbUtU8H/v9SHZ3gVyT96
+NH2pdErdAgMBAAECggEBAImI0FxQblOM45AkmmTDdPmWWjPspNGEWeF92wU55tOq
+0+yNnqa7tmg/6JkdyhJPqTQRoazr+ifUN/4rLDtDDzMSFVCpWihOxR2qTW4YjY52
+NjgU6EPbvSwLhUDiUplUcbrL3bnHqKSecxV2XYnKKdFudntRFPvmDL5GhWkL6Y8P
+9KiQaYuPf4av8PR0NlWBMiZs+CBjLlnSTMAWRYj5mRSyFSEOMT7+Lvr3TqrO2/nh
+0H30LXxrXXXuCbQXnVy3oSNf7TrathT2ADIrUUTdRHsLscvkEA35VtFQtWdJLtEg
+sso1J7viV9YDU4niPSdHPj3ubBjAExej4qCOzatsIQ0CgYEA8L5S3ojy89g7q6vB
+QuusIrjGkyM1yebDWqhEnjvlMpfrU1hCS90BM1ozZ28bjz/7PBimKL+A8BO+W0m4
+2s9YbZP5aGwo18Iq86XEdtDgWtQ3NXbYkb8F8LNtyevC/UlAI/xyIRr7hDYlr/1v
+jJg16DXiNLyk+uj4Q3EuwzNl8n8CgYEA8B5UUkOiufPtm+ZOq9AlBpIa+NYaahZM
+h52jzMTKsFB18xsZU/ufvpKvXEu1sTeCDRo3JAHmiA6AG292Zc7W+uWRtMtlmQWE
+wnoZ6hKvEkFnArLCY6Nm5Qqm1wipLwDVO3dD/CDL86siHrXK4wU7Q+bp6xbt8lDi
+itz5F7p7HKMCgYAoj8iimexlTU9wczXSsqaECyHZ9JrBc9ICWkuFZY4OYi5SEpLI
++WmUX2Q9zyiTkDIiQ/zq7KkqygjOlLNCmqDJhZ8GCwMupxZZitp5MmQ6qXrL1URT
++h1kGrcqyEBIMKlP5t7L2SH7eqwK5OaAh7y9bSa5v/cEF3CM3GsGlIhevQKBgBGU
+RtwW84zlnNmzDMNrY6qNe8gH9LsbktLC6cEOD0DFQz1fGIWbgGB1YL1DFbQ5uh23
+c54BPZ1sYlif2m0trXOE5xvzYCbJzqRmSAto/sQ5YY9DAxREXD4cf4ZyreAxEWtf
+Ge0VgZj/SGozKP1h3qrj9vAtJ5J79XnxH5NrJaQ9AoGBAM2rQrt8H2kizg4wMGRZ
+0G3709W7xxlbPdm+i/jFVDayJswCr0+eMm4gGyyZL3135D0fcijxytKgg3/OpOJF
+jC9vsHsE2K1ATp6eYvYjrhqJHI1m44aq/h46SfajytZQjwMT/jaApULDP2/fCBm5
+6eS2WCyHyrYJyrgoYQF56nsT
+-----END PRIVATE KEY-----
diff --git a/packages/core/acme-client/examples/http-01/README.md b/packages/core/acme-client/examples/http-01/README.md
new file mode 100644
index 00000000..a08cace1
--- /dev/null
+++ b/packages/core/acme-client/examples/http-01/README.md
@@ -0,0 +1,21 @@
+# http-01
+
+The `http-01` challenge type is the simplest to implement and should likely be your default choice, unless you either require wildcard certificates or if port 80 is unavailable for use.
+
+## How it works
+
+When solving `http-01` challenges, you prove ownership of a domain name by serving a specific payload from a specific URL. The ACME authority provides the client with a token that is used to generate the URL and file contents. The file must exist at `http://$YOUR_DOMAIN/.well-known/acme-challenge/$TOKEN` and contain the token and a thumbprint of your account key.
+
+Once the order is finalized, the ACME authority will verify that the URL responds with the correct payload by sending HTTP requests before the challenge is valid. HTTP redirects are followed, and Let's Encrypt allows redirecting to HTTPS although this diverges from the ACME spec.
+
+## Pros and cons
+
+* Challenge must be satisfied using port 80 (HTTP)
+* The simplest challenge type to implement
+* Can not be used to issue wildcard certificates
+* If using multiple web servers, all of them need to respond with the correct token
+
+## External links
+
+* [https://letsencrypt.org/docs/challenge-types/#http-01-challenge](https://letsencrypt.org/docs/challenge-types/#http-01-challenge)
+* [https://datatracker.ietf.org/doc/html/rfc8555#section-8.3](https://datatracker.ietf.org/doc/html/rfc8555#section-8.3)
diff --git a/packages/core/acme-client/examples/http-01/http-01.js b/packages/core/acme-client/examples/http-01/http-01.js
new file mode 100644
index 00000000..75153385
--- /dev/null
+++ b/packages/core/acme-client/examples/http-01/http-01.js
@@ -0,0 +1,172 @@
+/**
+ * Example using http-01 challenge to generate certificates on-demand
+ */
+
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+const tls = require('tls');
+const acme = require('./../../');
+
+const HTTP_SERVER_PORT = 80;
+const HTTPS_SERVER_PORT = 443;
+const VALID_DOMAINS = ['example.com', 'example.org'];
+const FALLBACK_KEY = fs.readFileSync(path.join(__dirname, '..', 'fallback.key'));
+const FALLBACK_CERT = fs.readFileSync(path.join(__dirname, '..', 'fallback.crt'));
+
+const pendingDomains = {};
+const challengeResponses = {};
+const certificateStore = {};
+
+function log(m) {
+ process.stdout.write(`${(new Date()).toISOString()} ${m}\n`);
+}
+
+
+/**
+ * On-demand certificate generation using http-01
+ */
+
+async function getCertOnDemand(client, servername, attempt = 0) {
+ /* Invalid domain */
+ if (!VALID_DOMAINS.includes(servername)) {
+ throw new Error(`Invalid domain: ${servername}`);
+ }
+
+ /* Certificate exists */
+ if (servername in certificateStore) {
+ return certificateStore[servername];
+ }
+
+ /* Waiting on certificate order to go through */
+ if (servername in pendingDomains) {
+ if (attempt >= 10) {
+ throw new Error(`Gave up waiting on certificate for ${servername}`);
+ }
+
+ await new Promise((resolve) => { setTimeout(resolve, 1000); });
+ return getCertOnDemand(client, servername, (attempt + 1));
+ }
+
+ /* Create CSR */
+ log(`Creating CSR for ${servername}`);
+ const [key, csr] = await acme.crypto.createCsr({
+ commonName: servername
+ });
+
+ /* Order certificate */
+ log(`Ordering certificate for ${servername}`);
+ const cert = await client.auto({
+ csr,
+ email: 'test@example.com',
+ termsOfServiceAgreed: true,
+ challengePriority: ['http-01'],
+ challengeCreateFn: (authz, challenge, keyAuthorization) => {
+ challengeResponses[challenge.token] = keyAuthorization;
+ },
+ challengeRemoveFn: (authz, challenge) => {
+ delete challengeResponses[challenge.token];
+ }
+ });
+
+ /* Done, store certificate */
+ log(`Certificate for ${servername} created successfully`);
+ certificateStore[servername] = [key, cert];
+ delete pendingDomains[servername];
+ return certificateStore[servername];
+}
+
+
+/**
+ * Main
+ */
+
+(async () => {
+ try {
+ /**
+ * Initialize ACME client
+ */
+
+ log('Initializing ACME client');
+ const client = new acme.Client({
+ directoryUrl: acme.directory.letsencrypt.staging,
+ accountKey: await acme.crypto.createPrivateKey()
+ });
+
+
+ /**
+ * HTTP server
+ */
+
+ const httpServer = http.createServer((req, res) => {
+ if (req.url.match(/\/\.well-known\/acme-challenge\/.+/)) {
+ const token = req.url.split('/').pop();
+ log(`Received challenge request for token=${token}`);
+
+ /* ACME challenge response */
+ if (token in challengeResponses) {
+ log(`Serving challenge response HTTP 200 token=${token}`);
+ res.writeHead(200);
+ res.end(challengeResponses[token]);
+ return;
+ }
+
+ /* Challenge response not found */
+ log(`Oops, challenge response not found for token=${token}`);
+ res.writeHead(404);
+ res.end();
+ return;
+ }
+
+ /* HTTP 302 redirect */
+ log(`HTTP 302 ${req.headers.host}${req.url}`);
+ res.writeHead(302, { Location: `https://${req.headers.host}${req.url}` });
+ res.end();
+ });
+
+ httpServer.listen(HTTP_SERVER_PORT, () => {
+ log(`HTTP server listening on port ${HTTP_SERVER_PORT}`);
+ });
+
+
+ /**
+ * HTTPS server
+ */
+
+ const requestListener = (req, res) => {
+ log(`HTTP 200 ${req.headers.host}${req.url}`);
+ res.writeHead(200);
+ res.end('Hello world\n');
+ };
+
+ const httpsServer = https.createServer({
+ /* Fallback certificate */
+ key: FALLBACK_KEY,
+ cert: FALLBACK_CERT,
+
+ /* Serve certificate based on servername */
+ SNICallback: async (servername, cb) => {
+ try {
+ log(`Handling SNI request for ${servername}`);
+ const [key, cert] = await getCertOnDemand(client, servername);
+
+ log(`Found certificate for ${servername}, serving secure context`);
+ cb(null, tls.createSecureContext({ key, cert }));
+ }
+ catch (e) {
+ log(`[ERROR] ${e.message}`);
+ cb(e.message);
+ }
+ }
+ }, requestListener);
+
+ httpsServer.listen(HTTPS_SERVER_PORT, () => {
+ log(`HTTPS server listening on port ${HTTPS_SERVER_PORT}`);
+ });
+ }
+ catch (e) {
+ log(`[FATAL] ${e.message}`);
+ process.exit(1);
+ }
+})();
diff --git a/packages/core/acme-client/examples/tls-alpn-01/README.md b/packages/core/acme-client/examples/tls-alpn-01/README.md
new file mode 100644
index 00000000..40863519
--- /dev/null
+++ b/packages/core/acme-client/examples/tls-alpn-01/README.md
@@ -0,0 +1,44 @@
+# tls-alpn-01
+
+Responding to `tls-alpn-01` challenges using Node.js is a bit more involved than the other two challenge types, and requires a proxy (f.ex. [Nginx](https://nginx.org) or [HAProxy](https://www.haproxy.org)) in front of the Node.js service. The reason for this is that `tls-alpn-01` is solved by responding to the ACME challenge using self-signed certificates with an ALPN extension containing the challenge response.
+
+Since we don't want users of our application to be served with these self-signed certificates, we need to split the HTTPS traffic into two different Node.js backends - one that only serves ALPN certificates for challenge responses, and the other for actual end-user traffic that serves certificates retrieved from the ACME provider. As far as I *(library author)* know, routing HTTPS traffic based on ALPN protocol can not be done purely using Node.js.
+
+The end result should look something like this:
+
+```text
+Nginx or HAProxy (0.0.0.0:443)
+ *inspect requests SSL ALPN protocol*
+ If ALPN == acme-tls/1
+ -> Node.js ALPN responder (127.0.0.1:4444)
+ Else
+ -> Node.js HTTPS server (127.0.0.1:4443)
+```
+
+Example proxy configuration:
+
+* [haproxy.cfg](haproxy.cfg) *(requires HAProxy >= v1.9.1)*
+* [nginx.conf](nginx.conf) *(requires [ngx_stream_ssl_preread_module](https://nginx.org/en/docs/stream/ngx_stream_ssl_preread_module.html))*
+
+Big thanks to [acme.sh](https://github.com/acmesh-official/acme.sh) and [dehydrated](https://github.com/dehydrated-io/dehydrated) for doing the legwork and providing Nginx and HAProxy config examples.
+
+## How it works
+
+When solving `tls-alpn-01` challenges, you prove ownership of a domain name by serving a specially crafted certificate over HTTPS. The ACME authority provides the client with a token that is placed into the certificates `id-pe-acmeIdentifier` extension along with a thumbprint of your account key.
+
+Once the order is finalized, the ACME authority will verify by sending HTTPS requests to your domain with the `acme-tls/1` ALPN protocol, indicating to the server that it should serve the challenge response certificate. If the `id-pe-acmeIdentifier` extension contains the correct payload, the challenge is valid.
+
+## Pros and cons
+
+* Challenge must be satisfied using port 443 (HTTPS)
+* Useful in instances where port 80 is unavailable
+* Can not be used to issue wildcard certificates
+* More complex than `http-01`, can not be solved purely using Node.js
+* If using multiple web servers, all of them need to respond with the correct certificate
+
+## External links
+
+* [https://letsencrypt.org/docs/challenge-types/#tls-alpn-01](https://letsencrypt.org/docs/challenge-types/#tls-alpn-01)
+* [https://github.com/dehydrated-io/dehydrated/blob/master/docs/tls-alpn.md](https://github.com/dehydrated-io/dehydrated/blob/master/docs/tls-alpn.md)
+* [https://github.com/acmesh-official/acme.sh/wiki/TLS-ALPN-without-downtime](https://github.com/acmesh-official/acme.sh/wiki/TLS-ALPN-without-downtime)
+* [https://datatracker.ietf.org/doc/html/rfc8737](https://datatracker.ietf.org/doc/html/rfc8737)
diff --git a/packages/core/acme-client/examples/tls-alpn-01/haproxy.cfg b/packages/core/acme-client/examples/tls-alpn-01/haproxy.cfg
new file mode 100644
index 00000000..5a99be7c
--- /dev/null
+++ b/packages/core/acme-client/examples/tls-alpn-01/haproxy.cfg
@@ -0,0 +1,23 @@
+##
+# HTTPS listener
+# - Send to ALPN responder port 4444 if protocol is acme-tls/1
+# - Default to HTTPS backend port 4443
+##
+
+frontend https
+ mode tcp
+ bind :443
+ tcp-request inspect-delay 5s
+ tcp-request content accept if { req_ssl_hello_type 1 }
+ use_backend alpnresp if { req.ssl_alpn acme-tls/1 }
+ default_backend https
+
+# Default HTTPS backend
+backend https
+ mode tcp
+ server https 127.0.0.1:4443
+
+# ACME tls-alpn-01 responder backend
+backend alpnresp
+ mode tcp
+ server acmesh 127.0.0.1:4444
diff --git a/packages/core/acme-client/examples/tls-alpn-01/nginx.conf b/packages/core/acme-client/examples/tls-alpn-01/nginx.conf
new file mode 100644
index 00000000..cb4aa7b6
--- /dev/null
+++ b/packages/core/acme-client/examples/tls-alpn-01/nginx.conf
@@ -0,0 +1,19 @@
+##
+# HTTPS server
+# - Send to ALPN responder port 4444 if protocol is acme-tls/1
+# - Default to HTTPS backend port 4443
+##
+
+stream {
+ map $ssl_preread_alpn_protocols $tls_port {
+ ~\bacme-tls/1\b 4444;
+ default 4443;
+ }
+
+ server {
+ listen 443;
+ listen [::]:443;
+ proxy_pass 127.0.0.1:$tls_port;
+ ssl_preread on;
+ }
+}
diff --git a/packages/core/acme-client/examples/tls-alpn-01/tls-alpn-01.js b/packages/core/acme-client/examples/tls-alpn-01/tls-alpn-01.js
new file mode 100644
index 00000000..e04d73c1
--- /dev/null
+++ b/packages/core/acme-client/examples/tls-alpn-01/tls-alpn-01.js
@@ -0,0 +1,180 @@
+/**
+ * Example using tls-alpn-01 challenge to generate certificates on-demand
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const tls = require('tls');
+const acme = require('./../../');
+
+const HTTPS_SERVER_PORT = 4443;
+const ALPN_RESPONDER_PORT = 4444;
+const VALID_DOMAINS = ['example.com', 'example.org'];
+const FALLBACK_KEY = fs.readFileSync(path.join(__dirname, '..', 'fallback.key'));
+const FALLBACK_CERT = fs.readFileSync(path.join(__dirname, '..', 'fallback.crt'));
+
+const pendingDomains = {};
+const alpnResponses = {};
+const certificateStore = {};
+
+function log(m) {
+ process.stdout.write(`${(new Date()).toISOString()} ${m}\n`);
+}
+
+
+/**
+ * On-demand certificate generation using tls-alpn-01
+ */
+
+async function getCertOnDemand(client, servername, attempt = 0) {
+ /* Invalid domain */
+ if (!VALID_DOMAINS.includes(servername)) {
+ throw new Error(`Invalid domain: ${servername}`);
+ }
+
+ /* Certificate exists */
+ if (servername in certificateStore) {
+ return certificateStore[servername];
+ }
+
+ /* Waiting on certificate order to go through */
+ if (servername in pendingDomains) {
+ if (attempt >= 10) {
+ throw new Error(`Gave up waiting on certificate for ${servername}`);
+ }
+
+ await new Promise((resolve) => { setTimeout(resolve, 1000); });
+ return getCertOnDemand(client, servername, (attempt + 1));
+ }
+
+ /* Create CSR */
+ log(`Creating CSR for ${servername}`);
+ const [key, csr] = await acme.crypto.createCsr({
+ commonName: servername
+ });
+
+ /* Order certificate */
+ log(`Ordering certificate for ${servername}`);
+ const cert = await client.auto({
+ csr,
+ email: 'test@example.com',
+ termsOfServiceAgreed: true,
+ challengePriority: ['tls-alpn-01'],
+ challengeCreateFn: async (authz, challenge, keyAuthorization) => {
+ alpnResponses[authz.identifier.value] = await acme.crypto.createAlpnCertificate(authz, keyAuthorization);
+ },
+ challengeRemoveFn: (authz) => {
+ delete alpnResponses[authz.identifier.value];
+ }
+ });
+
+ /* Done, store certificate */
+ log(`Certificate for ${servername} created successfully`);
+ certificateStore[servername] = [key, cert];
+ delete pendingDomains[servername];
+ return certificateStore[servername];
+}
+
+
+/**
+ * Main
+ */
+
+(async () => {
+ try {
+ /**
+ * Initialize ACME client
+ */
+
+ log('Initializing ACME client');
+ const client = new acme.Client({
+ directoryUrl: acme.directory.letsencrypt.staging,
+ accountKey: await acme.crypto.createPrivateKey()
+ });
+
+
+ /**
+ * ALPN responder
+ */
+
+ const alpnResponder = https.createServer({
+ /* Fallback cert */
+ key: FALLBACK_KEY,
+ cert: FALLBACK_CERT,
+
+ /* Allow acme-tls/1 ALPN protocol */
+ ALPNProtocols: ['acme-tls/1'],
+
+ /* Serve ALPN certificate based on servername */
+ SNICallback: async (servername, cb) => {
+ try {
+ log(`Handling ALPN SNI request for ${servername}`);
+ if (!Object.keys(alpnResponses).includes(servername)) {
+ throw new Error(`No ALPN certificate found for ${servername}`);
+ }
+
+ /* Serve ALPN challenge response */
+ log(`Found ALPN certificate for ${servername}, serving secure context`);
+ cb(null, tls.createSecureContext({
+ key: alpnResponses[servername][0],
+ cert: alpnResponses[servername][1]
+ }));
+ }
+ catch (e) {
+ log(`[ERROR] ${e.message}`);
+ cb(e.message);
+ }
+ }
+ });
+
+ /* Terminate once TLS handshake has been established */
+ alpnResponder.on('secureConnection', (socket) => {
+ socket.end();
+ });
+
+ alpnResponder.listen(ALPN_RESPONDER_PORT, () => {
+ log(`ALPN responder listening on port ${ALPN_RESPONDER_PORT}`);
+ });
+
+
+ /**
+ * HTTPS server
+ */
+
+ const requestListener = (req, res) => {
+ log(`HTTP 200 ${req.headers.host}${req.url}`);
+ res.writeHead(200);
+ res.end('Hello world\n');
+ };
+
+ const httpsServer = https.createServer({
+ /* Fallback cert */
+ key: FALLBACK_KEY,
+ cert: FALLBACK_CERT,
+
+ /* Serve certificate based on servername */
+ SNICallback: async (servername, cb) => {
+ try {
+ log(`Handling SNI request for ${servername}`);
+ const [key, cert] = await getCertOnDemand(client, servername);
+
+ log(`Found certificate for ${servername}, serving secure context`);
+ cb(null, tls.createSecureContext({ key, cert }));
+ }
+ catch (e) {
+ log(`[ERROR] ${e.message}`);
+ cb(e.message);
+ }
+ }
+ }, requestListener);
+
+ httpsServer.listen(HTTPS_SERVER_PORT, () => {
+ log(`HTTPS server listening on port ${HTTPS_SERVER_PORT}`);
+ });
+ }
+ catch (e) {
+ log(`[FATAL] ${e.message}`);
+ process.exit(1);
+ }
+})();
diff --git a/packages/core/acme-client/package.json b/packages/core/acme-client/package.json
index 7a2230d7..10521187 100644
--- a/packages/core/acme-client/package.json
+++ b/packages/core/acme-client/package.json
@@ -5,7 +5,7 @@
"author": "nmorsman",
"version": "1.20.2",
"main": "src/index.js",
- "types": "types",
+ "types": "types/index.d.ts",
"license": "MIT",
"homepage": "https://github.com/publishlab/node-acme-client",
"engines": {
@@ -16,32 +16,32 @@
"types"
],
"dependencies": {
- "axios": "0.27.2",
+ "@peculiar/x509": "^1.9.7",
+ "asn1js": "^3.0.5",
+ "axios": "^1.6.5",
"debug": "^4.1.1",
- "jsrsasign": "^10.5.26",
"node-forge": "^1.3.1"
},
"devDependencies": {
- "@types/node": "^18.6.1",
- "chai": "^4.3.6",
+ "@types/node": "^20.11.5",
+ "chai": "^4.4.1",
"chai-as-promised": "^7.1.1",
- "dtslint": "^4.2.1",
- "eslint": "^8.11.0",
+ "eslint": "^8.56.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",
+ "eslint-plugin-import": "^2.29.1",
+ "jsdoc-to-markdown": "^8.0.0",
+ "mocha": "^10.2.0",
+ "nock": "^13.5.0",
+ "tsd": "^0.30.4",
"typescript": "^4.8.4",
"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",
+ "lint-types": "tsd",
"prepublishOnly": "npm run build-docs",
- "test": "mocha -t 60000 \"test/setup.js\" \"test/**/*.spec.js\"",
- "test-local": "/bin/bash scripts/run-tests.sh"
+ "test": "mocha -t 60000 \"test/setup.js\" \"test/**/*.spec.js\""
},
"repository": {
"type": "git",
diff --git a/packages/core/acme-client/scripts/run-tests.sh b/packages/core/acme-client/scripts/run-tests.sh
deleted file mode 100644
index b0613ac2..00000000
--- a/packages/core/acme-client/scripts/run-tests.sh
+++ /dev/null
@@ -1,56 +0,0 @@
-#!/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-step.sh b/packages/core/acme-client/scripts/test-suite-install-step.sh
deleted file mode 100644
index 5de092a5..00000000
--- a/packages/core/acme-client/scripts/test-suite-install-step.sh
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/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/src/api.js b/packages/core/acme-client/src/api.js
index 84fe0f88..31c06f52 100644
--- a/packages/core/acme-client/src/api.js
+++ b/packages/core/acme-client/src/api.js
@@ -41,7 +41,7 @@ class AcmeApi {
* @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 {number[]} [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`
@@ -66,7 +66,7 @@ class AcmeApi {
* @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 {number[]} [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`
@@ -82,7 +82,7 @@ class AcmeApi {
/**
* Get Terms of Service URL if available
*
- * https://tools.ietf.org/html/rfc8555#section-7.1.1
+ * https://datatracker.ietf.org/doc/html/rfc8555#section-7.1.1
*
* @returns {Promise} ToS URL
*/
@@ -95,7 +95,7 @@ class AcmeApi {
/**
* Create new account
*
- * https://tools.ietf.org/html/rfc8555#section-7.3
+ * https://datatracker.ietf.org/doc/html/rfc8555#section-7.3
*
* @param {object} data Request payload
* @returns {Promise