v1.20.10

[acme] sync upgrade [trident-sync]

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,21 @@
+> 感谢您支持certd，请按如下规范提交issue    
+> 如果有条件，请尽量在[github上提交](https://github.com/certd/certd/issues)
+
+
+## 一、问题描述
+`请在此处简要描述你所遇到的问题，必要时请贴出相关截图辅助理解和定位`
+
+### 复现步骤
+`请描述复现问题的详细步骤`
+`如果非示例页面的问题，最好能提供最小复现示例的代码、或者仓库链接`
+
+
+### 报错截图
+`请贴出报错日志截图`
+
+### 效果截图
+`请贴出效果截图`
+#### 1. 期望效果
+
+#### 2. 实际效果
+

.github/workflows/sync-to-gitee.yml

@@ -0,0 +1,35 @@
+name: sync-to-gitee
+on:
+  push:
+    branches: ['v2']
+  pull_request:
+    branches: ['v2']
+#  schedule:
+#    - # 国际时间 19:17 执行，北京时间3:17  ↙↙↙ 改成你想要每天自动执行的时间
+#    - cron: '17 19 * * *'
+permissions:
+  contents: read
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout work repo            # 1. 检出当前仓库(certd-sync-work)
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Set git user                  # 2. 给git命令设置用户名和邮箱,↙↙↙ 改成你的name和email
+        run: |
+          git config --global user.name "xiaojunnuo"
+          git config --global user.email "xiaojunnuo@qq.com"
+
+      - name: Set git token                 # 3. 给git命令设置token，用于push到目标仓库
+        uses: de-vri-es/setup-git-credentials@v2
+        with:                              # token 格式为： username:password
+          credentials: https://${{secrets.PUSH_TOKEN_GITEE}}@gitee.com
+
+      - name: push to gitee               # 4. 执行同步
+        run: |
+          git remote add upstream https://gitee.com/certd/certd
+          git push --set-upstream upstream v2
+

.gitignore

@@ -1,9 +1,19 @@
+./packages/core/lego
 # 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/
 /test/*.private.*
 
 /*.log
@@ -18,3 +28,9 @@ node_modules/
 /other
 /dev-sidecar-test
 /packages/core/certd/yarn.lock
+/packages/test
+/test/own
+/pnpm-lock.yaml
+
+docker/image/workspace
+/packages/core/lego

CHANGELOG.md

@@ -0,0 +1,141 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## [1.20.10](https://github.com/certd/certd/compare/v1.20.9...v1.20.10) (2024-05-30)
+
+### Bug Fixes
+
+* 增加权限相关helper说明 ([83e4083](https://github.com/certd/certd/commit/83e40836ebff10bec60efe8933183e1ba1c22bf9))
+* 增加权限相关helper说明 ([4304c94](https://github.com/certd/certd/commit/4304c9443ad9248f63dd6d8c512d8d6f32f90d37))
+
+### Performance Improvements
+
+* 上传到主机插件支持复制到本机路径 ([92446c3](https://github.com/certd/certd/commit/92446c339936f98f08f654b8971a7393d8435224))
+* 优化文件下载包名 ([d9eb927](https://github.com/certd/certd/commit/d9eb927b0a1445feab08b1958aa9ea80637a5ae6))
+* 增加任务复制功能 ([39ad759](https://github.com/certd/certd/commit/39ad7597fa0e19cc1f7631bbd6fea0a9e05a62c9))
+
+## [1.20.9](https://github.com/certd/certd/compare/v1.20.8...v1.20.9) (2024-03-22)
+
+**Note:** Version bump only for package root
+
+## [1.20.8](https://github.com/certd/certd/compare/v1.20.7...v1.20.8) (2024-03-22)
+
+**Note:** Version bump only for package root
+
+## [1.20.7](https://github.com/certd/certd/compare/v1.20.6...v1.20.7) (2024-03-22)
+
+**Note:** Version bump only for package root
+
+## [1.20.6](https://github.com/certd/certd/compare/v1.20.5...v1.20.6) (2024-03-21)
+
+### Bug Fixes
+
+* 调整按钮图标到居中位置 ([836d18f](https://github.com/certd/certd/commit/836d18f07e22d00faf2f213bc3301a6672b5bafc))
+
+### Performance Improvements
+
+* 插件贡献文档及示例 ([72fb20a](https://github.com/certd/certd/commit/72fb20abf3ba5bdd862575d2907703a52fd7eb17))
+
+## [1.20.5](https://github.com/certd/certd/compare/v1.20.2...v1.20.5) (2024-03-11)
+
+### Bug Fixes
+
+* 修复腾讯云cdn部署无法选择端点的bug ([154409b](https://github.com/certd/certd/commit/154409b1dfee3ea1caae740ad9c1f99a6e7a9814))
+
+## [1.20.2](https://github.com/certd/certd/compare/v1.2.1...v1.20.2) (2024-02-28)
+
+### Bug Fixes
+
+* 临时修复阿里云domainlist接口返回域名列表不全的问题，后续还需要增加翻页查询 ([849c145](https://github.com/certd/certd/commit/849c145926984762bd9dbec87bd91cd047fc0855))
+
+## [1.2.1](https://github.com/certd/certd/compare/v1.2.0...v1.2.1) (2023-12-12)
+
+### Bug Fixes
+
+* 修复邮箱设置无效的bug ([aaa3224](https://github.com/certd/certd/commit/aaa322464d0f65e924d1850995540d396ee24d25))
+
+**Note:** Version bump only for package root
+
+# [1.2.0](https://github.com/certd/certd/compare/v1.1.6...v1.2.0) (2023-10-27)
+
+* 🔱: [client] sync upgrade with 2 commits [trident-sync] ([aa3207f](https://github.com/certd/certd/commit/aa3207fca5f15f7c3da789989d99c8ae7d1c4551))
+
+### BREAKING CHANGES
+
+* search支持自定义布局，search.layout、search.collapse转移到 search.container之下。如果想使用原来的search组件，请配置search.is=fs-search-v1
+
+## [1.1.6](https://github.com/certd/certd/compare/v1.1.5...v1.1.6) (2023-07-10)
+
+### Bug Fixes
+
+* 修复上传证书到腾讯云失败的bug ([e950322](https://github.com/certd/certd/commit/e950322232e19d1263b8552eefa5b0150fd7864e))
+
+## [1.1.5](https://github.com/certd/certd/compare/v1.1.4...v1.1.5) (2023-07-03)
+
+**Note:** Version bump only for package root
+
+## [1.1.4](https://github.com/certd/certd/compare/v1.1.3...v1.1.4) (2023-07-03)
+
+### Bug Fixes
+
+* 成功图标转动的问题 ([f87eee3](https://github.com/certd/certd/commit/f87eee3b9ff1ef9874e79a81fe0ed7104cb9ee8c))
+
+### Performance Improvements
+
+* cancel task ([bc65c0a](https://github.com/certd/certd/commit/bc65c0a786360c087fe95cad93ec6a87804cc5ee))
+* flush log ([891a43a](https://github.com/certd/certd/commit/891a43ae6716ff98ed06643f7da2e35199ee195c))
+* flush logger ([91be682](https://github.com/certd/certd/commit/91be6826b902e0f302b1a6cbdb1d24e15914c18d))
+* timeout ([3eeb1f7](https://github.com/certd/certd/commit/3eeb1f77aa2922f3545f3d2067f561d95621d54f))
+
+## [1.1.3](https://github.com/certd/certd/compare/v1.1.2...v1.1.3) (2023-07-03)
+
+**Note:** Version bump only for package root
+
+## [1.1.2](https://github.com/certd/certd/compare/v1.1.1...v1.1.2) (2023-07-03)
+
+**Note:** Version bump only for package root
+
+## [1.1.1](https://github.com/certd/certd/compare/v1.1.0...v1.1.1) (2023-06-28)
+
+**Note:** Version bump only for package root
+
+# [1.1.0](https://github.com/certd/certd/compare/v1.0.6...v1.1.0) (2023-06-28)
+
+### Bug Fixes
+
+* 修复access选择类型trigger ([2851a33](https://github.com/certd/certd/commit/2851a33eb2510f038fadb55da29512597a4ba512))
+
+### Features
+
+* 权限控制 ([27a4c81](https://github.com/certd/certd/commit/27a4c81c6d70e70abb3892c3ea58d4719988808a))
+* 邮件通知 ([937e3fa](https://github.com/certd/certd/commit/937e3fac19cd03b8aa91db8ba03fda7fcfbacea2))
+* cert download ([5a51c14](https://github.com/certd/certd/commit/5a51c14de521cb8075a80d2ae41a16e6d5281259))
+* config  merge ([fdc25dc](https://github.com/certd/certd/commit/fdc25dc0d795555cffacc4572648ec158988fbbb))
+* save files ([99522fb](https://github.com/certd/certd/commit/99522fb49adb42c1dfdf7bec3dd52d641158285b))
+* save files ([671d273](https://github.com/certd/certd/commit/671d273e2f9136d16896536b0ca127cf372f1619))
+
+## [1.0.6](https://github.com/certd/certd/compare/v1.0.5...v1.0.6) (2023-05-25)
+
+**Note:** Version bump only for package root
+
+## [1.0.5](https://github.com/certd/certd/compare/v1.0.4...v1.0.5) (2023-05-25)
+
+**Note:** Version bump only for package root
+
+## [1.0.4](https://github.com/certd/certd/compare/v1.0.3...v1.0.4) (2023-05-25)
+
+**Note:** Version bump only for package root
+
+## [1.0.3](https://github.com/certd/certd/compare/v1.0.2...v1.0.3) (2023-05-25)
+
+**Note:** Version bump only for package root
+
+## [1.0.2](https://github.com/certd/certd/compare/v1.0.1...v1.0.2) (2023-05-24)
+
+**Note:** Version bump only for package root
+
+## [1.0.1](https://github.com/certd/certd/compare/v1.0.0...v1.0.1) (2023-05-24)
+
+**Note:** Version bump only for package root

LICENSE

@@ -1,21 +1,661 @@
-MIT License
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
 
-Copyright (c) 2021 Greper
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-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:
+                            Preamble
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server 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.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

README.md

@@ -1,139 +1,136 @@
 # CertD
 
-CertD 是一个帮助你全自动申请和部署SSL证书的工具。       
+CertD 是一个免费全自动申请和部署SSL证书的工具。       
 后缀D取自linux守护进程的命名风格，意为证书守护进程。    
 
-## 特性
+## 一、特性
 本项目不仅支持证书申请过程自动化，还可以自动化部署证书，让你的证书永不过期。     
 
-* 全自动申请证书
-* 全自动部署证书（目前支持服务器上传部署、阿里云、腾讯云等）
-* 可与CI/DI工具结合使用
+* 全自动申请证书（支持阿里云、腾讯云、华为云注册的域名）
+* 全自动部署证书（目前支持服务器上传部署、部署到阿里云、腾讯云等）
+* 支持通配符域名
+* 支持多个域名打到一个证书上
+* 邮件通知
+* 证书自动更新
+* 免费、免费、免费（[阿里云单个通配符域名证书最便宜也要1800/年](https://yundun.console.aliyun.com/?p=cas#/certExtend/buy/cn-hangzhou)）
+
+
+
+## 二、在线体验
+
+官方Demo地址，自助注册后体验    
+
+https://certd.handsfree.work/
+
+> 注意数据将不定期清理，生产使用请自行部署    
+> 包含敏感信息，务必自己本地部署进行生产使用
+
+## 三、使用教程
+本案例演示，如何配置自动申请证书，并部署到阿里云CDN，然后快要到期前自动更新证书并重新部署     
+
+![演示](./doc/images/5-view.png)
+![演示](./doc/images/9-start.png)
+![演示](./doc/images/10-1-log.png)
+![演示](./doc/images/13-3-download.png)
+![演示](./doc/images/13-1-result.png)
+
+↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓      
+-------> [点我查看详细使用步骤演示](./step.md)   <--------      
+↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑     
+
+## 四、本地docker部署
+
+### 1. 安装docker、docker-compose
+
+1.1 安装docker    
+https://docs.docker.com/engine/install/
+
+1.2 安装docker-compose     
+https://docs.docker.com/compose/install/linux/
+
+### 2. 下载docker-compose.yaml文件
+```bash
+mkdir certd
+cd certd
+wget https://raw.githubusercontent.com/certd/certd/v2/docker/run/docker-compose.yaml
+# 或者使用gitee地址
+wget https://gitee.com/certd/certd/raw/v2/docker/run/docker-compose.yaml
+
+# 根据需要修改里面的配置
+# 1.修改镜像版本号
+# 2.配置数据保存路径
+# 3.配置certd_auth_jwt_secret
+vi docker-compose.yaml
+
+
+```
+> 镜像版本号与release版本号同步：    
+https://github.com/certd/certd/releases
+
+
+### 3. 运行
+```bash
+# 如果docker compose是插件化安装
+export CERTD_VERSION=1.20.9
+docker compose up -d
+
+#如果docker compose是独立安装
+export CERTD_VERSION=1.20.9
+docker-compose up -d
+
+```
+### 4. 访问
+
+http://your_server_ip:7001 
+默认账号密码：admin/123456 
+记得修改密码
+
+
+### 5. 升级
+
+* 修改版本号，重新运行 `docker compose up -d` 即可
+* 数据存在`/data/certd`目录下，不用担心数据丢失
+
+
+## 五、一些说明
 
-## 免费证书申请说明
 * 本项目ssl证书提供商为letencrypt
 * 申请过程遵循acme协议
-* 需要验证域名所有权，一般有两种方式（目前本项目仅支持dns-01）      
-  * http-01： 在网站根目录下放置一份txt文件     
-  * dns-01： 需要给域名添加txt解析记录，泛域名只能用这种方式   
+* 需要验证域名所有权，一般有两种方式（目前本项目仅支持dns-01）
+  * http-01： 在网站根目录下放置一份txt文件
+  * dns-01： 需要给域名添加txt解析记录，通配符域名只能用这种方式
 * 证书续期：
   * 实际上acme并没有续期概念。
   * 我们所说的续期，其实就是按照全套流程重新申请一份新证书。
 * 免费证书过期时间90天，以后可能还会缩短，所以自动化部署必不可少
+* 设置每天自动运行，当证书过期前20天，会自动重新申请证书并部署
+
+## 六、联系作者
+如有疑问，欢迎加入群聊（请备注certd）
+* QQ群：141236433
+* 微信群：   
+  ![](https://ai.handsfree.work/images/exchange_wxqroup.png)
 
 
+加作者好友
+<p align="center">
+<img height="230" src="./doc/images/me.png">
+</p>
 
-## 快速开始
-本案例演示，如何配置自动申请证书，并部署到阿里云CDN，然后快要到期前自动更新证书并重新部署    
+## 捐赠
+媳妇儿说：“一天到晚搞开源，也不管管老婆孩子！😡😡😡”        
+拜托各位捐赠支持一下，让媳妇儿开心开心，我也能有更多时间进行开源项目，感谢🙏🙏🙏
+<p align="center">
+<img height="380" src="./doc/images/donate.png">
+</p>
 
 
-1. 环境准备   
-安装[nodejs](https://nodejs.org/zh-cn/)
+## 七、贡献代码
+
+[贡献插件教程](./plugin.md)
 
 
-2. 生成node项目
-
-  通过ui生成： https://certd.docmirror.cn/
-  
-开始生成证书，先填写域名，支持将多个域名打到一个证书上
-![](./doc/step1.png)
-
-配置证书详细信息
-![](./doc/step2.png)
-
-配置证书部署流程
-![](./doc/step3.png)
-
-配置好之后，点击导出按钮，导出一个node项目包
-
-4. 运行    
-将导出的压缩包解压，然后执行如下命令，即可开始申请证书并部署
-```
-npm install
-npm run certd
-```
-5. 执行效果
-生成的证书默认会存储在 `${home}/.certd/${email}/certs/${domain}/current`目录下 
-```
-[2021-01-08T16:15:04.681] [INFO] certd - 任务完成
-[2021-01-08T16:15:04.681] [INFO] certd - ---------------------------任务结果总览--------------------------
-[2021-01-08T16:15:04.682] [INFO] certd - 【更新证书】---------------------------------------	[success] 
-  证书申请成功
-[2021-01-08T16:15:04.682] [INFO] certd - 【流程1-部署到阿里云CDN】----------------------------	[success]  	执行成功
-[2021-01-08T16:15:04.682] [INFO] certd -    └【上传到阿里云】--------------------------------	[success]  	执行成功
-[2021-01-08T16:15:04.682] [INFO] certd -    └【部署证书到CDN】-------------------------------	[success]  	执行成功
-```
-6. 证书续期    
-实际上没有证书续期的概念，只有重新生成一份新的证书，然后重新部署证书    
-所以每天定时运行即可，当证书过期日前20天时，会重新申请新的证书，然后执行部署任务。     
-
-7. 其他说明    
-证书的部署任务执行后会记录执行结果，已经成功过的不会重复执行     
-所以当你临时需要将证书部署到其他地方时，直接追加部署任务，然后再次运行即可
-
-## CI/DI集成与自动续期重新部署
-集成前，将以上导出的node项目提交到内网git仓库，或者私有git仓库（由于包含敏感信息，不要提交到公开git仓库）
-
-### jenkins任务
-1. 创建任务     
-选择构建自由风格的任务     
-
-2. 配置git    
-配置cert-run的git地址     
-
-3. 构建触发器    
-配置 `H 3 * * *` ，每天凌晨3点-4点执行一次
-
-4. 构建环境    
-勾选 `Provide Node & npm bin/ folder to PATH`，提供nodejs运行环境     
-如果没有此选项，需要jenkins安装`nodejs`插件
-
-5. 构建    
-执行shell
-```
-npm install --production   #执行过一次之后，就可以注释掉，加快执行速度
-npm run post
-```
-6. 构建后操作     
-邮件通知   
-配置你的邮箱地址，可以在执行失败时收到邮件通知。
-
-
-## API
-先列个提纲，待完善
-
-参数示例参考：https://gitee.com/certd/certd/blob/master/test/options.js
-
-### 授权提供者
-用于dns验证接口调用
-#### aliyun
-
-#### dnspod
-
-### deploy插件
-部署任务插件
-#### 阿里云
-##### 上传到阿里云
-type = uploadCertToAliyun
-##### 部署到阿里云DNS
-type = deployCertToAliyunCDN
-
-##### 部署到阿里云CLB
-type = deployCertToAliyunCLB
-
-#### 腾讯云
-##### 上传到腾讯云
-type = uploadCertToTencent
-
-##### 部署到腾讯云DNS
-type = deployCertToTencentDNS
-
-##### 部署到腾讯云CLB
-type = deployCertToTencentCLB
-
-##### 部署到腾讯云TKE-ingress
-type = deployCertToTencentTKEIngress
-
-
-### 更多部署插件
-等你来提需求
+## 八、我的其他项目
+* [袖手GPT](https://ai.handsfree.work/) ChatGPT，国内可用，无需FQ，每日免费额度
+* [fast-crud](https://gitee.com/fast-crud/fast-crud/) 基于vue3的crud快速开发框架
+* [dev-sidecar](https://github.com/docmirror/dev-sidecar/) 直连访问github工具，无需FQ，解决github无法访问的问题

deploy.js

@@ -0,0 +1,106 @@
+import http from 'axios'
+import fs from 'fs'
+
+//读取 packages/core/pipline/package.json的版本号
+import {default as packageJson} from './packages/core/pipeline/package.json' assert { type: "json" };
+
+const certdVersion = packageJson.version
+console.log("certdVersion", certdVersion)
+
+// 同步npmmirror的包
+async function getPackages(directoryPath) {
+    return new Promise((resolve, reject) => {
+        // 读取目录下的文件和目录列表
+        fs.readdir(directoryPath, {withFileTypes: true}, (err, files) => {
+            if (err) {
+                console.log('无法读取目录:', err);
+                reject(err)
+                return;
+            }
+
+            // 过滤仅保留目录
+            const directories = files
+                .filter(file => file.isDirectory())
+                .map(directory => directory.name);
+
+            console.log('目录列表:', directories);
+            resolve(directories)
+        });
+    })
+
+}
+
+async function getAllPackages() {
+    const base = await getPackages("./packages/core")
+    const plugins = await getPackages("./packages/plugins")
+
+    return base.concat(plugins)
+}
+
+async function sync() {
+    const packages = await getAllPackages()
+    for (const pkg of packages) {
+        await http({
+            url: `http://registry-direct.npmmirror.com/@certd/${pkg}/sync?sync_upstream=true`,
+            method: 'PUT',
+            headers: {
+                "Content-Type": "application/json"
+            },
+            data: {}
+        })
+        console.log(`sync success:${pkg}`)
+        await sleep(100*1000)
+    }
+}
+
+// curl -X PUT https://registry-direct.npmmirror.com/@certd/plugin-cert/sync?sync_upstream=true
+
+const certdImageBuild = "http://flow-openapi.aliyun.com/pipeline/webhook/4zgFk3i4RZEMGuQzlOcI"
+const certdImageRun = "http://flow-openapi.aliyun.com/pipeline/webhook/lzCzlGrLCOHQaTMMt0mG"
+const webhooks = [certdImageBuild,certdImageRun]
+
+async function sleep(time) {
+    return new Promise(resolve => {
+        setTimeout(resolve, time)
+    })
+}
+
+async function triggerBuild() {
+    await sleep(60000)
+    for (const webhook of webhooks) {
+        await http({
+            url: webhook,
+            method: 'POST',
+            headers: {
+                "Content-Type": "application/json"
+            },
+            data: {
+                'CERTD_VERSION': certdVersion
+            }
+        })
+        console.log(`webhook success:${webhook}`)
+        await sleep(10*60*1000)
+    }
+
+}
+
+async function start() {
+    // await build()
+    console.log("等待60秒")
+    await sleep(200 * 1000)
+    await sync()
+    await sleep(60 * 1000)
+    await triggerBuild()
+}
+
+start()
+
+
+/**
+ * 打包前 修改 lerna
+ * nodemodules里面搜索如下
+ * return childProcess.exec("git", ["add", "--", ...files], execOpts);
+ *
+ * ('git', ['add', '--', ...files]
+ * ('git', ['add', '.']
+ */

docker/image/Dockerfile

@@ -0,0 +1,18 @@
+FROM registry.cn-shenzhen.aliyuncs.com/handsfree/node:16-alpine
+EXPOSE 7001
+ENV NODE_ENV production
+ENV MIDWAY_SERVER_ENV production
+WORKDIR /app/
+#RUN npm install cross-env -g  --registry=https://registry.npmmirror.com
+#RUN npm install pm2 -g  --registry=https://registry.npmmirror.com
+#RUN pm2 install pm2-logrotate
+ADD ./workspace/certd-server/ /app/
+RUN yarn install --production  --registry=https://registry.npmmirror.com
+#RUN yarn install --production
+RUN npm run build
+#CMD ["pm2-runtime", "start", "./bootstrap.js","--name", "certd","-i","1"]
+CMD ["npm", "run","start"]
+
+
+
+

docker/image/build.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+set -e
+echo "请先输入一个版本号："
+read version
+
+echo "您输入的版本号是： $version"
+echo "登录aliyun镜像仓库"
+sudo docker login --username=252959493@qq.com registry.cn-shenzhen.aliyuncs.com
+
+build=$(pwd)
+cd ../../
+root=$(pwd)
+echo "安装依赖"
+#pnpm install --registry=https://registry.npmmirror.com
+pnpm install
+
+echo "client build"
+cd $root/packages/ui/certd-client
+pnpm run build
+echo "client build success"
+
+echo "server build"
+cd $root/packages/ui/certd-server
+pnpm run build
+echo "server build success"
+
+echo "rm node_modules"
+rm ./node_modules -rf
+
+echo "copy to workspace"
+mkdir -p $build/workspace/certd-server
+\cp ./* $build/workspace/certd-server -rf
+\cp ../certd-client/dist/* $build/workspace/certd-server/public/ -rf
+
+#export TAG=$version
+#sudo -E docker compose build
+#sudo -E docker compose push

docker/image/docker-compose.yaml

@@ -0,0 +1,15 @@
+version: '3.3' # 指定docker-compose 版本
+services: # 要拉起的服务们
+  certd:
+    build:
+      context: ./
+      dockerfile: Dockerfile
+    image: registry.cn-shenzhen.aliyuncs.com/handsfree/certd:${TAG}
+    container_name: certd # 容器名
+    restart: unless-stopped # 重启
+    ports: # 端口映射
+      - "7001:7001"
+    environment:
+      - TZ=Asia/Shanghai
+      - node_sqlite3_binary_host_mirror=https://registry.npmmirror.com/-/binary/sqlite3
+

docker/run/Dockerfile

@@ -0,0 +1,9 @@
+FROM registry.cn-shenzhen.aliyuncs.com/handsfree/certd:latest
+EXPOSE 7001
+RUN npm run build
+#RUN npm install pm2 -g  --registry=https://registry.npmmirror.com
+#CMD ["pm2-runtime", "start", "./bootstrap.js","--name", "certd","-i","1","--", "-p", "7001"]
+CMD ["npm","run", "start"]
+
+
+

docker/run/build.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+# 判断$CERTD_VERSION 是否存在
+if [ -n "$CERTD_VERSION" ]; then
+    echo "CERTD_VERSION is set = $CERTD_VERSION"
+else
+    echo "CERTD_VERSION is not set"
+    echo "请先输入一个版本号(如 1.0.6)："
+    read CERTD_VERSION
+fi
+
+echo "您输入的版本号是： $CERTD_VERSION"
+sudo -E docker compose up -d

docker/run/docker-compose.yaml

@@ -0,0 +1,23 @@
+version: '3.3'
+services:
+  certd:
+    # 镜像                                                  #  ↓↓↓↓↓ --- 1、 修改镜像版本号，或者干脆写成latest
+    image: registry.cn-shenzhen.aliyuncs.com/handsfree/certd:${CERTD_VERSION}
+    container_name: certd # 容器名
+    restart: unless-stopped # 重启
+    volumes:
+      #   ↓↓↓↓↓ ------------------------------------------------------- 2、 修改数据库以及证书存储路径
+      - /data/certd:/app/data
+    ports: # 端口映射
+      - "7001:7001"
+    environment: # 环境变量
+      - TZ=Asia/Shanghai
+      - certd_auth_jwt_secret=changeme
+                            #  ↑↑↑↑↑ ---------------------------------- 3、 修改成你的自定义密钥
+      # 设置环境变量即可自定义certd配置
+      # 服务端配置项见： packages/ui/certd-server/src/config/config.default.ts
+      # 服务端配置规则： certd_ + 配置项, 点号用_代替
+      # 如jwt密钥配置为： auth.jwt.secret，则设置环境变量 certd_auth_jwt_secret=changeme
+
+      # 客户端配置项见： packages/ui/certd-client/.env
+      # 按实际名称配置环境变量即可，如： VITE_APP_API=http://localhost:7001

lerna.json

@@ -1,6 +1,13 @@
 {
-  "packages": [
-    "packages/*/*"
-  ],
-  "version": "0.2.0"
+  "$schema": "node_modules/lerna/schemas/lerna-schema.json",
+  "useWorkspaces": true,
+  "command": {
+    "bootstrap": {
+      "npmClientArgs": [
+        "--no-package-lock"
+      ]
+    }
+  },
+  "npmClient": "pnpm",
+  "version": "1.20.10"
 }

