helpers/peertubeCrypto.js

   1 ;(function () {
   2   'use strict'
   3
   4   var config = require('config')
   5   var crypto = require('crypto')
   6   var fs = require('fs')
   7   var openssl = require('openssl-wrapper')
   8   var path = require('path')
   9   var ursa = require('ursa')
  10
  11   var logger = require('./logger')
  12
  13   var certDir = path.join(__dirname, '..', config.get('storage.certs'))
  14   var algorithm = 'aes-256-ctr'
  15
  16   var peertubeCrypto = {
  17     checkSignature: checkSignature,
  18     createCertsIfNotExist: createCertsIfNotExist,
  19     decrypt: decrypt,
  20     encrypt: encrypt,
  21     getCertDir: getCertDir,
  22     sign: sign
  23   }
  24
  25   function checkSignature (public_key, raw_data, hex_signature) {
  26     var crt = ursa.createPublicKey(public_key)
  27     var is_valid = crt.hashAndVerify('sha256', new Buffer(raw_data).toString('hex'), hex_signature, 'hex')
  28     return is_valid
  29   }
  30
  31   function createCertsIfNotExist (callback) {
  32     certsExist(function (exist) {
  33       if (exist === true) {
  34         return callback(null)
  35       }
  36
  37       createCerts(function (err) {
  38         return callback(err)
  39       })
  40     })
  41   }
  42
  43   function decrypt (key, data, callback) {
  44     fs.readFile(getCertDir() + 'peertube.key.pem', function (err, file) {
  45       if (err) return callback(err)
  46
  47       var my_private_key = ursa.createPrivateKey(file)
  48       var decrypted_key = my_private_key.decrypt(key, 'hex', 'utf8')
  49       var decrypted_data = symetricDecrypt(data, decrypted_key)
  50
  51       return callback(null, decrypted_data)
  52     })
  53   }
  54
  55   function encrypt (public_key, data, callback) {
  56     var crt = ursa.createPublicKey(public_key)
  57
  58     symetricEncrypt(data, function (err, dataEncrypted) {
  59       if (err) return callback(err)
  60
  61       var key = crt.encrypt(dataEncrypted.password, 'utf8', 'hex')
  62       var encrypted = {
  63         data: dataEncrypted.crypted,
  64         key: key
  65       }
  66
  67       callback(null, encrypted)
  68     })
  69   }
  70
  71   function getCertDir () {
  72     return certDir
  73   }
  74
  75   function sign (data) {
  76     var myKey = ursa.createPrivateKey(fs.readFileSync(certDir + 'peertube.key.pem'))
  77     var signature = myKey.hashAndSign('sha256', data, 'utf8', 'hex')
  78
  79     return signature
  80   }
  81
  82   // ---------------------------------------------------------------------------
  83
  84   module.exports = peertubeCrypto
  85
  86   // ---------------------------------------------------------------------------
  87
  88   function certsExist (callback) {
  89     fs.exists(certDir + 'peertube.key.pem', function (exists) {
  90       return callback(exists)
  91     })
  92   }
  93
  94   function createCerts (callback) {
  95     certsExist(function (exist) {
  96       if (exist === true) {
  97         var string = 'Certs already exist.'
  98         logger.warning(string)
  99         return callback(new Error(string))
 100       }
 101
 102       logger.info('Generating a RSA key...')
 103       openssl.exec('genrsa', { 'out': certDir + 'peertube.key.pem', '2048': false }, function (err) {
 104         if (err) {
 105           logger.error('Cannot create private key on this pod.')
 106           return callback(err)
 107         }
 108         logger.info('RSA key generated.')
 109
 110         logger.info('Manage public key...')
 111         openssl.exec('rsa', { 'in': certDir + 'peertube.key.pem', 'pubout': true, 'out': certDir + 'peertube.pub' }, function (err) {
 112           if (err) {
 113             logger.error('Cannot create public key on this pod.')
 114             return callback(err)
 115           }
 116
 117           logger.info('Public key managed.')
 118           return callback(null)
 119         })
 120       })
 121     })
 122   }
 123
 124   function generatePassword (callback) {
 125     crypto.randomBytes(32, function (err, buf) {
 126       if (err) return callback(err)
 127
 128       callback(null, buf.toString('utf8'))
 129     })
 130   }
 131
 132   function symetricDecrypt (text, password) {
 133     var decipher = crypto.createDecipher(algorithm, password)
 134     var dec = decipher.update(text, 'hex', 'utf8')
 135     dec += decipher.final('utf8')
 136     return dec
 137   }
 138
 139   function symetricEncrypt (text, callback) {
 140     generatePassword(function (err, password) {
 141       if (err) return callback(err)
 142
 143       var cipher = crypto.createCipher(algorithm, password)
 144       var crypted = cipher.update(text, 'utf8', 'hex')
 145       crypted += cipher.final('hex')
 146       callback(null, { crypted: crypted, password: password })
 147     })
 148   }
 149 })()