基于 NodeJs 实现结合 RSA 和 AES 加密算法的消息交换加密传输

2020-12-27 1 条评论 141 次阅读被赞了 0 次

敏感消息交换对正确性和安全性都有比较强的要求。

使用消息摘要算法对消息体计算和验证摘要，可以防止消息传输过程中被篡改为非法消息值；使用加密算法加密消息体，可以防止消息传输过程中被拦截并读取。二者结合则可以实现较强的安全性消息交换。

1 保证消息交换正确性

消息传输过程中可能被中间人篡改。比如 A 发送消息转账给 B，中间人在消息转发过程中进行了拦截，解密消息体并篡改为转账给 C，而且篡改转账额度，由此造成可能不可逆转的损失。

消息摘要可以保证消息传输的正确性。主要思路比较简单：对要发送对消息体使用消息摘要算法（如 md5、sha256、sha1、hashMAC 等）计算出摘要值，接收方收到消息后，使用相同的摘要算法对消息体计算摘要值，将其与接收到的摘要值比对验证是否一致。

该过程中需要注意的重点是要保障摘要算法的保密性。

2 消息交换加密传输

对称加密算法使用共同的密文对消息体加密，其特点是速度快效率高，缺点是需发送和接收方共享秘钥，任何一方泄露密文和加密算法则加密失效。非对称加密算法采用公私钥对，发送方使用公钥对消息体加密、接收方使用私钥对消息体解密（反之亦可），接收方只需保管好自己独有的秘钥，即可保障加密消息不被泄露。但其加密速度慢效率低，故一般不用其进行大消息体的加密。

将对称加密算法和非对称加密算法结合使用，则可以达到相对可行有效的消息交换加密传输。下文中非对称加密算法以 RSA 为例，对称加密算法以 AES 为例。

主要思路为：通过 RSA 算法加密 AES 算法使用的密钥，通过 AES 算法加密消息体，然后将加密的密钥和消息体发送给对方；对方收到消息后，使用 RSA 算法解密 AES 密钥，用解密后的密钥解密消息体，由此得到解密后的消息；接收方在回复消息的过程中重复类似过程，由此实现消息交换加密传输。

我们以客户端与服务端消息通信为例，详细流程概述如下：

准备：

客户端生成本地的 RSA 公私钥 clientPublicKey 和 clientPrivateKey
服务端生成远端的 RSA 公私钥 remotePublicKey 和 remotePublicKey

消息交换流程：

公钥交换：客户端发起请求，发送本地的 RSA 公钥 localPublicKey，并获取服务端的 RSA 公钥 remotePublicKey，用于加密对称算法（AES）的密钥
客户端生成随机的 16 位字符 aesKey，用于对称算法（AES）的密钥
客户端使用从服务器获取的公钥 remotePublicKey 对 aesKey 进行 RSA 加密，得到加密的值 aesKeyEncrypted
客户端使用 aesKey 对要发送的消息体 body 加密，得到 bodyAesEncrypted
客户端使用 http post 方法发送消息体 {aesKeyEncrypted, bodyAesEncrypted }。其中 localPublicKey 用于服务器加密返回的消息
服务端接收到消息体后，使用其 RSA 私钥 remotePrivateKey 对 aesKeyEncrypted 解密得到 AES 算法密钥 aesKey
服务端使用 AES 密钥 aesKey 对 bodyAesEncrypted 解密，得到 body。至此客户端到服务端的加密消息传输完毕
服务端使用 localPublicKey 重复上述 1-5 过程对回复消息加密并发送，客户端重复上述 6-7 过程对接收到的消息解密

通过以上流程，使得整个传输过程中的消息都是加密无法被读取的，当然前提是需保证双方的 RSA 秘密未被泄露。
此外，如果加上消息摘要算法对消息体签名，中间人不知道摘要算法则无法伪造有效的消息。所以结合消息摘要算法和消息加密算法，则可以进一步增强消息传递过程。当然，在对等双方的消息传递中，对方不一定是可信的，还是存在摘要算法泄露的风险。

上述流程可以保证消息的安全性，但无法保证其真实性，因为中间人也可以不解密消息，使用拦截到的公钥加密消息，发送伪造的消息体（伪造消息体和发送方公钥）。
解决办法则是引入第三方权威中间人机构，消息接收方在收到消息时，先通过中间人机构对来自消息发送方的公钥进行可靠性认证。

上述流程默认客户端与服务端为对等的双方。其实该流程也可以进行简化：客户端不维护本地 RSA 公私钥，但缓存随机生成的 RES 秘钥；服务端在得到消息后，回复消息时使用相同的 RES 算法和解密得到的客户端 RES 秘钥加密消息体，客户端收到消息后使用 RES 秘钥解密。其实简化流程中再加上颁发证书的第三方权威机构认证流程，就是典型的 HTTPS 消息加密传输的基本原理。