package.json

@@ -1,16 +1,29 @@
 {
   "name": "root",
+  "version": "1.20.4",
   "private": true,
   "type": "module",
   "devDependencies": {
-    "lerna": "^3.18.4"
+    "@lerna-lite/cli": "^3.2.1",
+    "@lerna-lite/publish": "^3.2.1",
+    "@lerna-lite/run": "^3.2.1",
+    "@lerna-lite/version": "^3.2.1"
   },
   "scripts": {
     "start": "lerna bootstrap --hoist",
-    "i-all": "lerna link && lerna exec npm install  "
+    "i-all": "lerna link && lerna exec npm install  ",
+    "publish": "npm run prepublishOnly1  && lerna publish --conventional-commits && npm run afterpublishOnly && npm run deploy1",
+    "afterpublishOnly": "",
+    "prepublishOnly1": "npm run before-build && lerna run build ",
+    "before-build": "cd ./packages/core/acme-client && time /t >build.md && git add ./build.md && git commit -m \"build: prepare to build\"",
+    "deploy1": "node --experimental-json-modules deploy.js "
   },
-  "license": "MIT",
+  "license": "AGPL-3.0",
   "dependencies": {
-    "lodash-es": "^4.17.20"
-  }
+    "axios": "^1.4.0",
+    "lodash": "^4.17.21"
+  },
+  "workspaces": [
+    "packages/**"
+  ]
 }

packages/core/acme-client/.editorconfig

@@ -0,0 +1,13 @@
+#
+# http://editorconfig.org
+#
+
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+
+[{*.yml,*.yaml}]
+indent_size = 2

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

