// 獲取簽名
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
}
### 將簽名后的報文及相關(guān)參數(shù)去驗證簽名
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';
    // 針對不同的調(diào)用方分配不同的appid
    const appid = '5000';
 
    const args = {
      // 生成簽名的時間戳
      timestamp: createTimestamp(),
      // 生成簽名的隨機串
      nonce: createNonceStr(),
      // 密鑰
      secret: secret,
      // 授權(quán)調(diào)用方唯一標(biāo)識
      appid: appid,
      // 請求報文
      params: qs.stringify(params)
    };
 
    /**
     * 簽名算法
     * timestamp + nonce 兩個參數(shù)來控制請求有效性，防止重放攻擊
     * 對所有待簽名參數(shù)按照字段名的ASCII 碼從小到大排序后，
     * 使用params鍵值對的格式（ 即key1 = value1 & key2 = value2…） 拼接成字符串。
     * 這里需要注意的是所有參數(shù)名均為小寫字符。 對string1作sha1加密， 字段名和字段值都采用原始值， 不進(jìn)行URL 轉(zhuǎn)義。
     */
    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;
  }
};

// API 接口簽名驗證
// 請求身份是否合法？
// 請求參數(shù)是否被篡改？
// 請求是否唯一
// timestamp+nonce方案: nonce指唯一的隨機字符串，用來標(biāo)識每個被簽名的請求,timestamp是否在1分鐘內(nèi)
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 兩個參數(shù)來控制請求有效性，防止重放攻擊
 * 對所有待簽名參數(shù)按照字段名的ASCII 碼從小到大排序后，
 * 使用params鍵值對的格式（ 即key1 = value1 & key2 = value2…） 拼接成字符串。
 * 這里需要注意的是所有參數(shù)名均為小寫字符。 對string1作sha1加密， 字段名和字段值都采用原始值， 不進(jìn)行URL 轉(zhuǎn)義。
 * @param  {對象} params 簽名所需參數(shù)對象
 * @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;
};

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();
    }
  };
};