1 import * as crypto from 'crypto'
2 import * as bcrypt from 'bcrypt'
3 import * as fs from 'fs'
4 import * as openssl from 'openssl-wrapper'
5 import { join } from 'path'
14 } from '../initializers'
15 import { logger } from './logger'
17 function checkSignature (publicKey: string, data: string, hexSignature: string) {
18 const verify = crypto.createVerify(SIGNATURE_ALGORITHM)
21 if (typeof data === 'string') {
25 dataString = JSON.stringify(data)
27 logger.error('Cannot check signature.', { error: err })
32 verify.update(dataString, 'utf8')
34 const isValid = verify.verify(publicKey, hexSignature, SIGNATURE_ENCODING)
38 function sign (data: string|Object) {
39 const sign = crypto.createSign(SIGNATURE_ALGORITHM)
41 let dataString: string
42 if (typeof data === 'string') {
46 dataString = JSON.stringify(data)
48 logger.error('Cannot sign data.', { error: err })
53 sign.update(dataString, 'utf8')
56 const certPath = join(CONFIG.STORAGE.CERT_DIR, PRIVATE_CERT_NAME)
57 const myKey = fs.readFileSync(certPath)
58 const signature = sign.sign(myKey.toString(), SIGNATURE_ENCODING)
63 function comparePassword (plainPassword: string, hashPassword: string, callback: (err: Error, match?: boolean) => void) {
64 bcrypt.compare(plainPassword, hashPassword, function (err, isPasswordMatch) {
65 if (err) return callback(err)
67 return callback(null, isPasswordMatch)
71 function createCertsIfNotExist (callback: (err: Error) => void) {
72 certsExist(function (err, exist) {
73 if (err) return callback(err)
79 createCerts(function (err) {
85 function cryptPassword (password: string, callback: (err: Error, hash?: string) => void) {
86 bcrypt.genSalt(BCRYPT_SALT_SIZE, function (err, salt) {
87 if (err) return callback(err)
89 bcrypt.hash(password, salt, function (err, hash) {
90 return callback(err, hash)
95 function getMyPrivateCert (callback: (err: Error, privateCert: string) => void) {
96 const certPath = join(CONFIG.STORAGE.CERT_DIR, PRIVATE_CERT_NAME)
97 fs.readFile(certPath, 'utf8', callback)
100 function getMyPublicCert (callback: (err: Error, publicCert: string) => void) {
101 const certPath = join(CONFIG.STORAGE.CERT_DIR, PUBLIC_CERT_NAME)
102 fs.readFile(certPath, 'utf8', callback)
105 // ---------------------------------------------------------------------------
110 createCertsIfNotExist,
117 // ---------------------------------------------------------------------------
119 function certsExist (callback: (err: Error, certsExist: boolean) => void) {
120 const certPath = join(CONFIG.STORAGE.CERT_DIR, PRIVATE_CERT_NAME)
121 fs.access(certPath, function (err) {
122 // If there is an error the certificates do not exist
124 return callback(null, exists)
128 function createCerts (callback: (err: Error) => void) {
129 certsExist(function (err, exist) {
130 if (err) return callback(err)
132 if (exist === true) {
133 const errorMessage = 'Certs already exist.'
134 logger.warning(errorMessage)
135 return callback(new Error(errorMessage))
138 logger.info('Generating a RSA key...')
140 const privateCertPath = join(CONFIG.STORAGE.CERT_DIR, PRIVATE_CERT_NAME)
141 const genRsaOptions = {
142 'out': privateCertPath,
145 openssl.exec('genrsa', genRsaOptions, function (err) {
147 logger.error('Cannot create private key on this pod.')
151 logger.info('RSA key generated.')
152 logger.info('Managing public key...')
154 const publicCertPath = join(CONFIG.STORAGE.CERT_DIR, 'peertube.pub')
156 'in': privateCertPath,
158 'out': publicCertPath
160 openssl.exec('rsa', rsaOptions, function (err) {
162 logger.error('Cannot create public key on this pod.')
166 logger.info('Public key managed.')
167 return callback(null)