Nodejs环境Eggjs加签验签示例

加签验签概念

加签：

用Hash函数把原始报文生成报文摘要，然后用私钥对这个摘要进行加密，就得到这个报文对应的数字签名。「注意啦，加签过程要包含一些特殊的私有的东西，比如个人私钥。」 通常来说呢，请求方会把「数字签名和报文原文」一并发送给接收方。

验签：

接收方拿到原始报文和数字签名后，用「同一个Hash函数」从报文中生成摘要A。另外，用对方提供的公钥对数字签名进行解密，得到摘要B，对比A和B是否相同，就可以得知报文有没有被篡改过。

如下使用Egg.js示例代码

// 获取签名

router.post('/api/sign/signature', controller.sign.signature);

// 验证签名

router.post('/api/sign/verifySign', controller.sign.verifySign);

### 将报文生成签名返回示例POST http://localhost:7001/api/sign/signature HTTP/1.1
content-type: application/json; charset=utf-8
 
{
    "name": "dss",
    "age": 10
}
 
### 将签名后的报文及相关参数去验证签名
POST http://localhost:7001/api/sign/verifySign HTTP/1.1
content-type: application/json; charset=utf-8
 
{
  "name": "dss",
  "age": "10",
  "timestamp": "1658732565",
  "nonce": "emjlwsezdmq",
  "appid": "11111",
  "params": "name=dss&age=10",
  "signature": "XXXXX"
}

module.exports = class SignController extends Controller {
  async signature(ctx) {
    try {
      const pageData = ctx.request.body || '';
      const startTime = new Date();
      // 将报文生成签名
      const result = await ctx.service.sign.signature(pageData);
      ctx.logger.info(`sign: ${pageData.name}用时：${Date.now() - startTime}ms`);
      ctx.body = result;
    } catch (error) {
      ctx.logger.error(`signature失败：${error.message}`);
      return {
        ...getCodeMsg('signErr', { responseMsg: error.message }),
        data: ''
      };
    }
  }
 
  async verifySign(ctx) {
    ctx.body = 'verifySign';
  }
};

const Service = require('egg').Service;
const qs = require('qs');
const debug = require('debug')('app: SignService');
const {
  verifySign,
  raw,
  getSign,
  getKeypair,
  signature,
  createTimestamp,
  createNonceStr
} = require('../common/utils/sign');
 
module.exports = class SignService extends Service {
  async signature(params) {
    const { ctx } = this;
    const keypair = getKeypair();
    const publicKey = keypair.publicKey;
    const privateKey = keypair.privateKey;
 
    debug(`publicKey:${publicKey}`);
    debug(`privateKey:${privateKey}`);
 
    // 密钥
    const secret = 'kuaida-service';
    // 针对不同的调用方分配不同的appid
    const appid = '5000';
 
    const args = {
      // 生成签名的时间戳
      timestamp: createTimestamp(),
      // 生成签名的随机串
      nonce: createNonceStr(),
      // 密钥
      secret: secret,
      // 授权调用方唯一标识
      appid: appid,
      // 请求报文
      params: qs.stringify(params)
    };
 
    /**
     * 签名算法
     * timestamp + nonce 两个参数来控制请求有效性，防止重放攻击
     * 对所有待签名参数按照字段名的ASCII 码从小到大排序后，
     * 使用params键值对的格式（ 即key1 = value1 & key2 = value2…） 拼接成字符串。
     * 这里需要注意的是所有参数名均为小写字符。 对string1作sha1加密， 字段名和字段值都采用原始值， 不进行URL 转义。
     */
    const msg = raw(args);
    // 加签
    const sign = signature(msg, privateKey);
    args.signature = sign;
    // const vv = verifySign(msg, sign, publicKey);
    debug(`args: ${JSON.stringify(args)}`);
    // debug(`vv:${vv}`);
    return args;
  }
};

common/utils/sign/sign.js