3 基于 nodejs 的消息交换加密传输示例

3.1 生成非对称加密 RSA 算法公私钥

使用 crypto 模块：

import crypto from 'crypto';

/** 使用 crypto 模块生成 RSA 公私钥 */
export function genRsaKeyByCrypto(options?: crypto.RSAKeyPairOptions<"pem", "pem">) {
    options = {
        modulusLength: 1024,
        publicKeyEncoding: {
            type: 'pkcs1',
            format: 'pem'
        },
        privateKeyEncoding: {
            type: 'pkcs8',
            format: 'pem',
            cipher: 'aes-256-cbc',
            passphrase: '',
        },
        ...options,
    };
    const result = crypto.generateKeyPairSync('rsa', options);

    return result;
}

使用 node-rsa 库：

import NodeRSA from 'node-rsa';

export function genRsaKeyPairByNodeRsa() {
    const key = new NodeRSA({ b: 1024 });
    key.setOptions({encryptionScheme: 'pkcs1'});
    return { publicKey: key.exportKey('public'), privateKey: key.exportKey('private') };
}

生成并保存 RSA 公私钥：

export function saveRsaKey(publicKeyPath='public.pem', privateKeyPath='private.pem', isForce = false) {
    publicKeyPath = path.resolve(publicKeyPath);
    privateKeyPath = path.resolve(privateKeyPath);

    if (existsSync(publicKeyPath) && !isForce) {
        // console.log('公钥文件已存在');
        return { publicKey: readFileSync(publicKeyPath), privateKey: readFileSync(privateKeyPath) };
    } else {
        console.log('重新生成公私钥文件');
    }

    // const { publicKey, privateKey } = await genRsaKeyByCrypto();
    const { publicKey, privateKey } = genRsaKeyPairByNodeRsa();

    if (!existsSync(path.dirname(publicKeyPath))) mkdirSync(path.dirname(publicKeyPath), {recursive: true});

    writeFileSync(publicKeyPath, publicKey);
    console.log('写入公钥文件：', publicKeyPath);
    writeFileSync(privateKeyPath, privateKey);
    console.log('写入私钥文件：', privateKeyPath);

    return { publicKey, privateKey };
}

3.2 RSA 算法加密与解密

使用 crypto 模块示例：

/**
 * RSA最大加密明文大小
 */
const MAX_ENCRYPT_BLOCK = 117 - 31;
/**
 * RSA最大解密密文大小
 */
const  MAX_DECRYPT_BLOCK = 128;

/**
 * rsa 公钥加密
 */
export function publicEncrypt(data, publicKey, outputEncoding: BufferEncoding = 'base64') {
    // 加密信息用buf封装
    const buf = Buffer.from(data, 'utf-8');
    const inputLen = buf.byteLength;
    const bufs = [];
    let offSet = 0;
    let endOffSet = MAX_ENCRYPT_BLOCK;
    // 分段加密
    while (inputLen - offSet > 0) {
        if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
            const bufTmp = buf.slice(offSet, endOffSet);
            bufs.push(crypto.publicEncrypt({key: publicKey, passphrase: '', padding: crypto.constants.RSA_PKCS1_PADDING}, bufTmp));
        } else {
            const bufTmp = buf.slice(offSet, inputLen);
            bufs.push(crypto.publicEncrypt({key: publicKey, passphrase: '', padding: crypto.constants.RSA_PKCS1_PADDING}, bufTmp));
        }
        offSet += MAX_ENCRYPT_BLOCK;
        endOffSet += MAX_ENCRYPT_BLOCK;
    }
    const result = Buffer.concat(bufs).toString(outputEncoding);
    return result;
}

/**
 * rsa 私钥解密
 */
export function privateDecrypt(data, privateKey, inputEncoding: BufferEncoding = 'base64') {
    // 经过base64编码的密文转成buf
    const buf = data instanceof Buffer ? data : Buffer.from(data, inputEncoding);
    const inputLen = buf.byteLength;
    const bufs = [];
    let offSet = 0;
    let endOffSet = MAX_DECRYPT_BLOCK;
    // 分段加密
    while (inputLen - offSet > 0) {
        if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
            const bufTmp = buf.slice(offSet, endOffSet);
            bufs.push(crypto.privateDecrypt({key: privateKey, passphrase: '', padding: crypto.constants.RSA_PKCS1_PADDING}, bufTmp));
        } else {
            const bufTmp = buf.slice(offSet, inputLen);
            bufs.push(crypto.privateDecrypt({key: privateKey, passphrase: '', padding: crypto.constants.RSA_PKCS1_PADDING}, bufTmp));
        }
        offSet += MAX_DECRYPT_BLOCK;
        endOffSet += MAX_DECRYPT_BLOCK;
    }
    const result = Buffer.concat(bufs).toString();

    return result;
}

