From 904cf09788c5572869f7b8f3a6a1ee431af8de1a Mon Sep 17 00:00:00 2001 From: PhilKunz Date: Tue, 1 Nov 2016 18:27:57 +0100 Subject: [PATCH] first version --- .gitignore | 4 + .gitlab-ci.yml | 59 ++ LICENSE | 20 + dist/index.d.ts | 1 + dist/index.js | 6 + dist/smartacme.classes.acmeclient.d.ts | 195 ++++++ dist/smartacme.classes.acmeclient.js | 903 ++++++++++++++++++++++++ dist/smartacme.classes.jwebclient.d.ts | 61 ++ dist/smartacme.classes.jwebclient.js | 283 ++++++++ dist/smartacme.classes.smartacme.d.ts | 5 + dist/smartacme.classes.smartacme.js | 9 + dist/smartacme.plugins.d.ts | 3 + dist/smartacme.plugins.js | 5 + package.json | 38 + test/test.d.ts | 1 + test/test.js | 7 + test/test.ts | 10 + ts/index.ts | 1 + ts/smartacme.classes.acmeclient.ts | 923 +++++++++++++++++++++++++ ts/smartacme.classes.jwebclient.ts | 294 ++++++++ ts/smartacme.classes.smartacme.ts | 9 + ts/smartacme.plugins.ts | 6 + tslint.json | 3 + 23 files changed, 2846 insertions(+) create mode 100644 .gitignore create mode 100644 .gitlab-ci.yml create mode 100644 LICENSE create mode 100644 dist/index.d.ts create mode 100644 dist/index.js create mode 100644 dist/smartacme.classes.acmeclient.d.ts create mode 100644 dist/smartacme.classes.acmeclient.js create mode 100644 dist/smartacme.classes.jwebclient.d.ts create mode 100644 dist/smartacme.classes.jwebclient.js create mode 100644 dist/smartacme.classes.smartacme.d.ts create mode 100644 dist/smartacme.classes.smartacme.js create mode 100644 dist/smartacme.plugins.d.ts create mode 100644 dist/smartacme.plugins.js create mode 100644 package.json create mode 100644 test/test.d.ts create mode 100644 test/test.js create mode 100644 test/test.ts create mode 100644 ts/index.ts create mode 100644 ts/smartacme.classes.acmeclient.ts create mode 100644 ts/smartacme.classes.jwebclient.ts create mode 100644 ts/smartacme.classes.smartacme.ts create mode 100644 ts/smartacme.plugins.ts create mode 100644 tslint.json diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3f93687 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +node_modules/ +coverage/ +public/ +pages/ diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 0000000..05f1805 --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,59 @@ +image: hosttoday/ht-docker-node:npmts + +stages: +- test +- release +- trigger +- pages + +testLEGACY: + stage: test + script: + - npmci test legacy + tags: + - docker + allow_failure: true + +testLTS: + stage: test + script: + - npmci test lts + tags: + - docker + +testSTABLE: + stage: test + script: + - npmci test stable + tags: + - docker + +release: + stage: release + script: + - npmci publish + only: + - tags + tags: + - docker + +trigger: + stage: trigger + script: + - npmci trigger + only: + - tags + tags: + - docker + +pages: + image: hosttoday/ht-docker-node:npmpage + stage: pages + script: + - npmci command npmpage --host gitlab + only: + - tags + artifacts: + expire_in: 1 week + paths: + - public \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..86a2642 --- /dev/null +++ b/LICENSE @@ -0,0 +1,20 @@ +Copyright (C) 2016, Lossless GmbH +Copyright (C) 2016, Martin Springwald + +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. \ No newline at end of file diff --git a/dist/index.d.ts b/dist/index.d.ts new file mode 100644 index 0000000..7c69782 --- /dev/null +++ b/dist/index.d.ts @@ -0,0 +1 @@ +export * from './smartacme.classes.smartacme'; diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..112a28c --- /dev/null +++ b/dist/index.js @@ -0,0 +1,6 @@ +"use strict"; +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +__export(require("./smartacme.classes.smartacme")); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsbURBQTZDIn0= \ No newline at end of file diff --git a/dist/smartacme.classes.acmeclient.d.ts b/dist/smartacme.classes.acmeclient.d.ts new file mode 100644 index 0000000..973cc01 --- /dev/null +++ b/dist/smartacme.classes.acmeclient.d.ts @@ -0,0 +1,195 @@ +/** + * @class AcmeClient + * @constructor + * @description ACME protocol implementation from client perspective + * @param {string} directory_url - Address of directory + * @param {module:JWebClient~JWebClient} jWebClient - Reference to JSON-Web-Client + */ +export declare class AcmeClient { + clientProfilePubKey: any; + days_valid: number; + defaultRsaKeySize: number; + directory: any; + directoryUrl: string; + emailDefaultPrefix: string; + emailOverride: string; + jWebClient: any; + regLink: string; + tosLink: string; + webroot: string; + well_known_path: string; + withInteraction: boolean; + constructor(directoryUrlArg: any); + /** + * getDirectory + * @description retrieve directory entries (directory url must be set prior to execution) + * @param {function} callback - first argument will be the answer object + */ + getDirectory(callback: any): void; + /** + * newRegistration + * @description try to register (directory lookup must have occured prior to execution) + * @param {Object} payload + * @param {function} callback - first argument will be the answer object + */ + newRegistration(payload: any, callback: any): void; + /** + * getRegistration + * @description get information about registration + * @param {string} uri - will be exposed when trying to register + * @param {Object} payload - update information + * @param {function} callback - first argument will be the answer object + */ + getRegistration(uri: any, payload: any, callback: any): void; + /** + * authorizeDomain + * @description authorize domain using challenge-response-method + * @param {string} domain + * @param {function} callback - first argument will be the answer object + */ + authorizeDomain(domain: any, callback: any): void; + /** + * acceptChallenge + * @description tell server which challenge will be accepted + * @param {Object} challenge + * @param {function} callback - first argument will be the answer object + */ + acceptChallenge(challenge: any, callback: any): void; + /** + * pollUntilValid + * @description periodically (with exponential back-off) check status of challenge + * @param {string} uri + * @param {function} callback - first argument will be the answer object + * @param {number} retry - factor of delay + */ + pollUntilValid(uri: any, callback: any, retry?: number): void; + /** + * pollUntilIssued + * @description periodically (with exponential back-off) check status of CSR + * @param {string} uri + * @param {function} callback - first argument will be the answer object + * @param {number} retry - factor of delay + */ + pollUntilIssued(uri: any, callback: any, retry?: number): void; + /** + * requestSigning + * @description send CSR + * @param {string} domain - expected to be already sanitized + * @param {function} callback - first argument will be the answer object + */ + requestSigning(domain: any, callback: any): void; + /** + * getProfile + * @description retrieve profile of user (will make directory lookup and registration check) + * @param {function} callback - first argument will be the answer object + */ + getProfile(callback: any): void; + /** + * createAccount + * @description create new account (assumes directory lookup has already occured) + * @param {string} email + * @param {function} callback - first argument will be the registration URI + */ + createAccount(email: any, callback: any): void; + /** + * agreeTos + * @description agree with terms of service (update agreement status in profile) + * @param {string} tosLink + * @param {function} callback - first argument will be the answer object + */ + agreeTos(tosLink: any, callback: any): void; + /** + * Entry-Point: Request certificate + * @param {string} domain + * @param {string} organization + * @param {string} country + * @param {function} callback + */ + requestCertificate(domain: any, organization: any, country: any, callback: any): void; + /** + * External: Create key pair + * @param {number} bit - key strength, expected to be already sanitized + * @param {string} c - country code, expected to be already sanitized + * @param {string} o - organization, expected to be already sanitized + * @param {string} cn - common name (domain name), expected to be already sanitized + * @param {string} e - email address, expected to be already sanitized + * @param {function} callback + */ + createKeyPair(bit: any, c: any, o: any, cn: any, e: any, callback: any): void; + /** + * Helper: Empty callback + */ + emptyCallback(): void; + /** + * Helper: Make safe file name or path from string + * @param {string} name + * @param {boolean} withPath - optional, default false + * @return {string} + */ + makeSafeFileName(name: any, withPath?: boolean): any; + /** + * Helper: Prepare challenge + * @param {string} domain + * @param {Object} challenge + * @param {function} callback + */ + prepareChallenge(domain: any, challenge: any, callback: any): void; + /** + * Helper: Extract TOS Link, e.g. from "<http://...>;rel="terms-of-service" + * @param {string} linkStr + * @return {string} + */ + getTosLink(linkStr: any): string; + /** + * Helper: Select challenge by type + * @param {Object} ans + * @param {string} challenge_type + * @return {Object} + */ + selectChallenge(ans: any, challengeType: string): any; + /** + * Helper: Extract first found email from profile (without mailto prefix) + * @param {Object} profile + * @return {string} + */ + extractEmail(profile: any): string; + /** + * Make ACME-Request: Domain-Authorization Request - Object: resource, identifier + * @param {string} domain + * @return {{resource: string, identifier: Object}} + */ + makeDomainAuthorizationRequest(domain: any): { + 'resource': string; + 'identifier': { + 'type': string; + 'value': any; + }; + }; + /** + * Make ACME-Object: Key-Authorization (encoded) - String: Challenge-Token . Encoded-Account-Key-Hash + * @param {Object} challenge + * @return {string} + */ + makeKeyAuthorization(challenge: any): string; + /** + * Make ACME-Request: Challenge-Response - Object: resource, keyAuthorization + * @param {Object} challenge + * @return {{resource: string, keyAuthorization: string}} + */ + makeChallengeResponse(challenge: any): { + 'resource': string; + 'keyAuthorization': string; + }; + /** + * Make ACME-Request: CSR - Object: resource, csr, notBefore, notAfter + * @param {string} csr + * @param {number} days_valid + * @return {{resource: string, csr: string, notBefore: string, notAfter: string}} + */ + makeCertRequest(csr: any, DAYS_VALID: number): { + 'resource': string; + 'csr': string; + 'notBefore': string; + 'notAfter': string; + }; +} diff --git a/dist/smartacme.classes.acmeclient.js b/dist/smartacme.classes.acmeclient.js new file mode 100644 index 0000000..f2e2ddf --- /dev/null +++ b/dist/smartacme.classes.acmeclient.js @@ -0,0 +1,903 @@ +"use strict"; +const base64url = require("base64url"); +const child_process = require("child_process"); +const crypto = require("crypto"); +const fs = require("fs"); +const readline = require("readline"); +const smartacme_classes_jwebclient_1 = require("./smartacme.classes.jwebclient"); +/** + * json_to_utf8buffer + * @private + * @description convert JSON to Buffer using UTF-8 encoding + * @param {Object} obj + * @return {Buffer} + * @throws Exception if object cannot be stringified or contains cycle + */ +let json_to_utf8buffer = function (obj) { + return new Buffer(JSON.stringify(obj), 'utf8'); +}; +/** + * @class AcmeClient + * @constructor + * @description ACME protocol implementation from client perspective + * @param {string} directory_url - Address of directory + * @param {module:JWebClient~JWebClient} jWebClient - Reference to JSON-Web-Client + */ +class AcmeClient { + constructor(directoryUrlArg) { + /** + * @member {Object} module:AcmeClient~AcmeClient#clientProfilePubKey + * @desc Cached public key obtained from profile + */ + this.clientProfilePubKey = {}; + /** + * @member {number} module:AcmeClient~AcmeClient#days_valid + * @desc Validity period in days + * @default 1 + */ + this.days_valid = 1; + /** + * @member {number} module:AcmeClient~AcmeClient#defaultRsaKeySize + * @desc Key strength in bits + * @default 4096 + */ + this.defaultRsaKeySize = 4096; + /** + * @member {Object} module:AcmeClient~AcmeClient#directory + * @desc Hash map of REST URIs + */ + this.directory = {}; + /** + * @member {string} module:AcmeClient~AcmeClient#directory_url + * @desc Address of directory + */ + this.directoryUrl = directoryUrlArg; + /** + * @member {string} module:AcmeClient~AcmeClient#emailDefaultPrefix + * @desc Prefix of email address if constructed from domain name + * @default "hostmaster" + */ + this.emailDefaultPrefix = 'hostmaster'; // {string} + /** + * @member {string} module:AcmeClient~AcmeClient#emailOverride + * @desc Email address to use + */ + this.emailOverride = null; // {string} + /** + * @member {module:JWebClient~JWebClient} module:AcmeClient~AcmeClient#jWebClient + * @desc Reference to JSON-Web-Client + */ + this.jWebClient = new smartacme_classes_jwebclient_1.JWebClient(); // {JWebClient} + /** + * @member {string} module:AcmeClient~AcmeClient#regLink + * @desc Cached registration URI + */ + this.regLink = null; // {string} + /** + * @member {string} module:AcmeClient~AcmeClient#tosLink + * @desc Cached terms of service URI + */ + this.tosLink = null; // {string} + /** + * @member {string} module:AcmeClient~AcmeClient#webroot + * @desc Path to server web root (or path to store challenge data) + * @default "." + */ + this.webroot = '.'; // {string} + /** + * @member {string} module:AcmeClient~AcmeClient#well_known_path + * @desc Directory structure for challenge data + * @default "/.well-known/acme-challenge/" + */ + this.well_known_path = '/.well-known/acme-challenge/'; // {string} + /** + * @member {boolean} module:AcmeClient~AcmeClient#withInteraction + * @desc Determines if interaction of user is required + * @default true + */ + this.withInteraction = true; // {boolean} + } + // ***************************************************************************** + // REQUEST-Section + // ***************************************************************************** + /** + * getDirectory + * @description retrieve directory entries (directory url must be set prior to execution) + * @param {function} callback - first argument will be the answer object + */ + getDirectory(callback) { + this.jWebClient.get(this.directoryUrl, callback, callback); + // dereference + callback = null; + } + /** + * newRegistration + * @description try to register (directory lookup must have occured prior to execution) + * @param {Object} payload + * @param {function} callback - first argument will be the answer object + */ + newRegistration(payload, callback) { + if (!(payload instanceof Object)) { + payload = {}; // ensure payload is object + } + payload.resource = 'new-reg'; + this.jWebClient.post(this.directory['new-reg'], payload, callback, callback); + // dereference + callback = null; + payload = null; + } + /** + * getRegistration + * @description get information about registration + * @param {string} uri - will be exposed when trying to register + * @param {Object} payload - update information + * @param {function} callback - first argument will be the answer object + */ + getRegistration(uri, payload, callback) { + /*jshint -W069 */ + let ctx = this; + if (!(payload instanceof Object)) { + payload = {}; // ensure payload is object + } + payload['resource'] = 'reg'; + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + this.jWebClient.post(uri, payload, function (ans, res) { + if (ans instanceof Object) { + ctx.clientProfilePubKey = ans.key; // cache or reset returned public key + if ((res instanceof Object) && (res['headers'] instanceof Object)) { + let linkStr = res.headers['link']; + if (typeof linkStr === 'string') { + let tosLink = ctx.getTosLink(linkStr); + if (typeof tosLink === 'string') { + ctx.tosLink = tosLink; // cache TOS link + } + else { + ctx.tosLink = null; // reset TOS link + } + } + else { + ctx.tosLink = null; // reset TOS link + } + } + else { + ctx.tosLink = null; // reset TOS link + } + callback(ans, res); + } + else { + callback(false); + } + // dereference + ans = null; + callback = null; + ctx = null; + res = null; + }); + // dereference + payload = null; + } + /** + * authorizeDomain + * @description authorize domain using challenge-response-method + * @param {string} domain + * @param {function} callback - first argument will be the answer object + */ + authorizeDomain(domain, callback) { + /*jshint -W069 */ + let ctx = this; + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + this.getProfile(function (profile) { + if (!(profile instanceof Object)) { + callback(false); // no profile returned + // dereference + callback = null; + ctx = null; + } + else { + ctx.jWebClient.post(ctx.directory['new-authz'], ctx.makeDomainAuthorizationRequest(domain), function (ans, res) { + if ((res instanceof Object) && (res['statusCode'] === 403)) { + ctx.agreeTos(ctx.tosLink, function (ans_, res_) { + if ((res_ instanceof Object) + && (res_['statusCode'] >= 200) + && (res_['statusCode'] <= 400)) { + ctx.authorizeDomain(domain, callback); // try authorization again + } + else { + callback(false); // agreement failed + } + // dereference + ans = null; + ans_ = null; + callback = null; + ctx = null; + profile = null; + res = null; + res_ = null; + }); + } + else { + if ((res instanceof Object) + && (res['headers'] instanceof Object) + && (typeof res.headers['location'] === 'string') + && (ans instanceof Object)) { + let poll_uri = res.headers['location']; // status URI for polling + let challenge = ctx.selectChallenge(ans, 'http-01'); // select simple http challenge + if (challenge instanceof Object) { + ctx.prepareChallenge(domain, challenge, function () { + // reset + ans = null; + res = null; + // accept challenge + ctx.acceptChallenge(challenge, function (ans, res) { + if ((res instanceof Object) + && (res['statusCode'] < 400) // server confirms challenge acceptance + ) { + ctx.pollUntilValid(poll_uri, callback); // poll status until server states success + } + else { + callback(false); // server did not confirm challenge acceptance + } + // dereference + ans = null; + callback = null; + challenge = null; + ctx = null; + profile = null; + res = null; + }); + }); + } + else { + callback(false); // desired challenge is not in list + // dereference + ans = null; + callback = null; + ctx = null; + profile = null; + res = null; + } + } + else { + callback(false); // server did not respond with status URI + // dereference + ans = null; + callback = null; + ctx = null; + profile = null; + res = null; + } + } + }); + } + }); + } + /** + * acceptChallenge + * @description tell server which challenge will be accepted + * @param {Object} challenge + * @param {function} callback - first argument will be the answer object + */ + acceptChallenge(challenge, callback) { + /*jshint -W069 */ + if (!(challenge instanceof Object)) { + challenge = {}; // ensure challenge is object + } + this.jWebClient.post(challenge['uri'], this.makeChallengeResponse(challenge), callback); + // dereference + callback = null; + challenge = null; + } + /** + * pollUntilValid + * @description periodically (with exponential back-off) check status of challenge + * @param {string} uri + * @param {function} callback - first argument will be the answer object + * @param {number} retry - factor of delay + */ + pollUntilValid(uri, callback, retry = 1) { + /*jshint -W069 */ + let ctx = this; + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + if (retry > 128) { + callback(false); // stop if retry value exceeds maximum + } + else { + this.jWebClient.get(uri, function (ans, res) { + if (!(ans instanceof Object)) { + callback(false); // invalid answer + // dereference + callback = null; + ctx = null; + res = null; + } + else { + if (ans['status'] === 'pending') { + setTimeout(function () { + ctx.pollUntilValid(uri, callback, retry * 2); // retry + // dereference + ans = null; + callback = null; + ctx = null; + res = null; + }, retry * 500); + } + else { + callback(ans, res); // challenge complete + // dereference + ans = null; + callback = null; + ctx = null; + res = null; + } + } + }); + } + } + /** + * pollUntilIssued + * @description periodically (with exponential back-off) check status of CSR + * @param {string} uri + * @param {function} callback - first argument will be the answer object + * @param {number} retry - factor of delay + */ + pollUntilIssued(uri, callback, retry = 1) { + /*jshint -W069 */ + let ctx = this; + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + if (retry > 128) { + callback(false); // stop if retry value exceeds maximum + } + else { + this.jWebClient.get(uri, function (ans, res) { + if ((ans instanceof Buffer) && (ans.length > 0)) { + callback(ans); // certificate was returned with answer + // dereference + ans = null; + callback = null; + ctx = null; + res = null; + } + else { + if ((res instanceof Object) && (res['statusCode'] < 400)) { + setTimeout(function () { + ctx.pollUntilIssued(uri, callback, retry * 2); // retry + // dereference + ans = null; + callback = null; + ctx = null; + res = null; + }, retry * 500); + } + else { + callback(false); // CSR complete + // dereference + ans = null; + callback = null; + ctx = null; + res = null; + } + } + }); + } + } + /** + * requestSigning + * @description send CSR + * @param {string} domain - expected to be already sanitized + * @param {function} callback - first argument will be the answer object + */ + requestSigning(domain, callback) { + /*jshint -W069 */ + let ctx = this; + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + fs.readFile(domain + '.csr', function (err, csr) { + if (err instanceof Object) { + if (ctx.jWebClient.verbose) { + console.error('Error : File system error', err['code'], 'while reading key from file'); + } + callback(false); + // dereference + callback = null; + csr = null; + ctx = null; + err = null; + } + else { + ctx.jWebClient.post(ctx.directory['new-cert'], ctx.makeCertRequest(csr, ctx.days_valid), function (ans, res) { + if ((ans instanceof Buffer) && (ans.length > 0)) { + callback(ans); // certificate was returned with answer + // dereference + ans = null; + callback = null; + csr = null; + ctx = null; + err = null; + res = null; + } + else { + if (res instanceof Object) { + if ((res['statusCode'] < 400) && !ans) { + let headers = res['headers']; + if (!(headers instanceof Object)) { + headers = {}; // ensure headers is object + } + ctx.pollUntilIssued(headers['location'], callback); // poll provided status URI + // dereference + headers = null; + } + else { + callback((res['statusCode'] < 400) ? ans : false); // answer may be provided as string or object + } + } + else { + callback(false); // invalid response + } + // dereference + ans = null; + callback = null; + csr = null; + ctx = null; + err = null; + res = null; + } + }); + } + }); + } + /** + * getProfile + * @description retrieve profile of user (will make directory lookup and registration check) + * @param {function} callback - first argument will be the answer object + */ + getProfile(callback) { + /*jshint -W069 */ + let ctx = this; + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + this.getDirectory(function (dir) { + if (!(dir instanceof Object)) { + callback(false); // server did not respond with directory + // dereference + callback = null; + ctx = null; + } + else { + ctx.directory = dir; // cache directory + ctx.newRegistration(null, function (ans, res) { + if ((res instanceof Object) + && (res['headers'] instanceof Object) + && (typeof res.headers['location'] === 'string')) { + ctx.regLink = res.headers['location']; + ctx.getRegistration(ctx.regLink, null, callback); // get registration info from link + } + else { + callback(false); // registration failed + } + // dereference + ans = null; + callback = null; + ctx = null; + dir = null; + res = null; + }); + } + }); + } + /** + * createAccount + * @description create new account (assumes directory lookup has already occured) + * @param {string} email + * @param {function} callback - first argument will be the registration URI + */ + createAccount(email, callback) { + /*jshint -W069 */ + let ctx = this; + if (typeof email === 'string') { + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + ctx.newRegistration({ + contact: [ + 'mailto:' + email + ] + }, function (ans, res) { + if ((res instanceof Object) + && (res['statusCode'] === 201) + && (res['headers'] instanceof Object) + && (typeof res.headers['location'] === 'string')) { + ctx.regLink = res.headers['location']; + callback(ctx.regLink); // registration URI + } + else { + callback(false); // registration failed + } + // dereference + ans = null; + callback = null; + ctx = null; + res = null; + }); + } + else { + callback(false); // no email address provided + // dereference + callback = null; + ctx = null; + } + } + /** + * agreeTos + * @description agree with terms of service (update agreement status in profile) + * @param {string} tosLink + * @param {function} callback - first argument will be the answer object + */ + agreeTos(tosLink, callback) { + this.getRegistration(this.regLink, { + 'Agreement': tosLink // terms of service URI + }, callback); + // dereference + callback = null; + } + /** + * Entry-Point: Request certificate + * @param {string} domain + * @param {string} organization + * @param {string} country + * @param {function} callback + */ + requestCertificate(domain, organization, country, callback) { + /*jshint -W069 */ + let ctx = this; + if (typeof domain !== 'string') { + domain = ''; // ensure domain is string + } + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + this.getProfile(function (profile) { + let email = ctx.extractEmail(profile); // try to determine email address from profile + if (typeof ctx.emailOverride === 'string') { + email = ctx.emailOverride; // override email address if set + } + else if (typeof email !== 'string') { + email = ctx.emailDefaultPrefix + '@' + domain; // or set default + } + let bit = ctx.defaultRsaKeySize; + // sanitize + bit = Number(bit); + country = ctx.makeSafeFileName(country); + domain = ctx.makeSafeFileName(domain); + email = ctx.makeSafeFileName(email); + organization = ctx.makeSafeFileName(organization); + // create key pair + ctx.createKeyPair(bit, country, organization, domain, email, function (e) { + if (!e) { + ctx.requestSigning(domain, function (cert) { + if ((cert instanceof Buffer) || (typeof cert === 'string')) { + fs.writeFile(domain + '.der', cert, function (err) { + if (err instanceof Object) { + if (ctx.jWebClient.verbose) { + console.error('Error : File system error', err['code'], 'while writing certificate to file'); + } + callback(false); + } + else { + callback(true); // CSR complete and certificate written to file system + } + // dereference + callback = null; + cert = null; + ctx = null; + e = null; + err = null; + profile = null; + }); + } + else { + callback(false); // invalid certificate data + // dereference + callback = null; + cert = null; + ctx = null; + e = null; + profile = null; + } + }); + } + else { + callback(false); // could not create key pair + // dereference + callback = null; + ctx = null; + e = null; + profile = null; + } + }); + }); + } + /** + * External: Create key pair + * @param {number} bit - key strength, expected to be already sanitized + * @param {string} c - country code, expected to be already sanitized + * @param {string} o - organization, expected to be already sanitized + * @param {string} cn - common name (domain name), expected to be already sanitized + * @param {string} e - email address, expected to be already sanitized + * @param {function} callback + */ + createKeyPair(bit, c, o, cn, e, callback) { + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + let openssl = `openssl req -new -nodes -newkey rsa:${bit} -sha256 -subj "/C=${c}/O=${o}/CN=${cn}/emailAddress=${e}" -keyout \"${cn}.key\" -outform der -out \"${cn}.csr\"`; + console.error('Action : Creating key pair'); + if (this.jWebClient.verbose) { + console.error('Running:', openssl); + } + child_process.exec(openssl, function (e) { + if (!e) { + console.error('Result : done'); + } + else { + console.error('Result : failed'); + } + callback(e); + // dereference + callback = null; + e = null; + }); + } + /** + * Helper: Empty callback + */ + emptyCallback() { + // nop + } + /** + * Helper: Make safe file name or path from string + * @param {string} name + * @param {boolean} withPath - optional, default false + * @return {string} + */ + makeSafeFileName(name, withPath = false) { + if (typeof name !== 'string') { + name = ''; + } + // respects file name restrictions for ntfs and ext2 + let regex_file = '[<>:\"/\\\\\\|\\?\\*\\u0000-\\u001f\\u007f\\u0080-\\u009f]'; + let regex_path = '[<>:\"\\\\\\|\\?\\*\\u0000-\\u001f\\u007f\\u0080-\\u009f]'; + return name.replace(new RegExp(withPath ? regex_path : regex_file, 'g'), function (charToReplace) { + if (typeof charToReplace === 'string') { + return '%' + charToReplace.charCodeAt(0).toString(16).toLocaleUpperCase(); + } + return '%00'; + }); + } + /** + * Helper: Prepare challenge + * @param {string} domain + * @param {Object} challenge + * @param {function} callback + */ + prepareChallenge(domain, challenge, callback) { + /*jshint -W069, unused:false*/ + let ctx = this; + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + if (challenge instanceof Object) { + if (challenge['type'] === 'http-01') { + let path = this.webroot + this.well_known_path + challenge['token']; // webroot and well_known_path are expected to be already sanitized + fs.writeFile(path, this.makeKeyAuthorization(challenge), function (err) { + if (err instanceof Object) { + if (ctx.jWebClient.verbose) { + console.error('Error : File system error', err['code'], 'while writing challenge data to file'); + } + callback(); + // dereference + callback = null; + challenge = null; + ctx = null; + err = null; + } + else { + // let uri = "http://" + domain + this.well_known_path + challenge["token"] + let rl = readline.createInterface(process.stdin, process.stdout); + if (ctx.withInteraction) { + rl.question('Press enter to proceed', function (answer) { + rl.close(); + callback(); + // dereference + callback = null; + challenge = null; + ctx = null; + rl = null; + }); + } + else { + rl.close(); + callback(); // skip interaction prompt if desired + // dereference + callback = null; + challenge = null; + ctx = null; + rl = null; + } + } + }); + } + else { + console.error('Error : Challenge not supported'); + callback(); + // dereference + callback = null; + challenge = null; + ctx = null; + } + } + else { + console.error('Error : Invalid challenge response'); + callback(); + // dereference + callback = null; + challenge = null; + ctx = null; + } + } + /** + * Helper: Extract TOS Link, e.g. from "<http://...>;rel="terms-of-service" + * @param {string} linkStr + * @return {string} + */ + getTosLink(linkStr) { + let match = /(<)([^>]+)(>;rel="terms-of-service")/g.exec(linkStr); + if ((match instanceof Array) && (match.length > 2)) { + let result = match[2]; + // dereference + match = null; + return result; + } + // dereference + match = null; + return void 0; + } + /** + * Helper: Select challenge by type + * @param {Object} ans + * @param {string} challenge_type + * @return {Object} + */ + selectChallenge(ans, challengeType) { + /*jshint -W069 */ + if ((ans instanceof Object) && (ans['challenges'] instanceof Array)) { + return ans.challenges.filter(function (entry) { + let type = entry['type']; + // dereference + entry = null; + if (type === challengeType) { + return true; + } + return false; + }).pop(); + } // return first match or undefined + // dereference + ans = null; + return void 0; // challenges not available or in expected format + } + /** + * Helper: Extract first found email from profile (without mailto prefix) + * @param {Object} profile + * @return {string} + */ + extractEmail(profile) { + /*jshint -W069 */ + if (!(profile instanceof Object) || !(profile['contact'] instanceof Array)) { + // dereference + profile = null; + return void 0; // invalid profile + } + let prefix = 'mailto:'; + let email = profile.contact.filter(function (entry) { + if (typeof entry !== 'string') { + return false; + } + else { + return !entry.indexOf(prefix); // check for mail prefix + } + }).pop(); + // dereference + profile = null; + if (typeof email !== 'string') { + return void 0; + } // return default + return email.substr(prefix.length); // only return email address without protocol prefix + } + /** + * Make ACME-Request: Domain-Authorization Request - Object: resource, identifier + * @param {string} domain + * @return {{resource: string, identifier: Object}} + */ + makeDomainAuthorizationRequest(domain) { + return { + 'resource': 'new-authz', + 'identifier': { + 'type': 'dns', + 'value': domain + } + }; + } + /** + * Make ACME-Object: Key-Authorization (encoded) - String: Challenge-Token . Encoded-Account-Key-Hash + * @param {Object} challenge + * @return {string} + */ + makeKeyAuthorization(challenge) { + /*jshint -W069 */ + if (challenge instanceof Object) { + if (this.clientProfilePubKey instanceof Object) { + let jwk = json_to_utf8buffer({ + e: this.clientProfilePubKey['e'], + kty: this.clientProfilePubKey['kty'], + n: this.clientProfilePubKey['n'] + }); + let hash = crypto.createHash('sha256').update(jwk.toString('utf8'), 'utf8').digest(); + let ACCOUNT_KEY = base64url.default.encode(hash); // create base64 encoded hash of account key + let token = challenge['token']; + // dereference + challenge = null; + jwk = null; + return token + '.' + ACCOUNT_KEY; + } + } + else { + return ''; // return default (for writing to file) + } + } + /** + * Make ACME-Request: Challenge-Response - Object: resource, keyAuthorization + * @param {Object} challenge + * @return {{resource: string, keyAuthorization: string}} + */ + makeChallengeResponse(challenge) { + return { + 'resource': 'challenge', + 'keyAuthorization': this.makeKeyAuthorization(challenge) + }; + } + /** + * Make ACME-Request: CSR - Object: resource, csr, notBefore, notAfter + * @param {string} csr + * @param {number} days_valid + * @return {{resource: string, csr: string, notBefore: string, notAfter: string}} + */ + makeCertRequest(csr, DAYS_VALID) { + if (typeof csr !== 'string' && !(csr instanceof Buffer)) { + csr = ''; // default string for CSR + } + if ((typeof DAYS_VALID !== 'number') || (isNaN(DAYS_VALID)) || (DAYS_VALID === 0)) { + DAYS_VALID = 1; // default validity duration (1 day) + } + let DOMAIN_CSR_DER = base64url.default.encode(csr); // create base64 encoded CSR + let CURRENT_DATE = (new Date()).toISOString(); // set start date to current date + // set end date to current date + days_valid + let NOTAFTER_DATE = (new Date((+new Date()) + 1000 * 60 * 60 * 24 * Math.abs(DAYS_VALID))).toISOString(); + return { + 'resource': 'new-cert', + 'csr': DOMAIN_CSR_DER, + 'notBefore': CURRENT_DATE, + 'notAfter': NOTAFTER_DATE + }; + } +} +exports.AcmeClient = AcmeClient; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartacme.classes.acmeclient.js","sourceRoot":"","sources":["../ts/smartacme.classes.acmeclient.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/dist/smartacme.classes.jwebclient.d.ts b/dist/smartacme.classes.jwebclient.d.ts new file mode 100644 index 0000000..ad0360a --- /dev/null +++ b/dist/smartacme.classes.jwebclient.d.ts @@ -0,0 +1,61 @@ +/** + * @class JWebClient + * @constructor + * @description Implementation of HTTPS-based JSON-Web-Client + */ +export declare class JWebClient { + key_pair: any; + last_nonce: string; + verbose: boolean; + constructor(); + /** + * createJWT + * @description create JSON-Web-Token signed object + * @param {string|undefined} nonce + * @param {Object|string|number|boolean} payload + * @param {string} alg + * @param {Object|string} key + * @param {Object} jwk + * @return {string} + */ + createJWT(nonce: any, payload: any, alg: any, key: any, jwk: any): string; + /** + * request + * @description make GET or POST request over HTTPS and use JOSE as payload type + * @param {string} query + * @param {string} payload + * @param {function} callback + * @param {function} errorCallback + */ + request(query: any, payload: any, callback: any, errorCallback: any): void; + /** + * get + * @description make GET request + * @param {string} uri + * @param {function} callback + * @param {function} errorCallback + */ + get(uri: any, callback: any, errorCallback: any): void; + /** + * post + * @description make POST request + * @param {string} uri + * @param {Object|string|number|boolean} payload + * @param {function} callback + * @param {function} errorCallback + */ + post(uri: any, payload: any, callback: any, errorCallback: any): void; + /** + * evaluateStatus + * @description check if status is expected and log errors + * @param {string} uri + * @param {Object|string|number|boolean} payload + * @param {Object|string} ans + * @param {Object} res + */ + evaluateStatus(uri: any, payload: any, ans: any, res: any): void; + /** + * Helper: Empty callback + */ + emptyCallback(): void; +} diff --git a/dist/smartacme.classes.jwebclient.js b/dist/smartacme.classes.jwebclient.js new file mode 100644 index 0000000..fb5d757 --- /dev/null +++ b/dist/smartacme.classes.jwebclient.js @@ -0,0 +1,283 @@ +"use strict"; +const base64url = require("base64url"); +const https = require("https"); +let jwa = require('jwa'); +const url = require("url"); +/** + * json_to_utf8base64url + * @private + * @description convert JSON to base64-url encoded string using UTF-8 encoding + * @param {Object} obj + * @return {string} + * @throws Exception if object cannot be stringified or contains cycle + */ +let json_to_utf8base64url = function (obj) { + return base64url.default.encode(new Buffer(JSON.stringify(obj), 'utf8')); +}; +/** + * @class JWebClient + * @constructor + * @description Implementation of HTTPS-based JSON-Web-Client + */ +class JWebClient { + constructor() { + /** + * @member {Object} module:JWebClient~JWebClient#key_pair + * @desc User account key pair + */ + this.key_pair = null; // {Object} + /** + * @member {string} module:JWebClient~JWebClient#last_nonce + * @desc Cached nonce returned with last request + */ + this.last_nonce = null; // {string} + /** + * @member {boolean} module:JWebClient~JWebClient#verbose + * @desc Determines verbose mode + */ + this.verbose = false; // {boolean} + } + /** + * createJWT + * @description create JSON-Web-Token signed object + * @param {string|undefined} nonce + * @param {Object|string|number|boolean} payload + * @param {string} alg + * @param {Object|string} key + * @param {Object} jwk + * @return {string} + */ + createJWT(nonce, payload, alg, key, jwk) { + /*jshint -W069 */ + // prepare key + if (key instanceof Object) { + key = base64url.default.toBuffer(key['k']); + } + // prepare header + let header = { + typ: 'JWT', + alg: alg, + jwk: jwk, + nonce: null + }; + if (nonce !== void 0) { + header.nonce = nonce; + } + // concatenate header and payload + let input = [ + json_to_utf8base64url(header), + json_to_utf8base64url(payload) + ].join('.'); + // sign input + let hmac = jwa(alg); + let sig = hmac.sign(input, key); + // concatenate input and signature + let output = [ + input, + sig + ].join('.'); + // dereference + header = null; + hmac = null; + input = null; + jwk = null; + key = null; + payload = null; + // output + return output; + } + /** + * request + * @description make GET or POST request over HTTPS and use JOSE as payload type + * @param {string} query + * @param {string} payload + * @param {function} callback + * @param {function} errorCallback + */ + request(query, payload, callback, errorCallback) { + /*jshint -W069 */ + if (typeof query !== 'string') { + query = ''; // ensure query is string + } + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + if (typeof errorCallback !== 'function') { + errorCallback = this.emptyCallback; // ensure callback is function + } + // prepare options + let uri = url.parse(query); + let options = { + hostname: uri.hostname, + port: parseInt(uri.port, 10), + path: uri.path, + method: null, + headers: {} + }; + if (typeof payload === 'string') { + options.method = 'POST'; + options.headers = { + 'Content-Type': 'application/jose', + 'Content-Length': payload.length + }; + } + else { + options.method = 'GET'; + } + // prepare request + let req = https.request(options, function (res) { + // receive data + let data = []; + res.on('data', function (block) { + if (block instanceof Buffer) { + data.push(block); + } + }); + res.on('end', function () { + let buf = Buffer.concat(data); + let isJSON = ((res instanceof Object) + && (res['headers'] instanceof Object) + && (typeof res.headers['content-type'] === 'string') + && (res.headers['content-type'].indexOf('json') > -1)); + if (isJSON && buf.length > 0) { + try { + // convert to JSON + let json = JSON.parse(buf.toString('utf8')); + callback(json, res); + } + catch (e) { + // error (if empty or invalid JSON) + errorCallback(void 0, e); + } + } + else { + callback(buf, res); + } + }); + }).on('error', function (e) { + console.error('Error occured', e); + // error + errorCallback(void 0, e); + }); + // write POST body if payload was specified + if (typeof payload === 'string') { + req.write(payload); + } + // make request + req.end(); + } + /** + * get + * @description make GET request + * @param {string} uri + * @param {function} callback + * @param {function} errorCallback + */ + get(uri, callback, errorCallback) { + /*jshint -W069 */ + let ctx = this; + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + this.request(uri, void 0, function (ans, res) { + ctx.evaluateStatus(uri, null, ans, res); + // save replay nonce for later requests + if ((res instanceof Object) && (res['headers'] instanceof Object)) { + ctx.last_nonce = res.headers['replay-nonce']; + } + callback(ans, res); + // dereference + ans = null; + callback = null; + ctx = null; + res = null; + }, errorCallback); + // dereference + errorCallback = null; + } + /** + * post + * @description make POST request + * @param {string} uri + * @param {Object|string|number|boolean} payload + * @param {function} callback + * @param {function} errorCallback + */ + post(uri, payload, callback, errorCallback) { + /*jshint -W069 */ + let ctx = this; + if (typeof callback !== 'function') { + callback = this.emptyCallback; // ensure callback is function + } + let key_pair = this.key_pair; + if (!(key_pair instanceof Object)) { + key_pair = {}; // ensure key pair is object + } + let jwt = this.createJWT(this.last_nonce, payload, 'RS256', key_pair['private_pem'], key_pair['public_jwk']); + this.request(uri, jwt, (ans, res) => { + ctx.evaluateStatus(uri, payload, ans, res); + // save replay nonce for later requests + if ((res instanceof Object) && (res['headers'] instanceof Object)) { + ctx.last_nonce = res.headers['replay-nonce']; + } + callback(ans, res); + // dereference + ans = null; + callback = null; + ctx = null; + key_pair = null; + payload = null; + res = null; + }, errorCallback); + // dereference + errorCallback = null; + } + /** + * evaluateStatus + * @description check if status is expected and log errors + * @param {string} uri + * @param {Object|string|number|boolean} payload + * @param {Object|string} ans + * @param {Object} res + */ + evaluateStatus(uri, payload, ans, res) { + /*jshint -W069 */ + if (this.verbose) { + if ((payload instanceof Object) + || (typeof payload === 'string') + || (typeof payload === 'number') + || (typeof payload === 'boolean')) { + console.error('Send :', payload); // what has been sent + } + } + let uri_parsed = url.parse(uri); + if (res['statusCode'] >= 100 && res['statusCode'] < 400) { + console.error('HTTP :', res['statusCode'], uri_parsed.path); // response code if successful + } + if (res['statusCode'] >= 400 && res['statusCode'] < 500) { + console.error('HTTP :', res['statusCode'], uri_parsed.path); // response code if error + if (ans instanceof Object) { + if (typeof ans['detail'] === 'string') { + console.error('Message:', ans.detail.split(' :: ').pop()); // error message if any + } + } + } + if (this.verbose) { + console.error('Receive:', res['headers']); // received headers + console.error('Receive:', ans); // received data + } + // dereference + ans = null; + payload = null; + res = null; + uri_parsed = null; + } + /** + * Helper: Empty callback + */ + emptyCallback() { + // nop + } +} +exports.JWebClient = JWebClient; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartacme.classes.jwebclient.js","sourceRoot":"","sources":["../ts/smartacme.classes.jwebclient.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/dist/smartacme.classes.smartacme.d.ts b/dist/smartacme.classes.smartacme.d.ts new file mode 100644 index 0000000..57d2931 --- /dev/null +++ b/dist/smartacme.classes.smartacme.d.ts @@ -0,0 +1,5 @@ +import * as acmeclient from './smartacme.classes.acmeclient'; +export declare class SmartAcme { + acmeClient: acmeclient.AcmeClient; + constructor(directoryUrlArg?: string); +} diff --git a/dist/smartacme.classes.smartacme.js b/dist/smartacme.classes.smartacme.js new file mode 100644 index 0000000..e6f9cbd --- /dev/null +++ b/dist/smartacme.classes.smartacme.js @@ -0,0 +1,9 @@ +"use strict"; +const acmeclient = require("./smartacme.classes.acmeclient"); +class SmartAcme { + constructor(directoryUrlArg = 'https://acme-staging.api.letsencrypt.org/directory') { + this.acmeClient = new acmeclient.AcmeClient(directoryUrlArg); + } +} +exports.SmartAcme = SmartAcme; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLmNsYXNzZXMuc21hcnRhY21lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRhY21lLmNsYXNzZXMuc21hcnRhY21lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFDQSw2REFBNEQ7QUFFNUQ7SUFFSSxZQUFZLGtCQUEwQixvREFBb0Q7UUFDdEYsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLFVBQVUsQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLENBQUE7SUFDaEUsQ0FBQztDQUNKO0FBTEQsOEJBS0MifQ== \ No newline at end of file diff --git a/dist/smartacme.plugins.d.ts b/dist/smartacme.plugins.d.ts new file mode 100644 index 0000000..8a7180f --- /dev/null +++ b/dist/smartacme.plugins.d.ts @@ -0,0 +1,3 @@ +import 'typings-global'; +import * as path from 'path'; +export { path }; diff --git a/dist/smartacme.plugins.js b/dist/smartacme.plugins.js new file mode 100644 index 0000000..1e65bb2 --- /dev/null +++ b/dist/smartacme.plugins.js @@ -0,0 +1,5 @@ +"use strict"; +require("typings-global"); +const path = require("path"); +exports.path = path; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGFjbWUucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBQ3ZCLDZCQUE0QjtBQUd4QixvQkFBSSJ9 \ No newline at end of file diff --git a/package.json b/package.json new file mode 100644 index 0000000..1427f7a --- /dev/null +++ b/package.json @@ -0,0 +1,38 @@ +{ + "name": "smartacme", + "version": "1.0.0", + "description": "acme implementation in TypeScript", + "main": "dist/index.js", + "typings": "dist/index.d.ts", + "scripts": { + "test": "(npmts --nodocs)" + }, + "repository": { + "type": "git", + "url": "git+ssh://git@gitlab.com/pushrocks/smartacme.git" + }, + "keywords": [ + "TypeScript", + "acme", + "letsencrypt" + ], + "author": "Lossless GmbH", + "license": "MIT", + "bugs": { + "url": "https://gitlab.com/pushrocks/smartacme/issues" + }, + "homepage": "https://gitlab.com/pushrocks/smartacme#README", + "dependencies": { + "@types/base64url": "^2.0.3", + "base64url": "^2.0.0", + "jwa": "^1.1.3", + "rsa-pem-to-jwk": "^1.1.3", + "smartstring": "^2.0.19", + "typings-global": "^1.0.14" + }, + "devDependencies": { + "@types/should": "^8.1.30", + "should": "^11.1.1", + "typings-test": "^1.0.3" + } +} diff --git a/test/test.d.ts b/test/test.d.ts new file mode 100644 index 0000000..2fd432a --- /dev/null +++ b/test/test.d.ts @@ -0,0 +1 @@ +import 'typings-test'; diff --git a/test/test.js b/test/test.js new file mode 100644 index 0000000..9fb4b88 --- /dev/null +++ b/test/test.js @@ -0,0 +1,7 @@ +"use strict"; +require("typings-test"); +describe('smartacme', function () { + let testAcme; + it('should create a valid instance'); +}); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHdCQUFxQjtBQU1yQixRQUFRLENBQUMsV0FBVyxFQUFFO0lBQ2xCLElBQUksUUFBNkIsQ0FBQTtJQUNqQyxFQUFFLENBQUMsZ0NBQWdDLENBQUMsQ0FBQTtBQUN4QyxDQUFDLENBQUMsQ0FBQSJ9 \ No newline at end of file diff --git a/test/test.ts b/test/test.ts new file mode 100644 index 0000000..f7fa067 --- /dev/null +++ b/test/test.ts @@ -0,0 +1,10 @@ +import 'typings-test' +import * as should from 'should' + +// import the module to test +import * as smartacme from '../dist/index' + +describe('smartacme', function(){ + let testAcme: smartacme.smartacme + it('should create a valid instance') +}) diff --git a/ts/index.ts b/ts/index.ts new file mode 100644 index 0000000..debfb71 --- /dev/null +++ b/ts/index.ts @@ -0,0 +1 @@ +export * from './smartacme.classes.smartacme' diff --git a/ts/smartacme.classes.acmeclient.ts b/ts/smartacme.classes.acmeclient.ts new file mode 100644 index 0000000..ce2df76 --- /dev/null +++ b/ts/smartacme.classes.acmeclient.ts @@ -0,0 +1,923 @@ +import * as plugins from './smartacme.plugins' +import * as base64url from 'base64url' +import * as child_process from 'child_process' +import * as crypto from 'crypto' +import * as fs from 'fs' +import * as readline from 'readline' +import { JWebClient } from './smartacme.classes.jwebclient' + +/** + * json_to_utf8buffer + * @private + * @description convert JSON to Buffer using UTF-8 encoding + * @param {Object} obj + * @return {Buffer} + * @throws Exception if object cannot be stringified or contains cycle + */ +let json_to_utf8buffer = function (obj) { + return new Buffer(JSON.stringify(obj), 'utf8') +} + +/** + * @class AcmeClient + * @constructor + * @description ACME protocol implementation from client perspective + * @param {string} directory_url - Address of directory + * @param {module:JWebClient~JWebClient} jWebClient - Reference to JSON-Web-Client + */ +export class AcmeClient { + clientProfilePubKey: any + days_valid: number + defaultRsaKeySize: number + directory: any + directoryUrl: string + emailDefaultPrefix: string + emailOverride: string + jWebClient: any + regLink: string + tosLink: string + webroot: string + well_known_path: string + withInteraction: boolean + constructor(directoryUrlArg) { + /** + * @member {Object} module:AcmeClient~AcmeClient#clientProfilePubKey + * @desc Cached public key obtained from profile + */ + this.clientProfilePubKey = {} + /** + * @member {number} module:AcmeClient~AcmeClient#days_valid + * @desc Validity period in days + * @default 1 + */ + this.days_valid = 1 + /** + * @member {number} module:AcmeClient~AcmeClient#defaultRsaKeySize + * @desc Key strength in bits + * @default 4096 + */ + this.defaultRsaKeySize = 4096 + /** + * @member {Object} module:AcmeClient~AcmeClient#directory + * @desc Hash map of REST URIs + */ + this.directory = {} + /** + * @member {string} module:AcmeClient~AcmeClient#directory_url + * @desc Address of directory + */ + this.directoryUrl = directoryUrlArg + /** + * @member {string} module:AcmeClient~AcmeClient#emailDefaultPrefix + * @desc Prefix of email address if constructed from domain name + * @default "hostmaster" + */ + this.emailDefaultPrefix = 'hostmaster' // {string} + /** + * @member {string} module:AcmeClient~AcmeClient#emailOverride + * @desc Email address to use + */ + this.emailOverride = null // {string} + /** + * @member {module:JWebClient~JWebClient} module:AcmeClient~AcmeClient#jWebClient + * @desc Reference to JSON-Web-Client + */ + this.jWebClient = new JWebClient() // {JWebClient} + /** + * @member {string} module:AcmeClient~AcmeClient#regLink + * @desc Cached registration URI + */ + this.regLink = null // {string} + /** + * @member {string} module:AcmeClient~AcmeClient#tosLink + * @desc Cached terms of service URI + */ + this.tosLink = null // {string} + /** + * @member {string} module:AcmeClient~AcmeClient#webroot + * @desc Path to server web root (or path to store challenge data) + * @default "." + */ + this.webroot = '.' // {string} + /** + * @member {string} module:AcmeClient~AcmeClient#well_known_path + * @desc Directory structure for challenge data + * @default "/.well-known/acme-challenge/" + */ + this.well_known_path = '/.well-known/acme-challenge/' // {string} + /** + * @member {boolean} module:AcmeClient~AcmeClient#withInteraction + * @desc Determines if interaction of user is required + * @default true + */ + this.withInteraction = true // {boolean} + } + + // ***************************************************************************** + // REQUEST-Section + // ***************************************************************************** + + /** + * getDirectory + * @description retrieve directory entries (directory url must be set prior to execution) + * @param {function} callback - first argument will be the answer object + */ + getDirectory(callback) { + this.jWebClient.get(this.directoryUrl, callback, callback) + // dereference + callback = null + } + + /** + * newRegistration + * @description try to register (directory lookup must have occured prior to execution) + * @param {Object} payload + * @param {function} callback - first argument will be the answer object + */ + newRegistration(payload, callback) { + if (!(payload instanceof Object)) { + payload = {} // ensure payload is object + } + payload.resource = 'new-reg' + this.jWebClient.post(this.directory['new-reg'], payload, callback, callback) + // dereference + callback = null + payload = null + } + + /** + * getRegistration + * @description get information about registration + * @param {string} uri - will be exposed when trying to register + * @param {Object} payload - update information + * @param {function} callback - first argument will be the answer object + */ + getRegistration(uri, payload, callback) { + /*jshint -W069 */ + let ctx = this + if (!(payload instanceof Object)) { + payload = {} // ensure payload is object + } + payload['resource'] = 'reg' + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + this.jWebClient.post(uri, payload, function (ans, res) { + if (ans instanceof Object) { + ctx.clientProfilePubKey = ans.key // cache or reset returned public key + if ((res instanceof Object) && (res['headers'] instanceof Object)) { + let linkStr = res.headers['link'] + if (typeof linkStr === 'string') { + let tosLink = ctx.getTosLink(linkStr) + if (typeof tosLink === 'string') { + ctx.tosLink = tosLink // cache TOS link + } else { + ctx.tosLink = null // reset TOS link + } + } else { + ctx.tosLink = null // reset TOS link + } + } else { + ctx.tosLink = null // reset TOS link + } + callback(ans, res) + } else { + callback(false) + } + // dereference + ans = null + callback = null + ctx = null + res = null + }) + // dereference + payload = null + } + + /** + * authorizeDomain + * @description authorize domain using challenge-response-method + * @param {string} domain + * @param {function} callback - first argument will be the answer object + */ + authorizeDomain(domain, callback) { + /*jshint -W069 */ + let ctx = this + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + this.getProfile(function (profile) { + if (!(profile instanceof Object)) { + callback(false) // no profile returned + // dereference + callback = null + ctx = null + } else { + ctx.jWebClient.post(ctx.directory['new-authz'], ctx.makeDomainAuthorizationRequest(domain), function (ans, res) { + if ((res instanceof Object) && (res['statusCode'] === 403)) { // if unauthorized + ctx.agreeTos(ctx.tosLink, function (ans_, res_) { // agree to TOS + if ( // if TOS were agreed successfully + (res_ instanceof Object) + && (res_['statusCode'] >= 200) + && (res_['statusCode'] <= 400) + ) { + ctx.authorizeDomain(domain, callback) // try authorization again + } else { + callback(false) // agreement failed + } + // dereference + ans = null + ans_ = null + callback = null + ctx = null + profile = null + res = null + res_ = null + }) + } else { + if ( + (res instanceof Object) + && (res['headers'] instanceof Object) + && (typeof res.headers['location'] === 'string') + && (ans instanceof Object) + ) { + let poll_uri = res.headers['location'] // status URI for polling + let challenge = ctx.selectChallenge(ans, 'http-01') // select simple http challenge + if (challenge instanceof Object) { // desired challenge is in list + ctx.prepareChallenge(domain, challenge, function () { // prepare all objects and files for challenge + // reset + ans = null + res = null + // accept challenge + ctx.acceptChallenge(challenge, function (ans, res) { + if ( + (res instanceof Object) + && (res['statusCode'] < 400) // server confirms challenge acceptance + ) { + ctx.pollUntilValid(poll_uri, callback) // poll status until server states success + } else { + callback(false) // server did not confirm challenge acceptance + } + // dereference + ans = null + callback = null + challenge = null + ctx = null + profile = null + res = null + }) + }) + } else { + callback(false) // desired challenge is not in list + // dereference + ans = null + callback = null + ctx = null + profile = null + res = null + } + } else { + callback(false) // server did not respond with status URI + // dereference + ans = null + callback = null + ctx = null + profile = null + res = null + } + } + }) + } + }) + } + + /** + * acceptChallenge + * @description tell server which challenge will be accepted + * @param {Object} challenge + * @param {function} callback - first argument will be the answer object + */ + acceptChallenge(challenge, callback) { + /*jshint -W069 */ + if (!(challenge instanceof Object)) { + challenge = {} // ensure challenge is object + } + this.jWebClient.post(challenge['uri'], this.makeChallengeResponse(challenge), callback) + // dereference + callback = null + challenge = null + } + + /** + * pollUntilValid + * @description periodically (with exponential back-off) check status of challenge + * @param {string} uri + * @param {function} callback - first argument will be the answer object + * @param {number} retry - factor of delay + */ + pollUntilValid(uri, callback, retry = 1) { + /*jshint -W069 */ + let ctx = this + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + if (retry > 128) { + callback(false) // stop if retry value exceeds maximum + } else { + this.jWebClient.get(uri, function (ans, res) { + if (!(ans instanceof Object)) { + callback(false) // invalid answer + // dereference + callback = null + ctx = null + res = null + } else { + if (ans['status'] === 'pending') { // still pending + setTimeout(function () { + ctx.pollUntilValid(uri, callback, retry * 2) // retry + // dereference + ans = null + callback = null + ctx = null + res = null + }, retry * 500) + } else { + callback(ans, res) // challenge complete + // dereference + ans = null + callback = null + ctx = null + res = null + } + } + }) + } + } + + /** + * pollUntilIssued + * @description periodically (with exponential back-off) check status of CSR + * @param {string} uri + * @param {function} callback - first argument will be the answer object + * @param {number} retry - factor of delay + */ + pollUntilIssued(uri, callback, retry = 1) { + /*jshint -W069 */ + let ctx = this + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + if (retry > 128) { + callback(false) // stop if retry value exceeds maximum + } else { + this.jWebClient.get(uri, function (ans, res) { + if ((ans instanceof Buffer) && (ans.length > 0)) { + callback(ans) // certificate was returned with answer + // dereference + ans = null + callback = null + ctx = null + res = null + } else { + if ((res instanceof Object) && (res['statusCode'] < 400)) { // still pending + setTimeout(function () { + ctx.pollUntilIssued(uri, callback, retry * 2) // retry + // dereference + ans = null + callback = null + ctx = null + res = null + }, retry * 500) + } else { + callback(false) // CSR complete + // dereference + ans = null + callback = null + ctx = null + res = null + } + } + }) + } + } + + /** + * requestSigning + * @description send CSR + * @param {string} domain - expected to be already sanitized + * @param {function} callback - first argument will be the answer object + */ + requestSigning(domain, callback) { + /*jshint -W069 */ + let ctx = this + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + fs.readFile(domain + '.csr', function (err, csr) { + if (err instanceof Object) { // file system error + if (ctx.jWebClient.verbose) { + console.error('Error : File system error', err['code'], 'while reading key from file') + } + callback(false) + // dereference + callback = null + csr = null + ctx = null + err = null + } else { + ctx.jWebClient.post(ctx.directory['new-cert'], ctx.makeCertRequest(csr, ctx.days_valid), function (ans, res) { + if ((ans instanceof Buffer) && (ans.length > 0)) { // answer is buffer + callback(ans) // certificate was returned with answer + // dereference + ans = null + callback = null + csr = null + ctx = null + err = null + res = null + } else { + if (res instanceof Object) { + if ((res['statusCode'] < 400) && !ans) { // success response, but no answer was provided + let headers = res['headers'] + if (!(headers instanceof Object)) { + headers = {} // ensure headers is object + } + ctx.pollUntilIssued(headers['location'], callback) // poll provided status URI + // dereference + headers = null + } else { + callback((res['statusCode'] < 400) ? ans : false) // answer may be provided as string or object + } + } else { + callback(false) // invalid response + } + // dereference + ans = null + callback = null + csr = null + ctx = null + err = null + res = null + } + }) + } + }) + } + + /** + * getProfile + * @description retrieve profile of user (will make directory lookup and registration check) + * @param {function} callback - first argument will be the answer object + */ + getProfile(callback) { + /*jshint -W069 */ + let ctx = this + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + this.getDirectory(function (dir) { + if (!(dir instanceof Object)) { + callback(false) // server did not respond with directory + // dereference + callback = null + ctx = null + } else { + ctx.directory = dir // cache directory + ctx.newRegistration(null, function (ans, res) { // try new registration to get registration link + if ( + (res instanceof Object) + && (res['headers'] instanceof Object) + && (typeof res.headers['location'] === 'string') + ) { + ctx.regLink = res.headers['location'] + ctx.getRegistration(ctx.regLink, null, callback) // get registration info from link + } else { + callback(false) // registration failed + } + // dereference + ans = null + callback = null + ctx = null + dir = null + res = null + }) + } + }) + } + + /** + * createAccount + * @description create new account (assumes directory lookup has already occured) + * @param {string} email + * @param {function} callback - first argument will be the registration URI + */ + createAccount(email, callback) { + /*jshint -W069 */ + let ctx = this + if (typeof email === 'string') { + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + ctx.newRegistration( + { + contact: [ + 'mailto:' + email + ] + }, + function (ans, res) { + if ( + (res instanceof Object) + && (res['statusCode'] === 201) + && (res['headers'] instanceof Object) + && (typeof res.headers['location'] === 'string') + ) { + ctx.regLink = res.headers['location'] + callback(ctx.regLink) // registration URI + } else { + callback(false) // registration failed + } + // dereference + ans = null + callback = null + ctx = null + res = null + }) + } else { + callback(false) // no email address provided + // dereference + callback = null + ctx = null + } + } + + /** + * agreeTos + * @description agree with terms of service (update agreement status in profile) + * @param {string} tosLink + * @param {function} callback - first argument will be the answer object + */ + agreeTos(tosLink, callback) { + this.getRegistration(this.regLink, { + 'Agreement': tosLink // terms of service URI + }, callback) + // dereference + callback = null + } + + /** + * Entry-Point: Request certificate + * @param {string} domain + * @param {string} organization + * @param {string} country + * @param {function} callback + */ + requestCertificate(domain, organization, country, callback) { + /*jshint -W069 */ + let ctx = this + if (typeof domain !== 'string') { + domain = '' // ensure domain is string + } + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + this.getProfile(function (profile) { + let email = ctx.extractEmail(profile) // try to determine email address from profile + if (typeof ctx.emailOverride === 'string') { + email = ctx.emailOverride // override email address if set + } else if (typeof email !== 'string') { + email = ctx.emailDefaultPrefix + '@' + domain // or set default + } + let bit = ctx.defaultRsaKeySize + // sanitize + bit = Number(bit) + country = ctx.makeSafeFileName(country) + domain = ctx.makeSafeFileName(domain) + email = ctx.makeSafeFileName(email) + organization = ctx.makeSafeFileName(organization) + // create key pair + ctx.createKeyPair(bit, country, organization, domain, email, function (e) { // create key pair + if (!e) { + ctx.requestSigning(domain, function (cert) { // send CSR + if ((cert instanceof Buffer) || (typeof cert === 'string')) { // valid certificate data + fs.writeFile(domain + '.der', cert, function (err) { // sanitize domain name for file path + if (err instanceof Object) { // file system error + if (ctx.jWebClient.verbose) { + console.error('Error : File system error', err['code'], 'while writing certificate to file') + } + callback(false) + } else { + callback(true) // CSR complete and certificate written to file system + } + // dereference + callback = null + cert = null + ctx = null + e = null + err = null + profile = null + }) + } else { + callback(false) // invalid certificate data + // dereference + callback = null + cert = null + ctx = null + e = null + profile = null + } + }) + } else { + callback(false) // could not create key pair + // dereference + callback = null + ctx = null + e = null + profile = null + } + }) + }) + } + + /** + * External: Create key pair + * @param {number} bit - key strength, expected to be already sanitized + * @param {string} c - country code, expected to be already sanitized + * @param {string} o - organization, expected to be already sanitized + * @param {string} cn - common name (domain name), expected to be already sanitized + * @param {string} e - email address, expected to be already sanitized + * @param {function} callback + */ + createKeyPair(bit, c, o, cn, e, callback) { + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + let openssl = `openssl req -new -nodes -newkey rsa:${bit} -sha256 -subj "/C=${c}/O=${o}/CN=${cn}/emailAddress=${e}" -keyout \"${cn}.key\" -outform der -out \"${cn}.csr\"` + console.error('Action : Creating key pair') + if (this.jWebClient.verbose) { + console.error('Running:', openssl) + } + child_process.exec(openssl, function (e) { + if (!e) { + console.error('Result : done') + } else { + console.error('Result : failed') + } + callback(e) + // dereference + callback = null + e = null + } + ) + } + + /** + * Helper: Empty callback + */ + emptyCallback() { + // nop + } + + /** + * Helper: Make safe file name or path from string + * @param {string} name + * @param {boolean} withPath - optional, default false + * @return {string} + */ + makeSafeFileName(name, withPath = false) { + if (typeof name !== 'string') { + name = '' + } + // respects file name restrictions for ntfs and ext2 + let regex_file = '[<>:\"/\\\\\\|\\?\\*\\u0000-\\u001f\\u007f\\u0080-\\u009f]' + let regex_path = '[<>:\"\\\\\\|\\?\\*\\u0000-\\u001f\\u007f\\u0080-\\u009f]' + return name.replace(new RegExp(withPath ? regex_path : regex_file, 'g'), function (charToReplace) { + if (typeof charToReplace === 'string') { + return '%' + charToReplace.charCodeAt(0).toString(16).toLocaleUpperCase() + } + return '%00' + }) + } + + /** + * Helper: Prepare challenge + * @param {string} domain + * @param {Object} challenge + * @param {function} callback + */ + prepareChallenge(domain, challenge, callback) { + /*jshint -W069, unused:false*/ + let ctx = this + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + if (challenge instanceof Object) { + if (challenge['type'] === 'http-01') { // simple http challenge + let path = this.webroot + this.well_known_path + challenge['token'] // webroot and well_known_path are expected to be already sanitized + fs.writeFile(path, this.makeKeyAuthorization(challenge), function (err) { // create challenge file + if (err instanceof Object) { // file system error + if (ctx.jWebClient.verbose) { + console.error( + 'Error : File system error', + err['code'], 'while writing challenge data to file' + ) + } + callback() + // dereference + callback = null + challenge = null + ctx = null + err = null + } else { + // let uri = "http://" + domain + this.well_known_path + challenge["token"] + let rl = readline.createInterface(process.stdin, process.stdout) + if (ctx.withInteraction) { + rl.question('Press enter to proceed', function (answer) { // wait for user to proceed + rl.close() + callback() + // dereference + callback = null + challenge = null + ctx = null + rl = null + }) + } else { + rl.close() + callback() // skip interaction prompt if desired + // dereference + callback = null + challenge = null + ctx = null + rl = null + } + } + }) + } else { // no supported challenge + console.error('Error : Challenge not supported') + callback() + // dereference + callback = null + challenge = null + ctx = null + } + } else { // invalid challenge response + console.error('Error : Invalid challenge response') + callback() + // dereference + callback = null + challenge = null + ctx = null + } + } + + /** + * Helper: Extract TOS Link, e.g. from "<http://...>;rel="terms-of-service" + * @param {string} linkStr + * @return {string} + */ + getTosLink(linkStr) { + let match = /(<)([^>]+)(>;rel="terms-of-service")/g.exec(linkStr) + if ((match instanceof Array) && (match.length > 2)) { + let result = match[2] + // dereference + match = null + return result + } + // dereference + match = null + return void 0 + } + + /** + * Helper: Select challenge by type + * @param {Object} ans + * @param {string} challenge_type + * @return {Object} + */ + selectChallenge(ans, challengeType: string) { + /*jshint -W069 */ + if ((ans instanceof Object) && (ans['challenges'] instanceof Array)) { + return ans.challenges.filter(function (entry) { + let type = entry['type'] + // dereference + entry = null + if (type === challengeType) { // check for type match + return true + } + return false + }).pop() + } // return first match or undefined + // dereference + ans = null + return void 0 // challenges not available or in expected format + } + + /** + * Helper: Extract first found email from profile (without mailto prefix) + * @param {Object} profile + * @return {string} + */ + extractEmail(profile) { + /*jshint -W069 */ + if (!(profile instanceof Object) || !(profile['contact'] instanceof Array)) { + // dereference + profile = null + return void 0 // invalid profile + } + let prefix = 'mailto:' + let email = profile.contact.filter(function (entry) { + if (typeof entry !== 'string') { + return false + } else { + return !entry.indexOf(prefix) // check for mail prefix + } + } + ).pop() + // dereference + profile = null + if (typeof email !== 'string') { + return void 0 + } // return default + return email.substr(prefix.length) // only return email address without protocol prefix + } + + /** + * Make ACME-Request: Domain-Authorization Request - Object: resource, identifier + * @param {string} domain + * @return {{resource: string, identifier: Object}} + */ + makeDomainAuthorizationRequest(domain) { + return { + 'resource': 'new-authz', + 'identifier': { + 'type': 'dns', + 'value': domain + } + } + } + + /** + * Make ACME-Object: Key-Authorization (encoded) - String: Challenge-Token . Encoded-Account-Key-Hash + * @param {Object} challenge + * @return {string} + */ + makeKeyAuthorization(challenge) { + /*jshint -W069 */ + if (challenge instanceof Object) { + if (this.clientProfilePubKey instanceof Object) { + let jwk = json_to_utf8buffer({ + e: this.clientProfilePubKey['e'], + kty: this.clientProfilePubKey['kty'], + n: this.clientProfilePubKey['n'] + } + ) + let hash = crypto.createHash('sha256').update(jwk.toString('utf8'), 'utf8').digest() + let ACCOUNT_KEY = base64url.default.encode(hash) // create base64 encoded hash of account key + let token = challenge['token'] + // dereference + challenge = null + jwk = null + return token + '.' + ACCOUNT_KEY + } + } else { + return '' // return default (for writing to file) + } + } + + /** + * Make ACME-Request: Challenge-Response - Object: resource, keyAuthorization + * @param {Object} challenge + * @return {{resource: string, keyAuthorization: string}} + */ + makeChallengeResponse(challenge) { + return { + 'resource': 'challenge', + 'keyAuthorization': this.makeKeyAuthorization(challenge) + } + } + + /** + * Make ACME-Request: CSR - Object: resource, csr, notBefore, notAfter + * @param {string} csr + * @param {number} days_valid + * @return {{resource: string, csr: string, notBefore: string, notAfter: string}} + */ + makeCertRequest(csr, DAYS_VALID: number) { + if (typeof csr !== 'string' && !(csr instanceof Buffer)) { + csr = '' // default string for CSR + } + if ((typeof DAYS_VALID !== 'number') || (isNaN(DAYS_VALID)) || (DAYS_VALID === 0)) { + DAYS_VALID = 1 // default validity duration (1 day) + } + let DOMAIN_CSR_DER = base64url.default.encode(csr) // create base64 encoded CSR + let CURRENT_DATE = (new Date()).toISOString() // set start date to current date + + // set end date to current date + days_valid + let NOTAFTER_DATE = (new Date((+new Date()) + 1000 * 60 * 60 * 24 * Math.abs(DAYS_VALID))).toISOString() + return { + 'resource': 'new-cert', + 'csr': DOMAIN_CSR_DER, + 'notBefore': CURRENT_DATE, + 'notAfter': NOTAFTER_DATE + } + } +} diff --git a/ts/smartacme.classes.jwebclient.ts b/ts/smartacme.classes.jwebclient.ts new file mode 100644 index 0000000..2465c76 --- /dev/null +++ b/ts/smartacme.classes.jwebclient.ts @@ -0,0 +1,294 @@ +import * as plugins from './smartacme.plugins' +import * as base64url from 'base64url' +import * as https from 'https' +let jwa = require('jwa') +import * as url from 'url' + +/** + * json_to_utf8base64url + * @private + * @description convert JSON to base64-url encoded string using UTF-8 encoding + * @param {Object} obj + * @return {string} + * @throws Exception if object cannot be stringified or contains cycle + */ +let json_to_utf8base64url = function (obj) { + return base64url.default.encode(new Buffer(JSON.stringify(obj), 'utf8')) +} + +/** + * @class JWebClient + * @constructor + * @description Implementation of HTTPS-based JSON-Web-Client + */ +export class JWebClient { + key_pair: any + last_nonce: string + verbose: boolean + constructor() { + /** + * @member {Object} module:JWebClient~JWebClient#key_pair + * @desc User account key pair + */ + this.key_pair = null // {Object} + /** + * @member {string} module:JWebClient~JWebClient#last_nonce + * @desc Cached nonce returned with last request + */ + this.last_nonce = null // {string} + /** + * @member {boolean} module:JWebClient~JWebClient#verbose + * @desc Determines verbose mode + */ + this.verbose = false // {boolean} + } + + /** + * createJWT + * @description create JSON-Web-Token signed object + * @param {string|undefined} nonce + * @param {Object|string|number|boolean} payload + * @param {string} alg + * @param {Object|string} key + * @param {Object} jwk + * @return {string} + */ + createJWT(nonce, payload, alg, key, jwk) { + /*jshint -W069 */ + // prepare key + if (key instanceof Object) { + key = base64url.default.toBuffer(key['k']) + } + // prepare header + let header = { + typ: 'JWT', + alg: alg, + jwk: jwk, + nonce: null + } + + if (nonce !== void 0) { + header.nonce = nonce + } + // concatenate header and payload + let input = [ + json_to_utf8base64url(header), + json_to_utf8base64url(payload) + ].join('.') + // sign input + let hmac = jwa(alg) + let sig = hmac.sign(input, key) + // concatenate input and signature + let output = [ + input, + sig + ].join('.') + // dereference + header = null + hmac = null + input = null + jwk = null + key = null + payload = null + // output + return output + } + + /** + * request + * @description make GET or POST request over HTTPS and use JOSE as payload type + * @param {string} query + * @param {string} payload + * @param {function} callback + * @param {function} errorCallback + */ + request(query, payload, callback, errorCallback) { + /*jshint -W069 */ + if (typeof query !== 'string') { + query = '' // ensure query is string + } + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + if (typeof errorCallback !== 'function') { + errorCallback = this.emptyCallback // ensure callback is function + } + // prepare options + let uri = url.parse(query) + let options = { + hostname: uri.hostname, + port: parseInt(uri.port, 10), + path: uri.path, + method: null, + headers: {} + } + if (typeof payload === 'string') { + options.method = 'POST' + options.headers = { + 'Content-Type': 'application/jose', + 'Content-Length': payload.length + } + } else { + options.method = 'GET' + } + // prepare request + let req = https.request(options, function (res) { + // receive data + let data = [] + res.on('data', function (block) { + if (block instanceof Buffer) { + data.push(block) + } + }) + res.on('end', function () { + let buf = Buffer.concat(data) + let isJSON = ( + (res instanceof Object) + && (res['headers'] instanceof Object) + && (typeof res.headers['content-type'] === 'string') + && (res.headers['content-type'].indexOf('json') > -1) + ) + if (isJSON && buf.length > 0) { + try { + // convert to JSON + let json = JSON.parse(buf.toString('utf8')) + callback(json, res) + } catch (e) { + // error (if empty or invalid JSON) + errorCallback(void 0, e) + } + } else { + callback(buf, res) + } + }) + }).on('error', function (e) { + console.error('Error occured', e) + // error + errorCallback(void 0, e) + }) + // write POST body if payload was specified + if (typeof payload === 'string') { + req.write(payload) + } + // make request + req.end() + } + + /** + * get + * @description make GET request + * @param {string} uri + * @param {function} callback + * @param {function} errorCallback + */ + get(uri, callback, errorCallback) { + /*jshint -W069 */ + let ctx = this + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + this.request(uri, void 0, function (ans, res) { + ctx.evaluateStatus(uri, null, ans, res) + // save replay nonce for later requests + if ((res instanceof Object) && (res['headers'] instanceof Object)) { + ctx.last_nonce = res.headers['replay-nonce'] + } + callback(ans, res) + // dereference + ans = null + callback = null + ctx = null + res = null + }, errorCallback) + // dereference + errorCallback = null + } + + /** + * post + * @description make POST request + * @param {string} uri + * @param {Object|string|number|boolean} payload + * @param {function} callback + * @param {function} errorCallback + */ + post(uri, payload, callback, errorCallback) { + /*jshint -W069 */ + let ctx = this + if (typeof callback !== 'function') { + callback = this.emptyCallback // ensure callback is function + } + let key_pair = this.key_pair + if (!(key_pair instanceof Object)) { + key_pair = {} // ensure key pair is object + } + let jwt = this.createJWT(this.last_nonce, payload, 'RS256', key_pair['private_pem'], key_pair['public_jwk']) + this.request(uri, jwt, (ans, res) => { + ctx.evaluateStatus(uri, payload, ans, res) + // save replay nonce for later requests + if ((res instanceof Object) && (res['headers'] instanceof Object)) { + ctx.last_nonce = res.headers['replay-nonce'] + } + callback(ans, res) + // dereference + ans = null + callback = null + ctx = null + key_pair = null + payload = null + res = null + }, errorCallback) + // dereference + errorCallback = null + } + + /** + * evaluateStatus + * @description check if status is expected and log errors + * @param {string} uri + * @param {Object|string|number|boolean} payload + * @param {Object|string} ans + * @param {Object} res + */ + evaluateStatus(uri, payload, ans, res) { + /*jshint -W069 */ + if (this.verbose) { + if ( + (payload instanceof Object) + || (typeof payload === 'string') + || (typeof payload === 'number') + || (typeof payload === 'boolean') + ) { + console.error('Send :', payload) // what has been sent + } + } + let uri_parsed = url.parse(uri) + if (res['statusCode'] >= 100 && res['statusCode'] < 400) { + console.error('HTTP :', res['statusCode'], uri_parsed.path) // response code if successful + } + if (res['statusCode'] >= 400 && res['statusCode'] < 500) { + console.error('HTTP :', res['statusCode'], uri_parsed.path) // response code if error + if (ans instanceof Object) { + if (typeof ans['detail'] === 'string') { + console.error('Message:', ans.detail.split(' :: ').pop()) // error message if any + } + } + } + if (this.verbose) { + console.error('Receive:', res['headers']) // received headers + console.error('Receive:', ans) // received data + } + // dereference + ans = null + payload = null + res = null + uri_parsed = null + } + + /** + * Helper: Empty callback + */ + emptyCallback() { + // nop + } +} diff --git a/ts/smartacme.classes.smartacme.ts b/ts/smartacme.classes.smartacme.ts new file mode 100644 index 0000000..569f42a --- /dev/null +++ b/ts/smartacme.classes.smartacme.ts @@ -0,0 +1,9 @@ +import * as plugins from './smartacme.plugins' +import * as acmeclient from './smartacme.classes.acmeclient' + +export class SmartAcme { + acmeClient: acmeclient.AcmeClient + constructor(directoryUrlArg: string = 'https://acme-staging.api.letsencrypt.org/directory') { + this.acmeClient = new acmeclient.AcmeClient(directoryUrlArg) + } +} diff --git a/ts/smartacme.plugins.ts b/ts/smartacme.plugins.ts new file mode 100644 index 0000000..3eccc7e --- /dev/null +++ b/ts/smartacme.plugins.ts @@ -0,0 +1,6 @@ +import 'typings-global' +import * as path from 'path' + +export { + path +} diff --git a/tslint.json b/tslint.json new file mode 100644 index 0000000..45052ad --- /dev/null +++ b/tslint.json @@ -0,0 +1,3 @@ +{ + "extends": "tslint-config-standard" +}