// API 接口签名验证
// 请求身份是否合法？
// 请求参数是否被篡改？
// 请求是否唯一
// timestamp+nonce方案: nonce指唯一的随机字符串，用来标识每个被签名的请求,timestamp是否在1分钟内
const sm2 = require('sm-crypto').sm2;
const crypto = require('crypto');
const publicKey = ''; //keypair.publicKey // 公钥
const privateKey = ''; //keypair.privateKey // 私钥
 
/**
 * 生成签名
 * @param {*} msg
 * @param {*} privateKey
 * @returns
 */
exports.signature = function (msg, privateKey) {
  const sigValueHex = sm2.doSignature(msg, privateKey, { hash: true, der: true });
  return sigValueHex;
};
 
// sha1加密
exports.getSign = function (str) {
  let shasum = crypto.createHash('sha1');
  shasum.update(str);
  str = shasum.digest('hex');
  return str;
};
 
/**
 * 验证签名
 * @param {*} msg
 * @param {*} vSign vsign是java生成的
 * @param {*} publicKey
 * @returns
 */
exports.verifySign = function (msg, vSign, publicKey) {
  const verifyResult = sm2.doVerifySignature(msg, vSign, publicKey, { hash: true, der: true });
  return verifyResult;
};
 
/**
 * 获取公钥、私钥
 * @returns KeyPairHex
 */
exports.getKeypair = function () {
  return sm2.generateKeyPairHex('kuaida-service');
};
 
/**
 * 生成签名的随机串
 * @return {字符串}
 */
exports.createNonceStr = function () {
  return Math.random().toString(36).substring(2, 15);
};
 
/**
 * 生成签名的时间戳
 * @returns {字符串}
 */
exports.createTimestamp = function () {
  return parseInt(new Date().getTime() / 1000).toString();
};
 
/**
 * 签名算法
 * timestamp + nonce 两个参数来控制请求有效性，防止重放攻击
 * 对所有待签名参数按照字段名的ASCII 码从小到大排序后，
 * 使用params键值对的格式（ 即key1 = value1 & key2 = value2…） 拼接成字符串。
 * 这里需要注意的是所有参数名均为小写字符。 对string1作sha1加密， 字段名和字段值都采用原始值， 不进行URL 转义。
 * @param  {对象} params 签名所需参数对象
 * @return {字符串}    排序后生成字符串
 */
exports.raw = function (params) {
  // 字典排序
  var keys = Object.keys(params);
  keys = keys.sort();
 
  var newArgs = {};
  keys.forEach(function (key) {
    newArgs[key.toLowerCase()] = params[key];
  });
 
  var string = '';
  for (var k in newArgs) {
    string += '&' + k + '=' + newArgs[k];
  }
 
  string = string.substring(1);
 
  return string;
};

签名中间件，Sign Middleware

egg中间件配置

config.default.js

exports.middleware = ['signature'];

exports.signature = {

path: [/^\/api\/sign\/verifySign\/*/, /^\/uploads/]

};

const debug = require('debug')('app: SignMiddleware');
const { verifySign, getKeypair, raw } = require('../common/utils/sign');
 
module.exports = (options) => {
  return async function signature(ctx, next) {
    const path = options.path;
    const isPath = path && Array.isArray(path);
 
    if (!isPath) {
      return;
    }
 
    const matchPath = path.some((item) => item.test(ctx.path));
 
    // 需要验签
    if (matchPath) {
      const keypair = getKeypair();
      const publicKey = keypair.publicKey;
      const secret = 'kuaida-service';
      const appid = '5000';
      const { timestamp, nonce, params, signature } = ctx.request.body;
      const msg = {
        timestamp: timestamp,
        nonce: nonce,
        secret: secret,
        appid: appid,
        params: params
      };
      const str = raw(msg);
      const verify = verifySign(str, signature, publicKey);
      if (verify) {
        await next();
      } else {
        ctx.body = '验签失败';
      }
    } else {
      await next();
    }
  };
};