一、具体实现

const _ = require("lodash");
const NodeRSA = require("node-rsa");
const BASE64 = "base64";
const UTF8 = "utf8";
const pkcsSize = 2048;
const pkcsType = "pkcs8";

const key = new NodeRSA({
  b: pkcsSize, //可以知道位数
});

// let data = {
//   b: [
//     { f: "3", e: "2", d: "1" },
//     { j: "6", i: "5", h: "4" },
//   ],
//   a: "100",
//   c: { k: "10", m: "11" },
// };
// 用loadash实现判断逻辑
// let newObj = "";
// //排序的函数
// function objKeySort(arys) {
//   //先用Object内置类的keys方法获取要排序对象的属性名数组，再利用Array的sort方法进行排序
//   if (arys === null) {
//     return;
//   }
//   const newkey = Object.keys(arys).sort();
//   for (let i = 0; i < newkey.length; i++) {
//     const newArrKey = newkey[i];
//     const newArrOne = arys[newkey[i]];
//     //遍历newkey数组
//     if (_.isArray(newArrOne)) {
//       for (let j = 0; j < newArrOne.length; j++) {
//         objKeySort(newArrOne[j]);
//       }
//     } else if (_.isPlainObject(newArrOne)) {
//       objKeySort(newArrOne);
//     } else {
//       newObj += [newArrKey] + "=" + newArrOne + "&";
//     }
//   }
//   return newObj.substring(0, newObj.length - 1);
// }

// 
var _toString = Object.prototype.toString;
function toRawType(value) {
  return _toString.call(value).slice(8, -1);
}

let newObj = "";
//排序的函数
function objKeySort(arys) {
  //先用Object内置类的keys方法获取要排序对象的属性名数组，再利用Array的sort方法进行排序
  if (arys === null) {
    return;
  }
  const newkey = Object.keys(arys).sort();
  for (let i = 0; i < newkey.length; i++) {
    const newArrKey = newkey[i];
    const newArrOne = arys[newkey[i]];
    //遍历newkey数组
    if (toRawType(newArrOne) === "Array") {
      for (let j = 0; j < newArrOne.length; j++) {
        objKeySort(newArrOne[j]);
      }
    } else if (toRawType(newArrOne) === "Object") {
      objKeySort(newArrOne);
    } else {
      newObj += [newArrKey] + "=" + newArrOne + "&";
    }
  }
  return newObj.substring(0, newObj.length - 1);
}

function genSign(buffer, privatePem) {
  // privatePem 为不携带-----BEGIN PRIVATE KEY-----的内容
  key.importKey(privatePem, pkcsType + "-private-pem");
  key.setOptions({ signingScheme: "sha1" });
  let sign = key.sign(Buffer.from(buffer), BASE64).toString(BASE64);
  // console.log("\n使用私钥签名:", sign);
  return sign;
}

function verifySign(buffer, signature, publicPem) {
 // privatePem 为不携带-----BEGIN PUBLIC KEY-----的内容
  key.importKey(publicPem, pkcsType + "-public-pem");
  let result = key.verify(Buffer.from(buffer), signature, "Buffer", BASE64);
  // console.log("\n验证签名结果", result);
  return result;
}

exports = module.exports = { objKeySort, genSign, verifySign };

二、如何使用

const buffer = objKeySort(pay_request);
const signature = genSign(buffer, PRIVATE_KEY);

// 校验签名是否成功
// const res = verifySign(buffer, signature, PUBLIC_KEY);
// true为成功，false为失败

三、参考资料

const fs = require("fs");
const NodeRSA = require("node-rsa");
const BASE64 = "base64";
const UTF8 = "utf8";
const pkcsSize = 2048;
const str = "服务端测试 -> miaomiaomiao~~~";
demo();
function demo() {
  pkcsType = "pkcs8"; //不为空则 设置为传入参数，为空则 设置为 pkcs8
  console.log("pkcsType=" + pkcsType);

  // 1.创建RSA对象，并指定 秘钥长度
  var key = new NodeRSA({ b: pkcsSize });
  key.setOptions({ encryptionScheme: "pkcs1" }); //指定加密格式
  key.setOptions({ signingScheme: "sha1" }); //指定加签格式

  // 2.生成 公钥私钥，使用 pkcs8标准，pem格式
  var publicPem = key.exportKey(pkcsType + "-public-pem"); //制定输出格式
  var privatePem = key.exportKey(pkcsType + "-private-pem");
  //console.log(key.$options);
  console.log(pkcsType + "公钥:\n", publicPem);
  console.log(pkcsType + "私钥:\n", privatePem);

  // write public key
  fs.openSync("keys/public.pem", "w");
  fs.writeFileSync("keys/public.pem", publicPem, "utf8");

  // write private key
  fs.openSync("keys/private.pem", "w");
  fs.writeFileSync("keys/private.pem", privatePem, "utf8");

  //---------------------demo1：服务端私钥加密公钥解密-------------------------------
  // 3.使用 私钥 加密 数据，并指定 字符编码 和 字符集
  var encryData = key.encryptPrivate(str, BASE64, UTF8);
  console.log("\n私钥加密后的数据：\n", encryData); //加密后数据为 base64 编码

  // 4.使用 公钥 解密 数据，并指定字符集
  var decryptData = key.decryptPublic(encryData, UTF8);
  console.log("\n公钥解密后的数据：\n", decryptData);

  //---------------------demo2：服务端加载公钥后解密----------------------
  // 1.创建RSA对象，并指定 秘钥长度
  var publicKey = new NodeRSA({ b: pkcsSize });

  // 2.导入 公钥，并指定使用 pkcs标准，pem格式
  publicKey.importKey(publicPem, pkcsType + "-public-pem");

  // 3.使用 公钥 解密数据
  var decrypted = publicKey.decryptPublic(encryData, UTF8);
  console.log("\n使用公钥解密后的数据：\n", decrypted);

  //---------------------demo3：服务端使用私钥签名------------------------

  // 1. 私钥
  var privateKey = new NodeRSA({ b: pkcsSize });

  // 2.导入 私钥，并指定使用 pkcs标准，pem格式
  privateKey.importKey(privatePem, pkcsType + "-private-pem");

  var signedData = privateKey.sign(Buffer.from(str), BASE64).toString(BASE64);

  console.log("\n使用私钥签名:", signedData);

  //---------------------demo4：服务端使用公钥验证签名---------------------

  var result = publicKey.verify(Buffer.from(str), signedData, "Buffer", BASE64);

  console.log("\n验证签名结果", result);
}