packages/core/acme-client/.github/scripts/tests-install-coredns.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+#
+# Install CoreDNS for testing.
+#
+set -euo pipefail
+
+# 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
+    bind 127.53.53.53
+    file /etc/coredns/db.example.com
+}
+
+test.example.com {
+    errors
+    log
+    bind 127.53.53.53
+    forward . 127.0.0.1:${PEBBLECTS_DNS_PORT}
+}
+
+. {
+    errors
+    log
+    bind 127.53.53.53
+    forward . 8.8.8.8
+}
+EOF
+
+exit 0

packages/core/acme-client/.github/scripts/tests-install-cts.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+#
+# Install Pebble Challenge Test Server for testing.
+#
+set -euo pipefail
+
+# 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

packages/core/acme-client/.github/scripts/tests-install-pebble.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+#
+# Install Pebble for testing.
+#
+set -euo pipefail
+
+CONFIG_NAME="pebble-config.json"
+
+# Use Pebble EAB config if enabled
+set +u
+if [[ -n $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

packages/core/acme-client/.github/scripts/tests-wait-for-ca.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+#
+# Wait for ACME server to accept connections.
+#
+set -euo pipefail
+
+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

packages/core/acme-client/.github/workflows/tests.yml

@@ -0,0 +1,94 @@
+---
+name: test
+on: [push, pull_request]
+
+jobs:
+  test:
+    name: node=${{matrix.node}} eab=${{matrix.eab}}
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node: [16, 18, 20, 22]
+        eab: [0, 1]
+
+
+    #
+    # Environment
+    #
+
+    env:
+      FORCE_COLOR: 1
+      NPM_CONFIG_COLOR: always
+
+      PEBBLE_VERSION: 2.3.1
+      PEBBLE_ALTERNATE_ROOTS: 2
+      PEBBLECTS_VERSION: 2.3.1
+      PEBBLECTS_DNS_PORT: 8053
+      COREDNS_VERSION: 1.11.1
+
+      NODE_EXTRA_CA_CERTS: /etc/pebble/ca.cert.pem
+      ACME_CA_CERT_PATH: /etc/pebble/ca.cert.pem
+
+      ACME_DIRECTORY_URL: https://127.0.0.1:14000/dir
+      ACME_CHALLTESTSRV_URL: http://127.0.0.1:8055
+      ACME_PEBBLE_MANAGEMENT_URL: https://127.0.0.1:15000
+
+      ACME_DOMAIN_NAME: test.example.com
+      ACME_CAP_EAB_ENABLED: ${{matrix.eab}}
+
+      ACME_TLSALPN_PORT: 5001
+      ACME_HTTP_PORT: 5002
+      ACME_HTTPS_PORT: 5003
+
+
+    #
+    # Pipeline
+    #
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{matrix.node}}
+
+      # Pebble Challenge Test Server
+      - name: Install Pebble Challenge Test Server
+        run: sudo -E /bin/bash ./.github/scripts/tests-install-cts.sh
+
+      - name: Start Pebble Challenge Test Server
+        run: |-
+          nohup bash -c "pebble-challtestsrv \
+            -dns01 :${PEBBLECTS_DNS_PORT} \
+            -tlsalpn01 :${ACME_TLSALPN_PORT} \
+            -http01 :${ACME_HTTP_PORT} \
+            -https01 :${ACME_HTTPS_PORT} \
+            -defaultIPv4 127.0.0.1 \
+            -defaultIPv6 \"\" &"
+
+      # Pebble
+      - name: Install Pebble
+        run: sudo -E /bin/bash ./.github/scripts/tests-install-pebble.sh
+
+      - name: Start Pebble
+        run: nohup bash -c "pebble -strict -config /etc/pebble/pebble.json -dnsserver 127.53.53.53:53 &"
+
+      - name: Wait for Pebble
+        run: /bin/bash ./.github/scripts/tests-wait-for-ca.sh
+
+      # CoreDNS
+      - name: Install CoreDNS
+        run: sudo -E /bin/bash ./.github/scripts/tests-install-coredns.sh
+
+      - name: Start CoreDNS
+        run: nohup bash -c "sudo coredns -p 53 -conf /etc/coredns/Corefile &"
+
+      - name: Use CoreDNS for DNS resolution
+        run: echo "nameserver 127.53.53.53" | sudo tee /etc/resolv.conf
+
+      # Run tests
+      - run: npm i
+      - run: npm run lint
+      - run: npm run lint-types
+      - run: npm run build-docs
+      - run: npm run test

packages/core/acme-client/.gitignore

@@ -1,7 +1,6 @@
+.actrc
 .vscode/
 node_modules/
 npm-debug.log
-yarn-error.log
-yarn.lock
 package-lock.json
 /.idea/

packages/core/acme-client/CHANGELOG.md

@@ -0,0 +1,235 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## [1.20.10](https://github.com/publishlab/node-acme-client/compare/v1.20.9...v1.20.10) (2024-05-30)
+
+**Note:** Version bump only for package @certd/acme-client
+
+## [1.20.9](https://github.com/publishlab/node-acme-client/compare/v1.20.8...v1.20.9) (2024-03-22)
+
+**Note:** Version bump only for package @certd/acme-client
+
+## [1.20.8](https://github.com/publishlab/node-acme-client/compare/v1.20.7...v1.20.8) (2024-03-22)
+
+**Note:** Version bump only for package @certd/acme-client
+
+## [1.20.7](https://github.com/publishlab/node-acme-client/compare/v1.20.6...v1.20.7) (2024-03-22)
+
+**Note:** Version bump only for package @certd/acme-client
+
+## [1.20.6](https://github.com/publishlab/node-acme-client/compare/v1.20.5...v1.20.6) (2024-03-21)
+
+**Note:** Version bump only for package @certd/acme-client
+
+## [1.20.5](https://github.com/publishlab/node-acme-client/compare/v1.20.2...v1.20.5) (2024-03-11)
+
+### Bug Fixes
+
+* 修复腾讯云cdn部署无法选择端点的bug ([154409b](https://github.com/publishlab/node-acme-client/commit/154409b1dfee3ea1caae740ad9c1f99a6e7a9814))
+
+# Changelog
+
+## v5.3.1
+
+* `fixed` Allow `client.auto()` being called with an empty CSR common name
+* `fixed` Bug when calling `updateAccountKey()` with external account binding
+
+## v5.3.0 (2024-02-05)
+
+* `added` Support and tests for satisfying `tls-alpn-01` challenges
+* `changed` Replace `jsrsasign` with `@peculiar/x509` for certificate and CSR generation and parsing
+* `changed` Method `getChallengeKeyAuthorization()` now returns `$token.$thumbprint` when called with a `tls-alpn-01` challenge
+    * Previously returned base64url encoded SHA256 digest of `$token.$thumbprint` erroneously
+    * This change is not considered breaking since the previous behavior was incorrect
+
+## v5.2.0 (2024-01-22)
+
+* `fixed` Allow self-signed or invalid certs when validating `http-01` challenges that redirect to HTTPS - [#65](https://github.com/publishlab/node-acme-client/issues/65)
+* `fixed` Wait for all challenge promises to settle before rejecting `client.auto()` - [#75](https://github.com/publishlab/node-acme-client/issues/75)
+
+## v5.1.0 (2024-01-20)
+
+* `fixed` Upgrade `jsrsasign@11.0.0` - [GHSA-rh63-9qcf-83gf](https://github.com/kjur/jsrsasign/security/advisories/GHSA-rh63-9qcf-83gf)
+* `fixed` Upgrade `axios@1.6.5` - [CVE-2023-45857](https://cve.mitre.org/cgi-bin/cvename.cgi?name=2023-45857)
+
+## 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://datatracker.ietf.org/doc/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://datatracker.ietf.org/doc/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://datatracker.ietf.org/doc/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://datatracker.ietf.org/doc/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://datatracker.ietf.org/doc/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://datatracker.ietf.org/doc/html/rfc5280)
+* `fixed` Implement `POST-as-GET` for all ACME API requests - [RFC 8555 Section 6.3](https://datatracker.ietf.org/doc/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://datatracker.ietf.org/doc/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

packages/core/acme-client/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2024 Labrador CMS AS
+
+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.

packages/core/acme-client/README.md

@@ -0,0 +1,239 @@
+# acme-client [![test](https://github.com/publishlab/node-acme-client/actions/workflows/tests.yml/badge.svg)](https://github.com/publishlab/node-acme-client/actions/workflows/tests.yml)
+
+*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://datatracker.ietf.org/doc/html/rfc8555](https://datatracker.ietf.org/doc/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)
+
+## 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 = '<PEM encoded private key>';
+
+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://datatracker.ietf.org/doc/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 [@peculiar/x509](https://www.npmjs.com/package/@peculiar/x509) 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: '<PEM encoded 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)

packages/core/acme-client/build.md

@@ -0,0 +1 @@
+11:37

packages/core/acme-client/docs/client.md

@@ -0,0 +1,518 @@
+## Classes
+
+<dl>
+<dt><a href="#AcmeClient">AcmeClient</a></dt>
+<dd><p>AcmeClient</p>
+</dd>
+</dl>
+
+## Objects
+
+<dl>
+<dt><a href="#Client">Client</a> : <code>object</code></dt>
+<dd><p>ACME client</p>
+</dd>
+</dl>
+
+<a name="AcmeClient"></a>
+
+## AcmeClient
+AcmeClient
+
+**Kind**: global class  
+
+* [AcmeClient](#AcmeClient)
+    * [new AcmeClient(opts)](#new_AcmeClient_new)
+    * [.getTermsOfServiceUrl()](#AcmeClient+getTermsOfServiceUrl) ⇒ <code>Promise.&lt;(string\|null)&gt;</code>
+    * [.getAccountUrl()](#AcmeClient+getAccountUrl) ⇒ <code>string</code>
+    * [.createAccount([data])](#AcmeClient+createAccount) ⇒ <code>Promise.&lt;object&gt;</code>
+    * [.updateAccount([data])](#AcmeClient+updateAccount) ⇒ <code>Promise.&lt;object&gt;</code>
+    * [.updateAccountKey(newAccountKey, [data])](#AcmeClient+updateAccountKey) ⇒ <code>Promise.&lt;object&gt;</code>
+    * [.createOrder(data)](#AcmeClient+createOrder) ⇒ <code>Promise.&lt;object&gt;</code>
+    * [.getOrder(order)](#AcmeClient+getOrder) ⇒ <code>Promise.&lt;object&gt;</code>
+    * [.finalizeOrder(order, csr)](#AcmeClient+finalizeOrder) ⇒ <code>Promise.&lt;object&gt;</code>
+    * [.getAuthorizations(order)](#AcmeClient+getAuthorizations) ⇒ <code>Promise.&lt;Array.&lt;object&gt;&gt;</code>
+    * [.deactivateAuthorization(authz)](#AcmeClient+deactivateAuthorization) ⇒ <code>Promise.&lt;object&gt;</code>
+    * [.getChallengeKeyAuthorization(challenge)](#AcmeClient+getChallengeKeyAuthorization) ⇒ <code>Promise.&lt;string&gt;</code>
+    * [.verifyChallenge(authz, challenge)](#AcmeClient+verifyChallenge) ⇒ <code>Promise</code>
+    * [.completeChallenge(challenge)](#AcmeClient+completeChallenge) ⇒ <code>Promise.&lt;object&gt;</code>
+    * [.waitForValidStatus(item)](#AcmeClient+waitForValidStatus) ⇒ <code>Promise.&lt;object&gt;</code>
+    * [.getCertificate(order, [preferredChain])](#AcmeClient+getCertificate) ⇒ <code>Promise.&lt;string&gt;</code>
+    * [.revokeCertificate(cert, [data])](#AcmeClient+revokeCertificate) ⇒ <code>Promise</code>
+    * [.auto(opts)](#AcmeClient+auto) ⇒ <code>Promise.&lt;string&gt;</code>
+
+<a name="new_AcmeClient_new"></a>
+
+### new AcmeClient(opts)
+
+| Param | Type | Description |
+| --- | --- | --- |
+| opts | <code>object</code> |  |
+| opts.directoryUrl | <code>string</code> | ACME directory URL |
+| opts.accountKey | <code>buffer</code> \| <code>string</code> | PEM encoded account private key |
+| [opts.accountUrl] | <code>string</code> | Account URL, default: `null` |
+| [opts.externalAccountBinding] | <code>object</code> |  |
+| [opts.externalAccountBinding.kid] | <code>string</code> | External account binding KID |
+| [opts.externalAccountBinding.hmacKey] | <code>string</code> | External account binding HMAC key |
+| [opts.backoffAttempts] | <code>number</code> | Maximum number of backoff attempts, default: `10` |
+| [opts.backoffMin] | <code>number</code> | Minimum backoff attempt delay in milliseconds, default: `5000` |
+| [opts.backoffMax] | <code>number</code> | 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'
+    }
+});
+```
+<a name="AcmeClient+getTermsOfServiceUrl"></a>
+
+### acmeClient.getTermsOfServiceUrl() ⇒ <code>Promise.&lt;(string\|null)&gt;</code>
+Get Terms of Service URL if available
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;(string\|null)&gt;</code> - ToS URL  
+**Example**  
+Get Terms of Service URL
+```js
+const termsOfService = client.getTermsOfServiceUrl();
+
+if (!termsOfService) {
+    // CA did not provide Terms of Service
+}
+```
+<a name="AcmeClient+getAccountUrl"></a>
+
+### acmeClient.getAccountUrl() ⇒ <code>string</code>
+Get current account URL
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>string</code> - Account URL  
+**Throws**:
+
+- <code>Error</code> 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
+}
+```
+<a name="AcmeClient+createAccount"></a>
+
+### acmeClient.createAccount([data]) ⇒ <code>Promise.&lt;object&gt;</code>
+Create a new account
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.3
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Account  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| [data] | <code>object</code> | 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']
+});
+```
+<a name="AcmeClient+updateAccount"></a>
+
+### acmeClient.updateAccount([data]) ⇒ <code>Promise.&lt;object&gt;</code>
+Update existing account
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.3.2
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Account  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| [data] | <code>object</code> | Request data |
+
+**Example**  
+Update existing account
+```js
+const account = await client.updateAccount({
+    contact: ['mailto:foo@example.com']
+});
+```
+<a name="AcmeClient+updateAccountKey"></a>
+
+### acmeClient.updateAccountKey(newAccountKey, [data]) ⇒ <code>Promise.&lt;object&gt;</code>
+Update account private key
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.3.5
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Account  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| newAccountKey | <code>buffer</code> \| <code>string</code> | New PEM encoded private key |
+| [data] | <code>object</code> | Additional request data |
+
+**Example**  
+Update account private key
+```js
+const newAccountKey = 'New private key goes here';
+const result = await client.updateAccountKey(newAccountKey);
+```
+<a name="AcmeClient+createOrder"></a>
+
+### acmeClient.createOrder(data) ⇒ <code>Promise.&lt;object&gt;</code>
+Create a new order
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.4
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Order  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| data | <code>object</code> | 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' }
+    ]
+});
+```
+<a name="AcmeClient+getOrder"></a>
+
+### acmeClient.getOrder(order) ⇒ <code>Promise.&lt;object&gt;</code>
+Refresh order object from CA
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.4
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Order  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| order | <code>object</code> | Order object |
+
+**Example**  
+```js
+const order = { ... }; // Previously created order object
+const result = await client.getOrder(order);
+```
+<a name="AcmeClient+finalizeOrder"></a>
+
+### acmeClient.finalizeOrder(order, csr) ⇒ <code>Promise.&lt;object&gt;</code>
+Finalize order
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.4
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Order  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| order | <code>object</code> | Order object |
+| csr | <code>buffer</code> \| <code>string</code> | 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);
+```
+<a name="AcmeClient+getAuthorizations"></a>
+
+### acmeClient.getAuthorizations(order) ⇒ <code>Promise.&lt;Array.&lt;object&gt;&gt;</code>
+Get identifier authorizations from order
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.5
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;Array.&lt;object&gt;&gt;</code> - Authorizations  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| order | <code>object</code> | Order |
+
+**Example**  
+Get identifier authorizations
+```js
+const order = { ... }; // Previously created order object
+const authorizations = await client.getAuthorizations(order);
+
+authorizations.forEach((authz) => {
+    const { challenges } = authz;
+});
+```
+<a name="AcmeClient+deactivateAuthorization"></a>
+
+### acmeClient.deactivateAuthorization(authz) ⇒ <code>Promise.&lt;object&gt;</code>
+Deactivate identifier authorization
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.5.2
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Authorization  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| authz | <code>object</code> | Identifier authorization |
+
+**Example**  
+Deactivate identifier authorization
+```js
+const authz = { ... }; // Identifier authorization resolved from previously created order
+const result = await client.deactivateAuthorization(authz);
+```
+<a name="AcmeClient+getChallengeKeyAuthorization"></a>
+
+### acmeClient.getChallengeKeyAuthorization(challenge) ⇒ <code>Promise.&lt;string&gt;</code>
+Get key authorization for ACME challenge
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-8.1
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;string&gt;</code> - Key authorization  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| challenge | <code>object</code> | 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
+```
+<a name="AcmeClient+verifyChallenge"></a>
+
+### acmeClient.verifyChallenge(authz, challenge) ⇒ <code>Promise</code>
+Verify that ACME challenge is satisfied
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| authz | <code>object</code> | Identifier authorization |
+| challenge | <code>object</code> | Authorization challenge |
+
+**Example**  
+Verify satisfied ACME challenge
+```js
+const authz = { ... }; // Identifier authorization
+const challenge = { ... }; // Satisfied challenge
+await client.verifyChallenge(authz, challenge);
+```
+<a name="AcmeClient+completeChallenge"></a>
+
+### acmeClient.completeChallenge(challenge) ⇒ <code>Promise.&lt;object&gt;</code>
+Notify CA that challenge has been completed
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.5.1
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Challenge  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| challenge | <code>object</code> | Challenge object returned by API |
+
+**Example**  
+Notify CA that challenge has been completed
+```js
+const challenge = { ... }; // Satisfied challenge
+const result = await client.completeChallenge(challenge);
+```
+<a name="AcmeClient+waitForValidStatus"></a>
+
+### acmeClient.waitForValidStatus(item) ⇒ <code>Promise.&lt;object&gt;</code>
+Wait for ACME provider to verify status on a order, authorization or challenge
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.5.1
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Valid order, authorization or challenge  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| item | <code>object</code> | An order, authorization or challenge object |
+
+**Example**  
+Wait for valid challenge status
+```js
+const challenge = { ... };
+await client.waitForValidStatus(challenge);
+```
+**Example**  
+Wait for valid authorization status
+```js
+const authz = { ... };
+await client.waitForValidStatus(authz);
+```
+**Example**  
+Wait for valid order status
+```js
+const order = { ... };
+await client.waitForValidStatus(order);
+```
+<a name="AcmeClient+getCertificate"></a>
+
+### acmeClient.getCertificate(order, [preferredChain]) ⇒ <code>Promise.&lt;string&gt;</code>
+Get certificate from ACME order
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.4.2
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;string&gt;</code> - Certificate  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| order | <code>object</code> |  | Order object |
+| [preferredChain] | <code>string</code> | <code>null</code> | 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');
+```
+<a name="AcmeClient+revokeCertificate"></a>
+
+### acmeClient.revokeCertificate(cert, [data]) ⇒ <code>Promise</code>
+Revoke certificate
+
+https://datatracker.ietf.org/doc/html/rfc8555#section-7.6
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| cert | <code>buffer</code> \| <code>string</code> | PEM encoded certificate |
+| [data] | <code>object</code> | 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
+});
+```
+<a name="AcmeClient+auto"></a>
+
+### acmeClient.auto(opts) ⇒ <code>Promise.&lt;string&gt;</code>
+Auto mode
+
+**Kind**: instance method of [<code>AcmeClient</code>](#AcmeClient)  
+**Returns**: <code>Promise.&lt;string&gt;</code> - Certificate  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| opts | <code>object</code> |  |
+| opts.csr | <code>buffer</code> \| <code>string</code> | Certificate Signing Request |
+| opts.challengeCreateFn | <code>function</code> | Function returning Promise triggered before completing ACME challenge |
+| opts.challengeRemoveFn | <code>function</code> | Function returning Promise triggered after completing ACME challenge |
+| [opts.email] | <code>string</code> | Account email address |
+| [opts.termsOfServiceAgreed] | <code>boolean</code> | Agree to Terms of Service, default: `false` |
+| [opts.skipChallengeVerification] | <code>boolean</code> | Skip internal challenge verification before notifying ACME provider, default: `false` |
+| [opts.challengePriority] | <code>Array.&lt;string&gt;</code> | Array defining challenge type priority, default: `['http-01', 'dns-01']` |
+| [opts.preferredChain] | <code>string</code> | 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 () => {}
+});
+```
+<a name="Client"></a>
+
+## Client : <code>object</code>
+ACME client
+
+**Kind**: global namespace  

packages/core/acme-client/docs/crypto.md

@@ -0,0 +1,313 @@
+## Objects
+
+<dl>
+<dt><a href="#crypto">crypto</a> : <code>object</code></dt>
+<dd><p>Native Node.js crypto interface</p>
+</dd>
+</dl>
+
+## Functions
+
+<dl>
+<dt><a href="#createPrivateRsaKey">createPrivateRsaKey([modulusLength])</a> ⇒ <code>Promise.&lt;buffer&gt;</code></dt>
+<dd><p>Generate a private RSA key</p>
+</dd>
+<dt><a href="#createPrivateKey">createPrivateKey()</a></dt>
+<dd><p>Alias of <code>createPrivateRsaKey()</code></p>
+</dd>
+<dt><a href="#createPrivateEcdsaKey">createPrivateEcdsaKey([namedCurve])</a> ⇒ <code>Promise.&lt;buffer&gt;</code></dt>
+<dd><p>Generate a private ECDSA key</p>
+</dd>
+<dt><a href="#getPublicKey">getPublicKey(keyPem)</a> ⇒ <code>buffer</code></dt>
+<dd><p>Get a public key derived from a RSA or ECDSA key</p>
+</dd>
+<dt><a href="#getJwk">getJwk(keyPem)</a> ⇒ <code>object</code></dt>
+<dd><p>Get a JSON Web Key derived from a RSA or ECDSA key</p>
+<p><a href="https://datatracker.ietf.org/doc/html/rfc7517">https://datatracker.ietf.org/doc/html/rfc7517</a></p>
+</dd>
+<dt><a href="#splitPemChain">splitPemChain(chainPem)</a> ⇒ <code>Array.&lt;string&gt;</code></dt>
+<dd><p>Split chain of PEM encoded objects from string into array</p>
+</dd>
+<dt><a href="#getPemBodyAsB64u">getPemBodyAsB64u(pem)</a> ⇒ <code>string</code></dt>
+<dd><p>Parse body of PEM encoded object and return a Base64URL string
+If multiple objects are chained, the first body will be returned</p>
+</dd>
+<dt><a href="#readCsrDomains">readCsrDomains(csrPem)</a> ⇒ <code>object</code></dt>
+<dd><p>Read domains from a Certificate Signing Request</p>
+</dd>
+<dt><a href="#readCertificateInfo">readCertificateInfo(certPem)</a> ⇒ <code>object</code></dt>
+<dd><p>Read information from a certificate
+If multiple certificates are chained, the first will be read</p>
+</dd>
+<dt><a href="#createCsr">createCsr(data, [keyPem])</a> ⇒ <code>Promise.&lt;Array.&lt;buffer&gt;&gt;</code></dt>
+<dd><p>Create a Certificate Signing Request</p>
+</dd>
+<dt><a href="#createAlpnCertificate">createAlpnCertificate(authz, keyAuthorization, [keyPem])</a> ⇒ <code>Promise.&lt;Array.&lt;buffer&gt;&gt;</code></dt>
+<dd><p>Create a self-signed ALPN certificate for TLS-ALPN-01 challenges</p>
+<p><a href="https://datatracker.ietf.org/doc/html/rfc8737">https://datatracker.ietf.org/doc/html/rfc8737</a></p>
+</dd>
+<dt><a href="#isAlpnCertificateAuthorizationValid">isAlpnCertificateAuthorizationValid(certPem, keyAuthorization)</a> ⇒ <code>boolean</code></dt>
+<dd><p>Validate that a ALPN certificate contains the expected key authorization</p>
+</dd>
+</dl>
+
+<a name="crypto"></a>
+
+## crypto : <code>object</code>
+Native Node.js crypto interface
+
+**Kind**: global namespace  
+<a name="createPrivateRsaKey"></a>
+
+## createPrivateRsaKey([modulusLength]) ⇒ <code>Promise.&lt;buffer&gt;</code>
+Generate a private RSA key
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;buffer&gt;</code> - PEM encoded private RSA key  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [modulusLength] | <code>number</code> | <code>2048</code> | 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);
+```
+<a name="createPrivateKey"></a>
+
+## createPrivateKey()
+Alias of `createPrivateRsaKey()`
+
+**Kind**: global function  
+<a name="createPrivateEcdsaKey"></a>
+
+## createPrivateEcdsaKey([namedCurve]) ⇒ <code>Promise.&lt;buffer&gt;</code>
+Generate a private ECDSA key
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;buffer&gt;</code> - PEM encoded private ECDSA key  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| [namedCurve] | <code>string</code> | 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');
+```
+<a name="getPublicKey"></a>
+
+## getPublicKey(keyPem) ⇒ <code>buffer</code>
+Get a public key derived from a RSA or ECDSA key
+
+**Kind**: global function  
+**Returns**: <code>buffer</code> - PEM encoded public key  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| keyPem | <code>buffer</code> \| <code>string</code> | PEM encoded private or public key |
+
+**Example**  
+Get public key
+```js
+const publicKey = acme.crypto.getPublicKey(privateKey);
+```
+<a name="getJwk"></a>
+
+## getJwk(keyPem) ⇒ <code>object</code>
+Get a JSON Web Key derived from a RSA or ECDSA key
+
+https://datatracker.ietf.org/doc/html/rfc7517
+
+**Kind**: global function  
+**Returns**: <code>object</code> - JSON Web Key  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| keyPem | <code>buffer</code> \| <code>string</code> | PEM encoded private or public key |
+
+**Example**  
+Get JWK
+```js
+const jwk = acme.crypto.getJwk(privateKey);
+```
+<a name="splitPemChain"></a>
+
+## splitPemChain(chainPem) ⇒ <code>Array.&lt;string&gt;</code>
+Split chain of PEM encoded objects from string into array
+
+**Kind**: global function  
+**Returns**: <code>Array.&lt;string&gt;</code> - Array of PEM objects including headers  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| chainPem | <code>buffer</code> \| <code>string</code> | PEM encoded object chain |
+
+<a name="getPemBodyAsB64u"></a>
+
+## getPemBodyAsB64u(pem) ⇒ <code>string</code>
+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**: <code>string</code> - Base64URL-encoded body  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| pem | <code>buffer</code> \| <code>string</code> | PEM encoded chain or object |
+
+<a name="readCsrDomains"></a>
+
+## readCsrDomains(csrPem) ⇒ <code>object</code>
+Read domains from a Certificate Signing Request
+
+**Kind**: global function  
+**Returns**: <code>object</code> - {commonName, altNames}  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| csrPem | <code>buffer</code> \| <code>string</code> | 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(', ')}`);
+```
+<a name="readCertificateInfo"></a>
+
+## readCertificateInfo(certPem) ⇒ <code>object</code>
+Read information from a certificate
+If multiple certificates are chained, the first will be read
+
+**Kind**: global function  
+**Returns**: <code>object</code> - Certificate info  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| certPem | <code>buffer</code> \| <code>string</code> | 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(', ')}`);
+```
+<a name="createCsr"></a>
+
+## createCsr(data, [keyPem]) ⇒ <code>Promise.&lt;Array.&lt;buffer&gt;&gt;</code>
+Create a Certificate Signing Request
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;Array.&lt;buffer&gt;&gt;</code> - [privateKey, certificateSigningRequest]  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| data | <code>object</code> |  |
+| [data.keySize] | <code>number</code> | Size of newly created RSA private key modulus in bits, default: `2048` |
+| [data.commonName] | <code>string</code> | FQDN of your server |
+| [data.altNames] | <code>Array.&lt;string&gt;</code> | SAN (Subject Alternative Names), default: `[]` |
+| [data.country] | <code>string</code> | 2 letter country code |
+| [data.state] | <code>string</code> | State or province |
+| [data.locality] | <code>string</code> | City |
+| [data.organization] | <code>string</code> | Organization name |
+| [data.organizationUnit] | <code>string</code> | Organizational unit name |
+| [data.emailAddress] | <code>string</code> | Email address |
+| [keyPem] | <code>buffer</code> \| <code>string</code> | 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);
+<a name="createAlpnCertificate"></a>
+
+## createAlpnCertificate(authz, keyAuthorization, [keyPem]) ⇒ <code>Promise.&lt;Array.&lt;buffer&gt;&gt;</code>
+Create a self-signed ALPN certificate for TLS-ALPN-01 challenges
+
+https://datatracker.ietf.org/doc/html/rfc8737
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;Array.&lt;buffer&gt;&gt;</code> - [privateKey, certificate]  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| authz | <code>object</code> | Identifier authorization |
+| keyAuthorization | <code>string</code> | Challenge key authorization |
+| [keyPem] | <code>buffer</code> \| <code>string</code> | 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);
+<a name="isAlpnCertificateAuthorizationValid"></a>
+
+## isAlpnCertificateAuthorizationValid(certPem, keyAuthorization) ⇒ <code>boolean</code>
+Validate that a ALPN certificate contains the expected key authorization
+
+**Kind**: global function  
+**Returns**: <code>boolean</code> - True when valid  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| certPem | <code>buffer</code> \| <code>string</code> | PEM encoded certificate |
+| keyAuthorization | <code>string</code> | Expected challenge key authorization |
+

packages/core/acme-client/docs/forge.md

@@ -0,0 +1,257 @@
+## Objects
+
+<dl>
+<dt><a href="#forge">forge</a> : <code>object</code></dt>
+<dd><p>Legacy node-forge crypto interface</p>
+<p>DEPRECATION WARNING: This crypto interface is deprecated and will be removed from acme-client in a future
+major release. Please migrate to the new <code>acme.crypto</code> interface at your earliest convenience.</p>
+</dd>
+</dl>
+
+## Functions
+
+<dl>
+<dt><a href="#createPrivateKey">createPrivateKey([size])</a> ⇒ <code>Promise.&lt;buffer&gt;</code></dt>
+<dd><p>Generate a private RSA key</p>
+</dd>
+<dt><a href="#createPublicKey">createPublicKey(key)</a> ⇒ <code>Promise.&lt;buffer&gt;</code></dt>
+<dd><p>Create public key from a private RSA key</p>
+</dd>
+<dt><a href="#getPemBody">getPemBody(str)</a> ⇒ <code>string</code></dt>
+<dd><p>Parse body of PEM encoded object from buffer or string
+If multiple objects are chained, the first body will be returned</p>
+</dd>
+<dt><a href="#splitPemChain">splitPemChain(str)</a> ⇒ <code>Array.&lt;string&gt;</code></dt>
+<dd><p>Split chain of PEM encoded objects from buffer or string into array</p>
+</dd>
+<dt><a href="#getModulus">getModulus(input)</a> ⇒ <code>Promise.&lt;buffer&gt;</code></dt>
+<dd><p>Get modulus</p>
+</dd>
+<dt><a href="#getPublicExponent">getPublicExponent(input)</a> ⇒ <code>Promise.&lt;buffer&gt;</code></dt>
+<dd><p>Get public exponent</p>
+</dd>
+<dt><a href="#readCsrDomains">readCsrDomains(csr)</a> ⇒ <code>Promise.&lt;object&gt;</code></dt>
+<dd><p>Read domains from a Certificate Signing Request</p>
+</dd>
+<dt><a href="#readCertificateInfo">readCertificateInfo(cert)</a> ⇒ <code>Promise.&lt;object&gt;</code></dt>
+<dd><p>Read information from a certificate</p>
+</dd>
+<dt><a href="#createCsr">createCsr(data, [key])</a> ⇒ <code>Promise.&lt;Array.&lt;buffer&gt;&gt;</code></dt>
+<dd><p>Create a Certificate Signing Request</p>
+</dd>
+</dl>
+
+<a name="forge"></a>
+
+## forge : <code>object</code>
+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  
+<a name="createPrivateKey"></a>
+
+## createPrivateKey([size]) ⇒ <code>Promise.&lt;buffer&gt;</code>
+Generate a private RSA key
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;buffer&gt;</code> - PEM encoded private RSA key  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [size] | <code>number</code> | <code>2048</code> | 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);
+```
+<a name="createPublicKey"></a>
+
+## createPublicKey(key) ⇒ <code>Promise.&lt;buffer&gt;</code>
+Create public key from a private RSA key
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;buffer&gt;</code> - PEM encoded public RSA key  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| key | <code>buffer</code> \| <code>string</code> | PEM encoded private RSA key |
+
+**Example**  
+Create public key
+```js
+const publicKey = await acme.forge.createPublicKey(privateKey);
+```
+<a name="getPemBody"></a>
+
+## getPemBody(str) ⇒ <code>string</code>
+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**: <code>string</code> - PEM body  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| str | <code>buffer</code> \| <code>string</code> | PEM encoded buffer or string |
+
+<a name="splitPemChain"></a>
+
+## splitPemChain(str) ⇒ <code>Array.&lt;string&gt;</code>
+Split chain of PEM encoded objects from buffer or string into array
+
+**Kind**: global function  
+**Returns**: <code>Array.&lt;string&gt;</code> - Array of PEM bodies  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| str | <code>buffer</code> \| <code>string</code> | PEM encoded buffer or string |
+
+<a name="getModulus"></a>
+
+## getModulus(input) ⇒ <code>Promise.&lt;buffer&gt;</code>
+Get modulus
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;buffer&gt;</code> - Modulus  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| input | <code>buffer</code> \| <code>string</code> | 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);
+```
+<a name="getPublicExponent"></a>
+
+## getPublicExponent(input) ⇒ <code>Promise.&lt;buffer&gt;</code>
+Get public exponent
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;buffer&gt;</code> - Exponent  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| input | <code>buffer</code> \| <code>string</code> | 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);
+```
+<a name="readCsrDomains"></a>
+
+## readCsrDomains(csr) ⇒ <code>Promise.&lt;object&gt;</code>
+Read domains from a Certificate Signing Request
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;object&gt;</code> - {commonName, altNames}  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| csr | <code>buffer</code> \| <code>string</code> | 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(', ')}`);
+```
+<a name="readCertificateInfo"></a>
+
+## readCertificateInfo(cert) ⇒ <code>Promise.&lt;object&gt;</code>
+Read information from a certificate
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;object&gt;</code> - Certificate info  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| cert | <code>buffer</code> \| <code>string</code> | 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(', ')}`);
+```
+<a name="createCsr"></a>
+
+## createCsr(data, [key]) ⇒ <code>Promise.&lt;Array.&lt;buffer&gt;&gt;</code>
+Create a Certificate Signing Request
+
+**Kind**: global function  
+**Returns**: <code>Promise.&lt;Array.&lt;buffer&gt;&gt;</code> - [privateKey, certificateSigningRequest]  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| data | <code>object</code> |  |
+| [data.keySize] | <code>number</code> | Size of newly created private key, default: `2048` |
+| [data.commonName] | <code>string</code> |  |
+| [data.altNames] | <code>Array.&lt;string&gt;</code> | default: `[]` |
+| [data.country] | <code>string</code> |  |
+| [data.state] | <code>string</code> |  |
+| [data.locality] | <code>string</code> |  |
+| [data.organization] | <code>string</code> |  |
+| [data.organizationUnit] | <code>string</code> |  |
+| [data.emailAddress] | <code>string</code> |  |
+| [key] | <code>buffer</code> \| <code>string</code> | 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);

packages/core/acme-client/docs/upgrade-v5.md

@@ -0,0 +1,93 @@
+# 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 [@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).
+
+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);
+```

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?

packages/core/acme-client/examples/api.js

@@ -0,0 +1,152 @@
+/**
+ * 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()}`);
+};

packages/core/acme-client/examples/auto.js

@@ -0,0 +1,117 @@
+/**
+ * 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()}`);
+};

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)

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);
+    }
+})();

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-----

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-----

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)

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);
+    }
+})();

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)

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

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;
+  }
+}

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);
+    }
+})();

packages/core/acme-client/package.json

@@ -0,0 +1,63 @@
+{
+    "name": "@certd/acme-client",
+    "description": "Simple and unopinionated ACME client",
+    "private": false,
+    "author": "nmorsman",
+    "version": "1.20.10",
+    "main": "src/index.js",
+    "types": "types/index.d.ts",
+    "license": "MIT",
+    "homepage": "https://github.com/publishlab/node-acme-client",
+    "engines": {
+        "node": ">= 16"
+    },
+    "files": [
+        "src",
+        "types"
+    ],
+    "dependencies": {
+        "@peculiar/x509": "^1.9.7",
+        "asn1js": "^3.0.5",
+        "axios": "^1.6.5",
+        "debug": "^4.1.1",
+        "https-proxy-agent": "^7.0.4",
+        "node-forge": "^1.3.1"
+    },
+    "devDependencies": {
+        "@types/node": "^20.11.5",
+        "chai": "^4.4.1",
+        "chai-as-promised": "^7.1.1",
+        "eslint": "^8.56.0",
+        "eslint-config-airbnb-base": "^15.0.0",
+        "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": "tsd",
+        "prepublishOnly": "npm run build-docs",
+        "test": "mocha -t 60000 \"test/setup.js\" \"test/**/*.spec.js\""
+    },
+    "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"
+    },
+    "gitHead": "b258e926209fef4cc4d633b0383eb54e26c516f9"
+}

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 {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`
+     * @returns {Promise<object>} 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 {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`
+     * @returns {Promise<object>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.1.1
+     *
+     * @returns {Promise<string|null>} ToS URL
+     */
+
+    async getTermsOfServiceUrl() {
+        return this.http.getMetaField('termsOfService');
+    }
+
+
+    /**
+     * Create new account
+     *
+     * https://datatracker.ietf.org/doc/html/rfc8555#section-7.3
+     *
+     * @param {object} data Request payload
+     * @returns {Promise<object>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.3.2
+     *
+     * @param {object} data Request payload
+     * @returns {Promise<object>} HTTP response
+     */
+
+    updateAccount(data) {
+        return this.apiRequest(this.getAccountUrl(), data, [200, 202]);
+    }
+
+
+    /**
+     * Update account key
+     *
+     * https://datatracker.ietf.org/doc/html/rfc8555#section-7.3.5
+     *
+     * @param {object} data Request payload
+     * @returns {Promise<object>} HTTP response
+     */
+
+    updateAccountKey(data) {
+        return this.apiResourceRequest('keyChange', data, [200]);
+    }
+
+
+    /**
+     * Create new order
+     *
+     * https://datatracker.ietf.org/doc/html/rfc8555#section-7.4
+     *
+     * @param {object} data Request payload
+     * @returns {Promise<object>} HTTP response
+     */
+
+    createOrder(data) {
+        return this.apiResourceRequest('newOrder', data, [201]);
+    }
+
+
+    /**
+     * Get order
+     *
+     * https://datatracker.ietf.org/doc/html/rfc8555#section-7.4
+     *
+     * @param {string} url Order URL
+     * @returns {Promise<object>} HTTP response
+     */
+
+    getOrder(url) {
+        return this.apiRequest(url, null, [200]);
+    }
+
+
+    /**
+     * Finalize order
+     *
+     * https://datatracker.ietf.org/doc/html/rfc8555#section-7.4
+     *
+     * @param {string} url Finalization URL
+     * @param {object} data Request payload
+     * @returns {Promise<object>} HTTP response
+     */
+
+    finalizeOrder(url, data) {
+        return this.apiRequest(url, data, [200]);
+    }
+
+
+    /**
+     * Get identifier authorization
+     *
+     * https://datatracker.ietf.org/doc/html/rfc8555#section-7.5
+     *
+     * @param {string} url Authorization URL
+     * @returns {Promise<object>} HTTP response
+     */
+
+    getAuthorization(url) {
+        return this.apiRequest(url, null, [200]);
+    }
+
+
+    /**
+     * Update identifier authorization
+     *
+     * https://datatracker.ietf.org/doc/html/rfc8555#section-7.5.2
+     *
+     * @param {string} url Authorization URL
+     * @param {object} data Request payload
+     * @returns {Promise<object>} HTTP response
+     */
+
+    updateAuthorization(url, data) {
+        return this.apiRequest(url, data, [200]);
+    }
+
+
+    /**
+     * Complete challenge
+     *
+     * https://datatracker.ietf.org/doc/html/rfc8555#section-7.5.1
+     *
+     * @param {string} url Challenge URL
+     * @param {object} data Request payload
+     * @returns {Promise<object>} HTTP response
+     */
+
+    completeChallenge(url, data) {
+        return this.apiRequest(url, data, [200]);
+    }
+
+
+    /**
+     * Revoke certificate
+     *
+     * https://datatracker.ietf.org/doc/html/rfc8555#section-7.6
+     *
+     * @param {object} data Request payload
+     * @returns {Promise<object>} HTTP response
+     */
+
+    revokeCert(data) {
+        return this.apiResourceRequest('revokeCert', data, [200]);
+    }
+}
+
+
+/* Export API */
+module.exports = AcmeApi;

packages/core/acme-client/src/auto.js

@@ -0,0 +1,218 @@
+/**
+ * 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<buffer>} 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 { commonName, altNames } = readCsrDomains(opts.csr);
+    const uniqueDomains = Array.from(new Set([commonName].concat(altNames).filter((d) => d)));
+
+    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 clearTasks = [];
+
+    const challengeFunc = 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);
+            let recordItem = null;
+            try {
+                recordItem = 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);
+            }
+            catch (e) {
+                log(`[auto] [${d}] challengeCreateFn threw error: ${e.message}`);
+                throw e;
+            }
+            finally {
+                log(`[auto] [${d}] add challengeRemoveFn()`);
+                clearTasks.push(async () => {
+                    /* Trigger challengeRemoveFn(), suppress errors */
+                    log(`[auto] [${d}] Trigger challengeRemoveFn()`);
+                    try {
+                        await opts.challengeRemoveFn(authz, challenge, keyAuthorization, recordItem);
+                    }
+                    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;
+        }
+    };
+
+    const challengePromises = authorizations.map((authz) => async () => {
+        await challengeFunc(authz);
+    });
+
+    log('开始challenge');
+    let promise = Promise.resolve();
+    function runPromisesSerially(tasks) {
+        tasks.forEach((task) => {
+            promise = promise.then(task);
+        });
+        return promise;
+    }
+
+
+    try {
+        await runPromisesSerially(challengePromises);
+    }
+    finally {
+        await runPromisesSerially(clearTasks);
+    }
+
+    // try {
+    //     await Promise.allSettled(challengePromises);
+    // }
+    // finally {
+    //     log('清理challenge');
+    //     await Promise.allSettled(clearTasks);
+    // }
+
+
+    log('challenge结束');
+
+    // 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);
+};

packages/core/acme-client/src/axios.js

@@ -0,0 +1,43 @@
+/**
+ * Axios instance
+ */
+
+const axios = require('axios');
+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,
+    httpsChallengePort: 443,
+    tlsAlpnChallengePort: 443
+};
+
+// instance.defaults.proxy = {
+//     host: '192.168.34.139',
+//     port: 10811
+// };
+/**
+ * Explicitly set Node as default HTTP adapter
+ *
+ * https://github.com/axios/axios/issues/1180
+ * https://stackoverflow.com/questions/42677387
+ */
+
+instance.defaults.adapter = 'http';
+
+
+/**
+ * Export instance
+ */
+
+module.exports = instance;

packages/core/acme-client/src/client.js

@@ -0,0 +1,732 @@
+/**
+ * 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<string|null>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.3
+     *
+     * @param {object} [data] Request data
+     * @returns {Promise<object>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.3.2
+     *
+     * @param {object} [data] Request data
+     * @returns {Promise<object>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.3.5
+     *
+     * @param {buffer|string} newAccountKey New PEM encoded private key
+     * @param {object} [data] Additional request data
+     * @returns {Promise<object>} 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, this.opts.externalAccountBinding);
+        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://datatracker.ietf.org/doc/html/rfc8555#section-7.4
+     *
+     * @param {object} data Request data
+     * @returns {Promise<object>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.4
+     *
+     * @param {object} order Order object
+     * @returns {Promise<object>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.4
+     *
+     * @param {object} order Order object
+     * @param {buffer|string} csr PEM encoded Certificate Signing Request
+     * @returns {Promise<object>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.5
+     *
+     * @param {object} order Order
+     * @returns {Promise<object[]>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.5.2
+     *
+     * @param {object} authz Identifier authorization
+     * @returns {Promise<object>} 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://datatracker.ietf.org/doc/html/rfc8555#section-8.1
+     *
+     * @param {object} challenge Challenge object returned by API
+     * @returns {Promise<string>} 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://datatracker.ietf.org/doc/html/rfc8555#section-8.3 */
+        if (challenge.type === 'http-01') {
+            return result;
+        }
+
+        /* https://datatracker.ietf.org/doc/html/rfc8555#section-8.4 */
+        if (challenge.type === 'dns-01') {
+            return createHash('sha256').update(result).digest('base64url');
+        }
+
+        /* https://datatracker.ietf.org/doc/html/rfc8737 */
+        if (challenge.type === 'tls-alpn-01') {
+            return result;
+        }
+
+        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://datatracker.ietf.org/doc/html/rfc8555#section-7.5.1
+     *
+     * @param {object} challenge Challenge object returned by API
+     * @returns {Promise<object>} 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://datatracker.ietf.org/doc/html/rfc8555#section-7.5.1
+     *
+     * @param {object} item An order, authorization or challenge object
+     * @returns {Promise<object>} Valid order, authorization or challenge
+     *
+     * @example Wait for valid challenge status
+     * ```js
+     * const challenge = { ... };
+     * await client.waitForValidStatus(challenge);
+     * ```
+     *
+     * @example Wait for valid authorization 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://datatracker.ietf.org/doc/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<string>} 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://datatracker.ietf.org/doc/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<string>} 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;

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<buffer>} 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<buffer>} 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<buffer>} 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<buffer>} 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<object>} {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<object>} 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://datatracker.ietf.org/doc/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 {string[]} [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<buffer[]>} [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)];
+};