使用 node-rsa 库：

import NodeRSA from 'node-rsa';

/**
 * rsa 公钥加密
 */
export function rsaEncrypt(data, publicKey, outputEncoding = 'base64') {
    const key = new NodeRSA({ b: 1024 });
    key.importKey(publicKey, 'public');
    let encryData = key.encrypt(data, outputEncoding, 'utf8');
    if (outputEncoding === 'hex' || outputEncoding === 'binary') encryData = Buffer.from(encryData, outputEncoding);
    return encryData;
}
/**
 * rsa 私钥解密
 */
export function rsaDecrypt(data, privateKey) {
    const key = new NodeRSA({ b: 1024 });
    key.importKey(privateKey, 'private');
    const decryptData = key.decrypt(data, 'utf8');
    return decryptData;
}

3.3 AES 算法加密与解密

AES 加密与解密相对比较简单，只需要传入对应的 data 数据与解密密文即可：

import crypto from 'crypto';

/** aes 加密 */
export aesEncrypt(data, passKey, outputEncoding = 'base64') {
    if (typeof data !== 'string') data = JSON.stringify(data);
    const cipherChunks = [];
    // const key = Buffer.from(passKey, 'utf8');
    const key= crypto.scryptSync(passKey, 'salt', 16);
    const iv = key; // Buffer.alloc(16, 0);
    const cipher = crypto.createCipheriv('aes-128-cbc', key, iv);
    cipher.setAutoPadding(true);
    cipherChunks.push(cipher.update(data, 'utf8', outputEncoding as any));
    cipherChunks.push(cipher.final(outputEncoding as any));
    return cipherChunks.join('');
}
/** aes 解密 */
export aesDecrypt(data, passKey, inputEncoding = 'base64') {
    const cipherChunks = [];
    // const key = Buffer.from(passKey, 'utf8');
    const key= crypto.scryptSync(passKey, 'salt', 16);
    const iv = key; // Buffer.alloc(16, 0);
    const decipher = crypto.createDecipheriv('aes-128-cbc', key, iv);
    decipher.setAutoPadding(true);
    cipherChunks.push(decipher.update(data, inputEncoding as any, 'utf8'));
    cipherChunks.push(decipher.final('utf8'));
    return cipherChunks.join('');
}

3.4 结合 AES 和 RSA 加密算法对消息体加密与解密

数据加密与解密实现：

/** 生成指定长度的字符串 */
export function genRandomAesKey(len = 16) {
    // return crypto.randomBytes(len).toString('utf-8');

    const result = [];
    for (let i = 0; i < len; i++) {
        let code = Math.round(Math.random() * 126);
        if (code < 33) code += 32;
        result.push( String.fromCharCode(code));
    }

    return result.join('');
}
/** （使用对方的公钥）数据加密，返回加密后的 key、data 以及本地公钥（用于给对方加密回据使用） */
export function dataEncrypt(data, remotePublicKey) {
    const aesKey = genRandomAesKey();
    // const localPublicKey = fs.readFileSync(config.publicKeyPath, {encoding: 'utf-8'});
    // if (!remotePublicKey) remotePublicKey = localPublicKey;
    const aesKeyEncrypted = rsaEncrypt(aesKey, remotePublicKey);
    const encryptedData = aesEncrypt(data, aesKey);

    return {key: aesKeyEncrypted, data: encryptedData, publicKey: localPublicKey};
}

export function dataDecrypt(encryptedData, aesKeyEncrypted, localPrivateKey) {
    // if (!localPrivateKey) localPrivateKey = fs.readFileSync(config.privateKeyPath, {encoding: 'utf-8'});
    const aesKey = rsaDecrypt(aesKeyEncrypted, localPrivateKey);
    const result = aesDecrypt(encryptedData, aesKey);
    try {
        return JSON.parse(result);
    } catch (_e) {
        return result;
    }
}

消息发送方数据加密与接收方数据解密：

// 发送方加密发送消息
const data = { user: 'lzwme', pwd: '123456' };
const remotePublicKey = '...';
const encryptedInfo = dataEncrypt(data);
console.log('数据加密：', encryptedInfo);

// 接受方收到消息体后解密消息
const localPrivateKey = '...';
const deCryptedInfo = dataDecrypt(encryptedInfo.key, encryptedInfo.data, localPrivateKey);
console.log('数据解密：', deCryptedInfo);

4 总结

本文主要介绍了结合使用对称加密算法(AES)和非对称加密算法(RSA)对消息交换双方消息加密传输的典型方案，并使用 nodejs 代码演示了主要流程的实现方式。在基于的浏览器/服务器(B/S)的服务中，浏览器端没有 nodejs 接口能力，可借助第三方库 crypto-js、jsencrypt 等提供的 API 实现相关加密和解密算法。