138 lines
4.2 KiB
TypeScript
138 lines
4.2 KiB
TypeScript
import * as q from 'q'
|
|
let letsencrypt = require('letsencrypt')
|
|
let leStore = require('le-store-certbot')
|
|
|
|
import * as plugins from './cert.plugins'
|
|
import * as paths from './cert.paths'
|
|
|
|
import { ChallengeHandler } from './cert.classes.challengehandler'
|
|
|
|
export type TLeEnv = 'production' | 'staging'
|
|
|
|
export interface ILetsencryptConstructorOptions {
|
|
leEnv: TLeEnv,
|
|
challengeHandler: ChallengeHandler,
|
|
sslDir: string
|
|
}
|
|
|
|
export class Letsencrypt {
|
|
leEnv: TLeEnv
|
|
challengeHandler: ChallengeHandler // this is the format we use
|
|
sslDir: string
|
|
|
|
private _leInstance: any
|
|
private _leServerUrl: string
|
|
|
|
constructor(optionsArg: ILetsencryptConstructorOptions) {
|
|
// determine leEnv
|
|
this.leEnv = optionsArg.leEnv
|
|
this.challengeHandler = optionsArg.challengeHandler
|
|
this.sslDir = optionsArg.sslDir
|
|
|
|
// set letsencrypt environment
|
|
if (this.leEnv === 'production') {
|
|
this._leServerUrl = letsencrypt.productionServerUrl
|
|
} else if (this.leEnv === 'staging') {
|
|
this._leServerUrl = letsencrypt.stagingServerUrl
|
|
}
|
|
|
|
// create leInstance
|
|
this._leInstance = letsencrypt.create({
|
|
server: this._leServerUrl,
|
|
challenges: {
|
|
'dns-01': this._leChallengeHandler()
|
|
},
|
|
challengeType: 'dns-01',
|
|
store: leStore.create({
|
|
configDir: paths.leConfigDir,
|
|
debug: true
|
|
}),
|
|
agreeToTerms: (opts, agreeCb) => {
|
|
agreeCb(null, opts.tosUrl)
|
|
},
|
|
debug: true
|
|
})
|
|
console.log()
|
|
}
|
|
|
|
/**
|
|
* register a domain
|
|
*/
|
|
registerDomain(domainNameArg: string) {
|
|
plugins.beautylog.log(`trying to register domain ${domainNameArg}`)
|
|
let done = q.defer()
|
|
console.log('test')
|
|
console.log(this._leServerUrl)
|
|
this._leInstance.register({
|
|
domains: [domainNameArg],
|
|
email: 'office@lossless.com',
|
|
agreeTos: true,
|
|
rsaKeySize: 2048,
|
|
challengeType: 'dns-01'
|
|
}).then(
|
|
results => {
|
|
plugins.beautylog.success(`Got certificates for ${domainNameArg}`)
|
|
this._leCopyToDestination(domainNameArg).then(done.resolve)
|
|
},
|
|
(err) => {
|
|
console.error('[Error]: node-letsencrypt/examples/standalone')
|
|
console.error(err.stack)
|
|
done.resolve()
|
|
}
|
|
).catch(err => { console.log(err) })
|
|
return done.promise
|
|
}
|
|
|
|
// --------------------------------------------
|
|
// Translate for official letsencrypt stuff
|
|
// --------------------------------------------
|
|
|
|
private _leCopyToDestination(domainNameArg) {
|
|
let done = q.defer()
|
|
done.resolve()
|
|
return done.promise
|
|
}
|
|
|
|
/**
|
|
* translates to the format expected by letsencrypt node implementation
|
|
*/
|
|
private _leChallengeHandler() {
|
|
return {
|
|
getOptions: () => {
|
|
return {
|
|
debug: false
|
|
}
|
|
},
|
|
set: (args, domain, challenge, keyAuthorization, cb) => {
|
|
let keyAuthDigest = require('crypto')
|
|
.createHash('sha256').update(keyAuthorization || '')
|
|
.digest('base64')
|
|
.replace(/\+/g, '-')
|
|
.replace(/\//g, '_')
|
|
.replace(/=+$/g, '')
|
|
this.challengeHandler.setChallenge(domain, keyAuthDigest)
|
|
.then(() => {
|
|
cb()
|
|
})
|
|
},
|
|
get: (defaults, domain, challenge, cb) => {
|
|
console.log(domain)
|
|
console.log(challenge)
|
|
cb()
|
|
},
|
|
remove: (args, domain, challenge, cb) => {
|
|
this.challengeHandler.cleanChallenge(domain)
|
|
.then(() => {
|
|
cb()
|
|
})
|
|
},
|
|
loopback: (defaults, domain, challenge, done) => {
|
|
done()
|
|
},
|
|
test: (defaults, domain, challenge, cb) => {
|
|
cb()
|
|
}
|
|
}
|
|
}
|
|
}
|