packages/core/acme-client/src/crypto/index.js

@@ -0,0 +1,619 @@
+/**
+ * Native Node.js crypto interface
+ *
+ * @namespace crypto
+ */
+
+const net = require('net');
+const { promisify } = require('util');
+const crypto = require('crypto');
+const asn1js = require('asn1js');
+const x509 = require('@peculiar/x509');
+
+const randomInt = promisify(crypto.randomInt);
+const generateKeyPair = promisify(crypto.generateKeyPair);
+
+/* Use Node.js Web Crypto API */
+x509.cryptoProvider.set(crypto.webcrypto);
+
+/* id-ce-subjectAltName - https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.6 */
+const subjectAltNameOID = '2.5.29.17';
+
+/* id-pe-acmeIdentifier - https://datatracker.ietf.org/doc/html/rfc8737#section-6.1 */
+const alpnAcmeIdentifierOID = '1.3.6.1.5.5.7.1.31';
+
+
+/**
+ * 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,
+        publicKey: crypto.createPublicKey(keyPem)
+    };
+
+    if (result.publicKey.asymmetricKeyType === 'rsa') {
+        result.isRSA = true;
+    }
+    else if (result.publicKey.asymmetricKeyType === 'ec') {
+        result.isECDSA = true;
+    }
+    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<buffer>} 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<buffer>} 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;
+
+
+/**
+ * Produce CryptoKeyPair and signing algorithm from a PEM encoded private key
+ *
+ * @private
+ * @param {buffer|string} keyPem PEM encoded private key
+ * @returns {Promise<array>} [keyPair, signingAlgorithm]
+ */
+
+async function getWebCryptoKeyPair(keyPem) {
+    const info = getKeyInfo(keyPem);
+    const jwk = getJwk(keyPem);
+
+    /* Signing algorithm */
+    const sigalg = {
+        name: 'RSASSA-PKCS1-v1_5',
+        hash: { name: 'SHA-256' }
+    };
+
+    if (info.isECDSA) {
+        sigalg.name = 'ECDSA';
+        sigalg.namedCurve = jwk.crv;
+
+        if (jwk.crv === 'P-384') {
+            sigalg.hash.name = 'SHA-384';
+        }
+
+        if (jwk.crv === 'P-521') {
+            sigalg.hash.name = 'SHA-512';
+        }
+    }
+
+    /* Decode PEM and import into CryptoKeyPair */
+    const privateKeyDec = x509.PemConverter.decodeFirst(keyPem.toString());
+    const privateKey = await crypto.webcrypto.subtle.importKey('pkcs8', privateKeyDec, sigalg, true, ['sign']);
+    const publicKey = await crypto.webcrypto.subtle.importKey('jwk', jwk, sigalg, true, ['verify']);
+
+    return [{ privateKey, publicKey }, sigalg];
+}
+
+
+/**
+ * Split chain of PEM encoded objects from string into array
+ *
+ * @param {buffer|string} chainPem PEM encoded object chain
+ * @returns {string[]} Array of PEM objects including headers
+ */
+
+function splitPemChain(chainPem) {
+    if (Buffer.isBuffer(chainPem)) {
+        chainPem = chainPem.toString();
+    }
+
+    /* Decode into array and re-encode */
+    return x509.PemConverter.decodeWithHeaders(chainPem)
+        .map((params) => x509.PemConverter.encode([params]));
+}
+
+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');
+    }
+
+    /* Select first object, extract body and convert to b64u */
+    const dec = x509.PemConverter.decodeFirst(chain[0]);
+    return Buffer.from(dec).toString('base64url');
+};
+
+
+/**
+ * Parse domains from a certificate or CSR
+ *
+ * @private
+ * @param {object} input x509.Certificate or x509.Pkcs10CertificateRequest
+ * @returns {object} {commonName, altNames}
+ */
+
+function parseDomains(input) {
+    const commonName = input.subjectName.getField('CN').pop() || null;
+    const altNamesRaw = input.getExtension(subjectAltNameOID);
+    let altNames = [];
+
+    if (altNamesRaw) {
+        const altNamesExt = new x509.SubjectAlternativeNameExtension(altNamesRaw.rawData);
+        altNames = altNames.concat(altNamesExt.names.items.map((i) => i.value));
+    }
+
+    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();
+    }
+
+    const dec = x509.PemConverter.decodeFirst(csrPem);
+    const csr = new x509.Pkcs10CertificateRequest(dec);
+    return parseDomains(csr);
+};
+
+
+/**
+ * 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) => {
+    if (Buffer.isBuffer(certPem)) {
+        certPem = certPem.toString();
+    }
+
+    const dec = x509.PemConverter.decodeFirst(certPem);
+    const cert = new x509.X509Certificate(dec);
+
+    return {
+        issuer: {
+            commonName: cert.issuerName.getField('CN').pop() || null
+        },
+        domains: parseDomains(cert),
+        notBefore: cert.notBefore,
+        notAfter: cert.notAfter
+    };
+};
+
+
+/**
+ * Determine ASN.1 character string type for CSR subject field name
+ *
+ * https://datatracker.ietf.org/doc/html/rfc5280
+ * https://github.com/PeculiarVentures/x509/blob/ecf78224fd594abbc2fa83c41565d79874f88e00/src/name.ts#L65-L71
+ *
+ * @private
+ * @param {string} field CSR subject field name
+ * @returns {string} ASN.1 character string type
+ */
+
+function getCsrAsn1CharStringType(field) {
+    switch (field) {
+        case 'C':
+            return 'printableString';
+        case 'E':
+            return 'ia5String';
+        default:
+            return 'utf8String';
+    }
+}
+
+
+/**
+ * Create array of subject fields for a Certificate Signing Request
+ *
+ * https://github.com/PeculiarVentures/x509/blob/ecf78224fd594abbc2fa83c41565d79874f88e00/src/name.ts#L65-L71
+ *
+ * @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]: [{ [ds]: value }] });
+        }
+
+        return result;
+    }, []);
+}
+
+
+/**
+ * Create x509 subject alternate name extension
+ *
+ * https://github.com/PeculiarVentures/x509/blob/ecf78224fd594abbc2fa83c41565d79874f88e00/src/extensions/subject_alt_name.ts
+ *
+ * @private
+ * @param {string[]} altNames Array of alt names
+ * @returns {x509.SubjectAlternativeNameExtension} Subject alternate name extension
+ */
+
+function createSubjectAltNameExtension(altNames) {
+    return new x509.SubjectAlternativeNameExtension(altNames.map((value) => {
+        const type = net.isIP(value) ? 'ip' : 'dns';
+        return { type, 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 {string[]} [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 {buffer|string} [keyPem] PEM encoded CSR private key
+ * @returns {Promise<buffer[]>} [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 = [];
+    }
+
+    /* 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);
+    }
+
+    /* CryptoKeyPair and signing algorithm from private key */
+    const [keys, signingAlgorithm] = await getWebCryptoKeyPair(keyPem);
+
+    const extensions = [
+        /* https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.3 */
+        new x509.KeyUsagesExtension(x509.KeyUsageFlags.digitalSignature | x509.KeyUsageFlags.keyEncipherment), // eslint-disable-line no-bitwise
+
+        /* https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.6 */
+        createSubjectAltNameExtension(data.altNames)
+    ];
+
+    /* Create CSR */
+    const csr = await x509.Pkcs10CertificateRequestGenerator.create({
+        keys,
+        extensions,
+        signingAlgorithm,
+        name: createCsrSubject({
+            CN: data.commonName,
+            C: data.country,
+            ST: data.state,
+            L: data.locality,
+            O: data.organization,
+            OU: data.organizationUnit,
+            E: data.emailAddress
+        })
+    });
+
+    /* Done */
+    const pem = csr.toString('pem');
+    return [keyPem, Buffer.from(pem)];
+};
+
+
+/**
+ * Create a self-signed ALPN certificate for TLS-ALPN-01 challenges
+ *
+ * https://datatracker.ietf.org/doc/html/rfc8737
+ *
+ * @param {object} authz Identifier authorization
+ * @param {string} keyAuthorization Challenge key authorization
+ * @param {buffer|string} [keyPem] PEM encoded CSR private key
+ * @returns {Promise<buffer[]>} [privateKey, certificate]
+ *
+ * @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);
+ */
+
+exports.createAlpnCertificate = async (authz, keyAuthorization, keyPem = null) => {
+    if (!keyPem) {
+        keyPem = await createPrivateRsaKey();
+    }
+    else if (!Buffer.isBuffer(keyPem)) {
+        keyPem = Buffer.from(keyPem);
+    }
+
+    const now = new Date();
+    const commonName = authz.identifier.value;
+
+    /* Pseudo-random serial - max 20 bytes, 11 for epoch (year 5138), 9 random */
+    const random = await randomInt(1, 999999999);
+    const serialNumber = `${Math.floor(now.getTime() / 1000)}${random}`;
+
+    /* CryptoKeyPair and signing algorithm from private key */
+    const [keys, signingAlgorithm] = await getWebCryptoKeyPair(keyPem);
+
+    const extensions = [
+        /* https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.3 */
+        new x509.KeyUsagesExtension(x509.KeyUsageFlags.keyCertSign | x509.KeyUsageFlags.cRLSign, true), // eslint-disable-line no-bitwise
+
+        /* https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.9 */
+        new x509.BasicConstraintsExtension(true, 2, true),
+
+        /* https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.2 */
+        await x509.SubjectKeyIdentifierExtension.create(keys.publicKey),
+
+        /* https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.6 */
+        createSubjectAltNameExtension([commonName])
+    ];
+
+    /* ALPN extension */
+    const payload = crypto.createHash('sha256').update(keyAuthorization).digest('hex');
+    const octstr = new asn1js.OctetString({ valueHex: Buffer.from(payload, 'hex') });
+    extensions.push(new x509.Extension(alpnAcmeIdentifierOID, true, octstr.toBER()));
+
+    /* Self-signed ALPN certificate */
+    const cert = await x509.X509CertificateGenerator.createSelfSigned({
+        keys,
+        signingAlgorithm,
+        extensions,
+        serialNumber,
+        notBefore: now,
+        notAfter: now,
+        name: createCsrSubject({
+            CN: commonName
+        })
+    });
+
+    /* Done */
+    const pem = cert.toString('pem');
+    return [keyPem, Buffer.from(pem)];
+};
+
+
+/**
+ * Validate that a ALPN certificate contains the expected key authorization
+ *
+ * @param {buffer|string} certPem PEM encoded certificate
+ * @param {string} keyAuthorization Expected challenge key authorization
+ * @returns {boolean} True when valid
+ */
+
+exports.isAlpnCertificateAuthorizationValid = (certPem, keyAuthorization) => {
+    const expected = crypto.createHash('sha256').update(keyAuthorization).digest('hex');
+
+    /* Attempt to locate ALPN extension */
+    const cert = new x509.X509Certificate(certPem);
+    const ext = cert.getExtension(alpnAcmeIdentifierOID);
+
+    if (!ext) {
+        throw new Error('Unable to locate ALPN extension within parsed certificate');
+    }
+
+    /* Decode extension value */
+    const parsed = asn1js.fromBER(ext.value);
+    const result = Buffer.from(parsed.result.valueBlock.valueHexView).toString('hex');
+
+    /* Return true if match */
+    return (result === expected);
+};

packages/core/acme-client/src/http.js

@@ -0,0 +1,328 @@
+/**
+ * ACME HTTP client
+ */
+
+const { createHmac, createSign, constants: { RSA_PKCS1_PADDING } } = require('crypto');
+const { HttpsProxyAgent } = require('https-proxy-agent');
+const { getJwk } = require('./crypto');
+const { log } = require('./logger');
+const axios1 = require('./axios');
+
+const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+let httpsAgent = null;
+if (httpsProxy) {
+    httpsAgent = new HttpsProxyAgent(httpsProxy);
+}
+const axios = axios1.create({
+    proxy: false,
+    httpsAgent
+});
+
+/**
+ * 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<object>} 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://datatracker.ietf.org/doc/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://datatracker.ietf.org/doc/html/rfc8555#section-7.2
+     *
+     * @returns {Promise<string>} 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<string>} 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<string|null>} 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://datatracker.ietf.org/doc/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<object>} 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://datatracker.ietf.org/doc/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;

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;

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);
+};

packages/core/acme-client/src/util.js

@@ -0,0 +1,314 @@
+/**
+ * Utility methods
+ */
+
+const tls = require('tls');
+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 {string[]} Array of URLs
+ */
+
+function parseLinkHeader(header, rel = 'alternate') {
+    const relRe = new RegExp(`\\s*rel\\s*=\\s*"?${rel}"?`, 'i');
+
+    const results = (header || '').split(/,\s*</).map((link) => {
+        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 {string[]} 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<string>} 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>} 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;
+}
+
+
+/**
+ * Attempt to retrieve TLS ALPN certificate from peer
+ *
+ * https://nodejs.org/api/tls.html#tlsconnectoptions-callback
+ *
+ * @param {string} host Host the TLS client should connect to
+ * @param {number} port Port the client should connect to
+ * @param {string} servername Server name for the SNI (Server Name Indication)
+ * @returns {Promise<string>} PEM encoded certificate
+ */
+
+async function retrieveTlsAlpnCertificate(host, port, timeout = 30000) {
+    return new Promise((resolve, reject) => {
+        let result;
+
+        /* TLS connection */
+        const socket = tls.connect({
+            host,
+            port,
+            servername: host,
+            rejectUnauthorized: false,
+            ALPNProtocols: ['acme-tls/1']
+        });
+
+        socket.setTimeout(timeout);
+        socket.setEncoding('utf-8');
+
+        /* Grab certificate once connected and close */
+        socket.on('secureConnect', () => {
+            result = socket.getPeerX509Certificate();
+            socket.end();
+        });
+
+        /* Errors */
+        socket.on('error', (err) => {
+            reject(err);
+        });
+
+        socket.on('timeout', () => {
+            socket.destroy(new Error('TLS ALPN certificate lookup request timed out'));
+        });
+
+        /* Done, return cert as PEM if found */
+        socket.on('end', () => {
+            if (result) {
+                return resolve(result.toString());
+            }
+
+            return reject(new Error('TLS ALPN lookup failed to retrieve certificate'));
+        });
+    });
+}
+
+
+/**
+ * Export utils
+ */
+
+module.exports = {
+    retry,
+    parseLinkHeader,
+    findCertificateChainForIssuer,
+    formatResponseError,
+    getAuthoritativeDnsResolver,
+    retrieveTlsAlpnCertificate
+};

packages/core/acme-client/src/verify.js

@@ -0,0 +1,161 @@
+/**
+ * ACME challenge verification
+ */
+
+const dns = require('dns').promises;
+const https = require('https');
+const { log } = require('./logger');
+const axios = require('./axios');
+const util = require('./util');
+const { isAlpnCertificateAuthorizationValid } = require('./crypto');
+
+
+/**
+ * Verify ACME HTTP challenge
+ *
+ * https://datatracker.ietf.org/doc/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<boolean>}
+ */
+
+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}`;
+
+    /* May redirect to HTTPS with invalid/self-signed cert - https://letsencrypt.org/docs/challenge-types/#http-01-challenge */
+    const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+
+    log(`Sending HTTP query to ${authz.identifier.value}, suffix: ${suffix}, port: ${httpPort}`);
+    const resp = await axios.get(challengeUrl, { httpsAgent });
+    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://datatracker.ietf.org/doc/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<boolean>}
+ */
+
+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;
+}
+
+
+/**
+ * Verify ACME TLS ALPN challenge
+ *
+ * https://datatracker.ietf.org/doc/html/rfc8737
+ *
+ * @param {object} authz Identifier authorization
+ * @param {object} challenge Authorization challenge
+ * @param {string} keyAuthorization Challenge key authorization
+ * @returns {Promise<boolean>}
+ */
+
+async function verifyTlsAlpnChallenge(authz, challenge, keyAuthorization) {
+    const tlsAlpnPort = axios.defaults.acmeSettings.tlsAlpnChallengePort || 443;
+    const host = authz.identifier.value;
+    log(`Establishing TLS connection with host: ${host}:${tlsAlpnPort}`);
+
+    const certificate = await util.retrieveTlsAlpnCertificate(host, tlsAlpnPort);
+    log('Certificate received from server successfully, matching key authorization in ALPN');
+
+    if (!isAlpnCertificateAuthorizationValid(certificate, keyAuthorization)) {
+        throw new Error(`Authorization not found in certificate from ${authz.identifier.value}`);
+    }
+
+    log(`Key authorization match for ${challenge.type}/${authz.identifier.value}, ACME challenge verified`);
+    return true;
+}
+
+
+/**
+ * Export API
+ */
+
+module.exports = {
+    'http-01': verifyHttpChallenge,
+    'dns-01': verifyDnsChallenge,
+    'tls-alpn-01': verifyTlsAlpnChallenge
+};

packages/core/acme-client/test/00-pebble.spec.js

@@ -0,0 +1,215 @@
+/**
+ * Pebble Challenge Test Server tests
+ */
+
+const dns = require('dns').promises;
+const { randomUUID: uuid } = require('crypto');
+const https = require('https');
+const { assert } = require('chai');
+const cts = require('./challtestsrv');
+const axios = require('./../src/axios');
+const { retrieveTlsAlpnCertificate } = require('./../src/util');
+const { isAlpnCertificateAuthorizationValid } = require('./../src/crypto');
+
+const domainName = process.env.ACME_DOMAIN_NAME || 'example.com';
+const httpPort = axios.defaults.acmeSettings.httpChallengePort || 80;
+const httpsPort = axios.defaults.acmeSettings.httpsChallengePort || 443;
+const tlsAlpnPort = axios.defaults.acmeSettings.tlsAlpnChallengePort || 443;
+
+
+describe('pebble', () => {
+    const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+
+    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 testHttps01ChallengeHost = `${uuid()}.${domainName}`;
+    const testHttps01ChallengeToken = uuid();
+    const testHttps01ChallengeContent = uuid();
+
+    const testDns01ChallengeHost = `_acme-challenge.${uuid()}.${domainName}.`;
+    const testDns01ChallengeValue = uuid();
+
+    const testTlsAlpn01ChallengeHost = `${uuid()}.${domainName}`;
+    const testTlsAlpn01ChallengeValue = 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]);
+        });
+    });
+
+
+    /**
+     * HTTP-01 challenge response
+     */
+
+    describe('http-01', () => {
+        it('should not locate 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 challenge response', async () => {
+            const resp = await cts.addHttp01ChallengeResponse(testHttp01ChallengeToken, testHttp01ChallengeContent);
+            assert.isTrue(resp);
+        });
+
+        it('should locate 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);
+        });
+    });
+
+
+    /**
+     * HTTPS-01 challenge response
+     */
+
+    describe('https-01', () => {
+        it('should not locate challenge response', async () => {
+            const r1 = await axios.get(`http://${testHttps01ChallengeHost}:${httpPort}/.well-known/acme-challenge/${testHttps01ChallengeToken}`, { httpsAgent });
+            const r2 = await axios.get(`https://${testHttps01ChallengeHost}:${httpsPort}/.well-known/acme-challenge/${testHttps01ChallengeToken}`, { httpsAgent });
+
+            [r1, r2].forEach((resp) => {
+                assert.isString(resp.data);
+                assert.notEqual(resp.data, testHttps01ChallengeContent);
+            });
+        });
+
+        it('should add challenge response', async () => {
+            const resp = await cts.addHttps01ChallengeResponse(testHttps01ChallengeToken, testHttps01ChallengeContent, testHttps01ChallengeHost);
+            assert.isTrue(resp);
+        });
+
+        it('should 302 with self-signed cert', async () => {
+            /* Assert HTTP 302 */
+            const resp = await axios.get(`http://${testHttps01ChallengeHost}:${httpPort}/.well-known/acme-challenge/${testHttps01ChallengeToken}`, {
+                maxRedirects: 0,
+                validateStatus: null
+            });
+
+            assert.strictEqual(resp.status, 302);
+            assert.strictEqual(resp.headers.location, `https://${testHttps01ChallengeHost}:${httpsPort}/.well-known/acme-challenge/${testHttps01ChallengeToken}`);
+
+            /* Self-signed cert test */
+            await assert.isRejected(axios.get(`https://${testHttps01ChallengeHost}:${httpsPort}/.well-known/acme-challenge/${testHttps01ChallengeToken}`));
+            await assert.isFulfilled(axios.get(`https://${testHttps01ChallengeHost}:${httpsPort}/.well-known/acme-challenge/${testHttps01ChallengeToken}`, { httpsAgent }));
+        });
+
+        it('should locate challenge response', async () => {
+            const r1 = await axios.get(`http://${testHttps01ChallengeHost}:${httpPort}/.well-known/acme-challenge/${testHttps01ChallengeToken}`, { httpsAgent });
+            const r2 = await axios.get(`https://${testHttps01ChallengeHost}:${httpsPort}/.well-known/acme-challenge/${testHttps01ChallengeToken}`, { httpsAgent });
+
+            [r1, r2].forEach((resp) => {
+                assert.isString(resp.data);
+                assert.strictEqual(resp.data, testHttps01ChallengeContent);
+            });
+        });
+    });
+
+
+    /**
+     * DNS-01 challenge response
+     */
+
+    describe('dns-01', () => {
+        it('should not locate challenge response', async () => {
+            await assert.isRejected(dns.resolveTxt(testDns01ChallengeHost));
+        });
+
+        it('should add challenge response', async () => {
+            const resp = await cts.addDns01ChallengeResponse(testDns01ChallengeHost, testDns01ChallengeValue);
+            assert.isTrue(resp);
+        });
+
+        it('should locate challenge response', async () => {
+            const resp = await dns.resolveTxt(testDns01ChallengeHost);
+
+            assert.isArray(resp);
+            assert.deepStrictEqual(resp, [[testDns01ChallengeValue]]);
+        });
+    });
+
+
+    /**
+     * TLS-ALPN-01 challenge response
+     */
+
+    describe('tls-alpn-01', () => {
+        it('should not locate challenge response', async () => {
+            await assert.isRejected(retrieveTlsAlpnCertificate(testTlsAlpn01ChallengeHost, tlsAlpnPort), /(failed to retrieve)|(ssl3_read_bytes:tlsv1 alert internal error)/);
+        });
+
+        it('should timeout challenge response', async () => {
+            await assert.isRejected(retrieveTlsAlpnCertificate('example.org', tlsAlpnPort, 500));
+        });
+
+        it('should add challenge response', async () => {
+            const resp = await cts.addTlsAlpn01ChallengeResponse(testTlsAlpn01ChallengeHost, testTlsAlpn01ChallengeValue);
+            assert.isTrue(resp);
+        });
+
+        it('should locate challenge response', async () => {
+            const resp = await retrieveTlsAlpnCertificate(testTlsAlpn01ChallengeHost, tlsAlpnPort);
+            assert.isTrue(isAlpnCertificateAuthorizationValid(resp, testTlsAlpn01ChallengeValue));
+        });
+    });
+});

