TypeScript crypto.createCipher函数代码示例

  public encrypt(file: string, algorithm: string, password: string): void {
    let cipher = createCipher(algorithm, password),
      cipherName = createCipher(algorithm, password),
      encryptedFileName,
      decrypted,
      encrypted,
      pathArray,
      fileName,
      path;

    pathArray = file.split('/');
    fileName = pathArray.pop();
    path = pathArray.join('/') + '/encrypted';

    mkdir(path);

    encryptedFileName = cipherName.update(fileName, 'utf8', 'hex');
    encryptedFileName += cipherName.final('hex');
    path += '/' + encryptedFileName;

    decrypted = createReadStream(file);
    encrypted = createWriteStream(path);

    decrypted
      .pipe(cipher)
      .pipe(encrypted);
  }

    export function encrypt(input:string, secret:string, callback: (result: string) => void) : void {
        
        if(input) {
            
            if(secret) {

                try {

                    var cipher = crypto.createCipher(algorithm, secret)
         
                    var result = cipher.update(input, 'utf8', 'hex') + cipher.final('hex')

                    callback(result)

                } catch( e) {

                    callback(null)
                }

                return
            }
        }

        callback(null)
    }

 encrypt(value) {
     let cipher = crypto.createCipher('aes-256-ctr', this.secretKey.value);
     let encrypted = cipher.update(value, 'utf8', 'binary');
     encrypted += cipher.final('binary');
     let hexVal = new Buffer(encrypted, 'binary');
     return hexVal.toString('base64');
 }

 export function encrypt(text: string, key: string): string {
     let cryptoKey = !key ? localKey : key;
     const cipher = crypto.createCipher('aes-256-cbc',cryptoKey);
     let encipheredContent: string = cipher.update(text,'utf8','hex');
     encipheredContent += cipher.final('hex');
     return encipheredContent;
 }

export function encrypt(text) {
  const cipher = crypto.createCipher('aes-256-cbc', process.env.APP_KEY);
  let crypted = cipher.update(text, 'utf8', 'base64');
  crypted += cipher.final('base64');

  return crypted;
}

export const cryptoPassword = (password: string) => {
  // 先 md5 不可逆加密
  const md5 = crypto.createHash('md5')
  md5.update(password, 'utf8')
  const md5Str = md5.digest('hex')
  // 再 aes 对称加密(密匙私有!)
  const aes = crypto.createCipher('aes-256-cbc', process.env.PASSWORD_SECRET)
  return aes.update(md5Str, 'utf8', 'hex') + aes.final('hex')
}

function crypto_cipher_decipher_string_test() {
	var key:Buffer = new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7]);
	var clearText:string = "This is the clear text.";
	var cipher:crypto.Cipher = crypto.createCipher("aes-128-ecb", key);
	var cipherText:string = cipher.update(clearText, "utf8", "hex");
	cipherText += cipher.final("hex");

	var decipher:crypto.Decipher = crypto.createDecipher("aes-128-ecb", key);
	var clearText2:string = decipher.update(cipherText, "hex", "utf8");
	clearText2 += decipher.final("utf8");

	assert.equal(clearText2, clearText);
}

 conn.query(q, args, (qerr, results) => {
     conn.release();
     if (qerr) {
         console.log('Error validating file id', qerr);
         return res.status(500).send({ Error: 'Internal Server Error' });
     }
     if (results.length < 1) {
         return res.send(404).send({ Error: 'No such file ID' });
     }
     const cipher = crypto.createCipher('aes256', new Buffer(APP_CONFIG.storage_key, 'base64'));
     let pl = req.pipe(zlib.createGzip()).pipe(cipher);
     store.store(fileid, pl, function (perr) {
         if (perr) {
             return res.status(500).send({ Error: perr });
         }
         return res.send({ Success: true });
     });
 });

function crypto_cipher_decipher_buffer_test() {
	var key:Buffer = new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7]);
	var clearText:Buffer = new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4]);
	var cipher:crypto.Cipher = crypto.createCipher("aes-128-ecb", key);
	var cipherBuffers:Buffer[] = [];
	cipherBuffers.push(cipher.update(clearText));
	cipherBuffers.push(cipher.final());

	var cipherText:Buffer = Buffer.concat(cipherBuffers);

	var decipher:crypto.Decipher = crypto.createDecipher("aes-128-ecb", key);
	var decipherBuffers:Buffer[] = [];
	decipherBuffers.push(decipher.update(cipherText));
	decipherBuffers.push(decipher.final());

	var clearText2:Buffer = Buffer.concat(decipherBuffers);

	assert.deepEqual(clearText2, clearText);
}

export function getEncAse192(str, secret = 'lqbw') {
  const cipher = crypto.createCipher('aes192', secret);
  let enc = cipher.update(str, 'utf8', 'hex');
  enc += cipher.final('hex');
  return enc;
}

//
// Encrypt the password hash using a secret from our config file.
// We do this so if an attacker acquired the database (e.g. through
// SQL injection) then the password hashes will be unreadable.
//
function encrypt(input: string): string {
    const cipher = crypto.createCipher('aes256', config.security.passwordSecret);
    let output = cipher.update(input, 'ascii', 'base64');
    output += cipher.final('base64');
    return output;
}

export function encrypt(text:string) : string {
  var cipher = crypto.createCipher(algorithm,config.secret);
  var crypted = cipher.update(text,'utf8','hex');
  crypted += cipher.final('hex');
  return crypted;
}

 /**
  * Encrypt
  * @param  {string} str
  * @param  {string} password
  * @param  {string} algo
  * @return {string}
  */
 public static encrypt(str: string, password: string, algo: string): string {
   let cipher = crypto.createCipher(algo, password);
   let crypted = cipher.update(str, 'utf8', 'hex');
   crypted += cipher.final('hex');
   return crypted;
 }

export function stringEncrypt(text: string, pass: string): string {
	let cipher = crypto.createCipher('aes-256-ctr', pass);
	let crypted = cipher.update(text, 'utf8', 'hex');
	crypted += cipher.final('hex');
	return crypted;
}

export function encrypt(text: string, key: string) {
    return evaluate('utf8', 'hex', text, createCipher(ALGORITHM, key));
}