packages/core/acme-client/test/10-http.spec.js

@@ -0,0 +1,98 @@
+/**
+ * HTTP client tests
+ */
+
+const { randomUUID: uuid } = require('crypto');
+const { assert } = require('chai');
+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(() => {
+        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;
+    });
+
+
+    /**
+     * 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'));
+    });
+});

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);
+        });
+    });
+});

packages/core/acme-client/test/10-verify.spec.js

@@ -0,0 +1,156 @@
+/**
+ * Challenge verification tests
+ */
+
+const { randomUUID: uuid } = require('crypto');
+const { assert } = require('chai');
+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 testHttps01Authz = { identifier: { type: 'dns', value: `${uuid()}.${domainName}` } };
+    const testHttps01Challenge = { type: 'http-01', status: 'pending', token: uuid() };
+    const testHttps01Key = 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}`;
+
+    const testTlsAlpn01Authz = { identifier: { type: 'dns', value: `${uuid()}.${domainName}` } };
+    const testTlsAlpn01Challenge = { type: 'dns-01', status: 'pending', token: uuid() };
+    const testTlsAlpn01Key = uuid();
+
+
+    /**
+     * 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);
+        });
+    });
+
+
+    /**
+     * https-01
+     */
+
+    describe('https-01', () => {
+        it('should reject challenge', async () => {
+            await assert.isRejected(verify['http-01'](testHttps01Authz, testHttps01Challenge, testHttps01Key));
+        });
+
+        it('should mock challenge response', async () => {
+            const resp = await cts.addHttps01ChallengeResponse(testHttps01Challenge.token, testHttps01Key, testHttps01Authz.identifier.value);
+            assert.isTrue(resp);
+        });
+
+        it('should verify challenge', async () => {
+            const resp = await verify['http-01'](testHttps01Authz, testHttps01Challenge, testHttps01Key);
+            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);
+        });
+    });
+
+
+    /**
+     * tls-alpn-01
+     */
+
+    describe('tls-alpn-01', () => {
+        it('should reject challenge', async () => {
+            await assert.isRejected(verify['tls-alpn-01'](testTlsAlpn01Authz, testTlsAlpn01Challenge, testTlsAlpn01Key));
+        });
+
+        it('should mock challenge response', async () => {
+            const resp = await cts.addTlsAlpn01ChallengeResponse(testTlsAlpn01Authz.identifier.value, testTlsAlpn01Key);
+            assert.isTrue(resp);
+        });
+
+        it('should verify challenge', async () => {
+            const resp = await verify['tls-alpn-01'](testTlsAlpn01Authz, testTlsAlpn01Challenge, testTlsAlpn01Key);
+            assert.isTrue(resp);
+        });
+    });
+});

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));
+            }
+        });
+    });
+});

packages/core/acme-client/test/20-crypto.spec.js

@@ -0,0 +1,423 @@
+/**
+ * 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-----
+dGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZw==
+-----END TEST-----
+-----BEGIN TEST-----
+dGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZw==
+-----END TEST-----
+
+-----BEGIN TEST-----
+
+-----END TEST-----
+
+
+-----BEGIN TEST-----
+dGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZw==
+-----END TEST-----
+`;
+
+const emptyBodyChain2 = `
+
+
+-----BEGIN TEST-----
+-----END TEST-----
+-----BEGIN TEST-----
+
+
+
+-----END TEST-----
+
+-----BEGIN TEST-----
+dGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZw==
+-----END TEST-----
+
+
+-----BEGIN TEST-----
+dGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZw==
+-----END TEST-----
+-----BEGIN TEST-----
+dGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZ3Rlc3Rpbmd0ZXN0aW5ndGVzdGluZw==
+-----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;
+                let testAlpnCertificate;
+
+
+                /**
+                 * 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 public key from string`, () => {
+                    testPublicKeys[n] = crypto.getPublicKey(testPrivateKeys[n].toString());
+                    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);
+                });
+
+                it(`${n}/should get jwk from string`, () => {
+                    const jwk = crypto.getJwk(testPrivateKeys[n].toString());
+                    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 generate a csr with key as string`, async () => {
+                    const [key, csr] = await crypto.createCsr({
+                        commonName: testCsrDomain
+                    }, testPrivateKeys[n].toString());
+
+                    assert.isTrue(Buffer.isBuffer(key));
+                    assert.isTrue(Buffer.isBuffer(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]);
+                });
+
+                it(`${n}/should resolve domains from csr string`, () => {
+                    [testCsr, testSanCsr, testNonCnCsr, testNonAsciiCsr].forEach((csr) => {
+                        const result = crypto.readCsrDomains(csr.toString());
+                        spec.crypto.csrDomains(result);
+                    });
+                });
+
+
+                /**
+                 * ALPN
+                 */
+
+                it(`${n}/should generate alpn certificate`, async () => {
+                    const authz = { identifier: { value: 'test.example.com' } };
+                    const [key, cert] = await crypto.createAlpnCertificate(authz, 'super-secret.12345', await createFn());
+
+                    assert.isTrue(Buffer.isBuffer(key));
+                    assert.isTrue(Buffer.isBuffer(cert));
+
+                    testAlpnCertificate = cert;
+                });
+
+                it(`${n}/should generate alpn certificate with key as string`, async () => {
+                    const k = await createFn();
+                    const authz = { identifier: { value: 'test.example.com' } };
+                    const [key, cert] = await crypto.createAlpnCertificate(authz, 'super-secret.12345', k.toString());
+
+                    assert.isTrue(Buffer.isBuffer(key));
+                    assert.isTrue(Buffer.isBuffer(cert));
+                });
+
+                it(`${n}/should not validate invalid alpn certificate key authorization`, () => {
+                    assert.isFalse(crypto.isAlpnCertificateAuthorizationValid(testAlpnCertificate, 'aaaaaaa'));
+                    assert.isFalse(crypto.isAlpnCertificateAuthorizationValid(testAlpnCertificate, 'bbbbbbb'));
+                    assert.isFalse(crypto.isAlpnCertificateAuthorizationValid(testAlpnCertificate, 'ccccccc'));
+                });
+
+                it(`${n}/should validate valid alpn certificate key authorization`, () => {
+                    assert.isTrue(crypto.isAlpnCertificateAuthorizationValid(testAlpnCertificate, 'super-secret.12345'));
+                });
+
+                it(`${n}/should validate valid alpn certificate with cert as string`, () => {
+                    assert.isTrue(crypto.isAlpnCertificateAuthorizationValid(testAlpnCertificate.toString(), 'super-secret.12345'));
+                });
+            });
+        });
+    });
+
+
+    /**
+     * 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 default 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));
+        });
+
+        it('should read certificate info from string', () => {
+            [testCert, testSanCert].forEach((cert) => {
+                const info = crypto.readCertificateInfo(cert.toString());
+                spec.crypto.certificateInfo(info);
+            });
+        });
+
+
+        /**
+         * ALPN
+         */
+
+        it('should generate alpn certificate with default key', async () => {
+            const authz = { identifier: { value: 'test.example.com' } };
+            const [key, cert] = await crypto.createAlpnCertificate(authz, 'abc123');
+
+            assert.isTrue(Buffer.isBuffer(key));
+            assert.isTrue(Buffer.isBuffer(cert));
+        });
+
+
+        /**
+         * 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 get pem body as b64u from string', () => {
+            [testPemKey, testCert, testSanCert].forEach((pem) => {
+                const body = crypto.getPemBodyAsB64u(pem.toString());
+
+                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 from string', () => {
+            [testPemKey, testCert, testSanCert].forEach((pem) => {
+                const chain = crypto.splitPemChain(pem.toString());
+
+                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);
+        });
+    });
+});

packages/core/acme-client/test/50-client.spec.js

@@ -0,0 +1,595 @@
+/**
+ * ACME client tests
+ */
+
+const { randomUUID: uuid } = require('crypto');
+const { assert } = require('chai');
+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 testDomainAlpn = `${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 testOrderAlpn;
+            let testOrderWildcard;
+            let testAuthz;
+            let testAuthzAlpn;
+            let testAuthzWildcard;
+            let testChallenge;
+            let testChallengeAlpn;
+            let testChallengeWildcard;
+            let testKeyAuthorization;
+            let testKeyAuthorizationAlpn;
+            let testKeyAuthorizationWildcard;
+            let testCsr;
+            let testCsrAlpn;
+            let testCsrWildcard;
+            let testCertificate;
+            let testCertificateAlpn;
+            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());
+                [, testCsrAlpn] = await acme.crypto.createCsr({ commonName: testDomainAlpn }, 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: testDomainAlpn }] };
+                const data3 = { identifiers: [{ type: 'dns', value: testDomainWildcard }] };
+
+                testOrder = await testClient.createOrder(data1);
+                testOrderAlpn = await testClient.createOrder(data2);
+                testOrderWildcard = await testClient.createOrder(data3);
+
+                [testOrder, testOrderAlpn, 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, testOrderAlpn, 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 alpnAuthzCollection = await testClient.getAuthorizations(testOrderAlpn);
+                const wildcardAuthzCollection = await testClient.getAuthorizations(testOrderWildcard);
+
+                [orderAuthzCollection, alpnAuthzCollection, wildcardAuthzCollection].forEach((collection) => {
+                    assert.isArray(collection);
+                    assert.isNotEmpty(collection);
+
+                    collection.forEach((authz) => {
+                        spec.rfc8555.authorization(authz);
+                        assert.strictEqual(authz.status, 'pending');
+                    });
+                });
+
+                testAuthz = orderAuthzCollection.pop();
+                testAuthzAlpn = alpnAuthzCollection.pop();
+                testAuthzWildcard = wildcardAuthzCollection.pop();
+
+                testAuthz.challenges.concat(testAuthzAlpn.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'));
+                testChallengeAlpn = testAuthzAlpn.challenges.find((c) => (c.type === 'tls-alpn-01'));
+                testChallengeWildcard = testAuthzWildcard.challenges.find((c) => (c.type === 'dns-01'));
+
+                testKeyAuthorization = await testClient.getChallengeKeyAuthorization(testChallenge);
+                testKeyAuthorizationAlpn = await testClient.getChallengeKeyAuthorization(testChallengeAlpn);
+                testKeyAuthorizationWildcard = await testClient.getChallengeKeyAuthorization(testChallengeWildcard);
+
+                [testKeyAuthorization, testKeyAuthorizationAlpn, 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.assertTlsAlpnChallengeCreateFn(testAuthzAlpn, testChallengeAlpn, testKeyAuthorizationAlpn);
+                await cts.assertDnsChallengeCreateFn(testAuthzWildcard, testChallengeWildcard, testKeyAuthorizationWildcard);
+
+                await testClient.verifyChallenge(testAuthz, testChallenge);
+                await testClient.verifyChallenge(testAuthzAlpn, testChallengeAlpn);
+                await testClient.verifyChallenge(testAuthzWildcard, testChallengeWildcard);
+            });
+
+
+            /**
+             * Complete challenge
+             */
+
+            it('should complete challenge', async () => {
+                await Promise.all([testChallenge, testChallengeAlpn, 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, testChallengeAlpn, testChallengeWildcard].map(async (c) => testClient.waitForValidStatus(c)));
+            });
+
+
+            /**
+             * Finalize order
+             */
+
+            it('should finalize order', async () => {
+                const finalize = await testClient.finalizeOrder(testOrder, testCsr);
+                const finalizeAlpn = await testClient.finalizeOrder(testOrderAlpn, testCsrAlpn);
+                const finalizeWildcard = await testClient.finalizeOrder(testOrderWildcard, testCsrWildcard);
+
+                [finalize, finalizeAlpn, finalizeWildcard].forEach((f) => spec.rfc8555.order(f));
+
+                assert.strictEqual(testOrder.url, finalize.url);
+                assert.strictEqual(testOrderAlpn.url, finalizeAlpn.url);
+                assert.strictEqual(testOrderWildcard.url, finalizeWildcard.url);
+            });
+
+
+            /**
+             * Wait for valid order
+             */
+
+            it('should wait for valid order status', async () => {
+                await Promise.all([testOrder, testOrderAlpn, testOrderWildcard].map(async (o) => testClient.waitForValidStatus(o)));
+            });
+
+
+            /**
+             * Get certificate
+             */
+
+            it('should get certificate', async () => {
+                testCertificate = await testClient.getCertificate(testOrder);
+                testCertificateAlpn = await testClient.getCertificate(testOrderAlpn);
+                testCertificateWildcard = await testClient.getCertificate(testOrderWildcard);
+
+                [testCertificate, testCertificateAlpn, 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(testCertificateAlpn, { reason: 0 });
+                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(testOrderAlpn));
+                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));
+            });
+        });
+    });
+});

packages/core/acme-client/test/70-auto.spec.js

@@ -0,0 +1,449 @@
+/**
+ * ACME client.auto tests
+ */
+
+const { randomUUID: uuid } = require('crypto');
+const { assert } = require('chai');
+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 testHttpsDomain = `${uuid()}.${domainName}`;
+    const testDnsDomain = `${uuid()}.${domainName}`;
+    const testAlpnDomain = `${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);
+            });
+
+            it('should settle all challenges before rejecting', async () => {
+                const results = [];
+                const [, csr] = await acme.crypto.createCsr({
+                    commonName: `${uuid()}.${domainName}`,
+                    altNames: [
+                        `${uuid()}.${domainName}`,
+                        `${uuid()}.${domainName}`,
+                        `${uuid()}.${domainName}`,
+                        `${uuid()}.${domainName}`
+                    ]
+                }, await createKeyFn());
+
+                await assert.isRejected(testClient.auto({
+                    csr,
+                    termsOfServiceAgreed: true,
+                    challengeCreateFn: async (...args) => {
+                        if ([0, 1, 2].includes(results.length)) {
+                            results.push(false);
+                            throw new Error('oops');
+                        }
+
+                        await new Promise((resolve) => { setTimeout(resolve, 500); });
+                        results.push(true);
+                        return cts.challengeCreateFn(...args);
+                    },
+                    challengeRemoveFn: cts.challengeRemoveFn
+                }));
+
+                assert.strictEqual(results.length, 5);
+                assert.deepStrictEqual(results, [false, false, false, true, true]);
+            });
+
+
+            /**
+             * 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 https-01', async () => {
+                const [, csr] = await acme.crypto.createCsr({
+                    commonName: testHttpsDomain
+                }, await createKeyFn());
+
+                const cert = await testClient.auto({
+                    csr,
+                    termsOfServiceAgreed: true,
+                    challengeCreateFn: cts.assertHttpsChallengeCreateFn,
+                    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 certificate using tls-alpn-01', async () => {
+                const [, csr] = await acme.crypto.createCsr({
+                    commonName: testAlpnDomain
+                }, await createKeyFn());
+
+                const cert = await testClient.auto({
+                    csr,
+                    termsOfServiceAgreed: true,
+                    challengeCreateFn: cts.assertTlsAlpnChallengeCreateFn,
+                    challengeRemoveFn: cts.challengeRemoveFn,
+                    challengePriority: ['tls-alpn-01']
+                });
+
+                assert.isString(cert);
+            });
+
+            it('should order san certificate', async () => {
+                const [, csr] = await acme.crypto.createCsr({
+                    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}`]);
+            });
+        });
+    });
+});

packages/core/acme-client/test/challtestsrv.js

@@ -0,0 +1,124 @@
+/**
+ * Pebble Challenge Test Server integration
+ */
+
+const { assert } = require('chai');
+const axios = require('./../src/axios');
+
+const apiBaseUrl = process.env.ACME_CHALLTESTSRV_URL || null;
+const httpsPort = axios.defaults.acmeSettings.httpsChallengePort || 443;
+
+
+/**
+ * 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 addHttps01ChallengeResponse(token, content, targetHostname) {
+    await addHttp01ChallengeResponse(token, content);
+    return request('add-redirect', {
+        path: `/.well-known/acme-challenge/${token}`,
+        targetURL: `https://${targetHostname}:${httpsPort}/.well-known/acme-challenge/${token}`
+    });
+}
+
+async function addDns01ChallengeResponse(host, value) {
+    return request('set-txt', { host, value });
+}
+
+async function addTlsAlpn01ChallengeResponse(host, content) {
+    return request('add-tlsalpn01', { host, content });
+}
+
+exports.addHttp01ChallengeResponse = addHttp01ChallengeResponse;
+exports.addHttps01ChallengeResponse = addHttps01ChallengeResponse;
+exports.addDns01ChallengeResponse = addDns01ChallengeResponse;
+exports.addTlsAlpn01ChallengeResponse = addTlsAlpn01ChallengeResponse;
+
+
+/**
+ * Challenge response mock functions
+ */
+
+async function assertHttpChallengeCreateFn(authz, challenge, keyAuthorization) {
+    assert.strictEqual(challenge.type, 'http-01');
+    return addHttp01ChallengeResponse(challenge.token, keyAuthorization);
+}
+
+async function assertHttpsChallengeCreateFn(authz, challenge, keyAuthorization) {
+    assert.strictEqual(challenge.type, 'http-01');
+    return addHttps01ChallengeResponse(challenge.token, keyAuthorization, authz.identifier.value);
+}
+
+async function assertDnsChallengeCreateFn(authz, challenge, keyAuthorization) {
+    assert.strictEqual(challenge.type, 'dns-01');
+    return addDns01ChallengeResponse(`_acme-challenge.${authz.identifier.value}.`, keyAuthorization);
+}
+
+async function assertTlsAlpnChallengeCreateFn(authz, challenge, keyAuthorization) {
+    assert.strictEqual(challenge.type, 'tls-alpn-01');
+    return addTlsAlpn01ChallengeResponse(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);
+    }
+
+    if (challenge.type === 'tls-alpn-01') {
+        return assertTlsAlpnChallengeCreateFn(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.assertHttpsChallengeCreateFn = assertHttpsChallengeCreateFn;
+exports.assertDnsChallengeCreateFn = assertDnsChallengeCreateFn;
+exports.assertTlsAlpnChallengeCreateFn = assertTlsAlpnChallengeCreateFn;
+exports.challengeCreateFn = challengeCreateFn;