gamerpc 7.1.1 → 7.1.3

package/test/utils/secp256k1.js

@@ -0,0 +1,444 @@
+/**
+ * secp256k1 加密单元测试
+ * 使用已知测试向量，验证 @noble/secp256k1 封装层与 elliptic 的等价性
+ *
+ * 测试向量来源：
+ *   - RFC 6979 (Deterministic ECDSA)
+ *   - Bitcoin BIP32 test vectors
+ *   - secp256k1 标准测试向量
+ */
+const assert = require('assert');
+const secp = require('../../src/utils/secp256k1');
+
+// ============================================================
+// Helper
+// ============================================================
+const hex = (buf) => Buffer.isBuffer(buf) ? buf.toString('hex') : buf;
+
+describe('secp256k1 封装层单元测试', function () {
+
+  // ==========================================================
+  // 1. 密钥生成
+  // ==========================================================
+  describe('密钥生成', function () {
+    it('generatePrivateKey: 生成 32 字节私钥', function () {
+      const priv = secp.generatePrivateKey();
+      assert(Buffer.isBuffer(priv));
+      assert.strictEqual(priv.length, 32);
+    });
+
+    it('generatePrivateKey: 连续两次生成的私钥不同', function () {
+      const a = secp.generatePrivateKey();
+      const b = secp.generatePrivateKey();
+      assert(!a.equals(b));
+    });
+
+    it('privateKeyVerify: 有效私钥返回 true', function () {
+      const priv = secp.generatePrivateKey();
+      assert.strictEqual(secp.privateKeyVerify(priv), true);
+    });
+
+    it('privateKeyVerify: 全零私钥返回 false', function () {
+      assert.strictEqual(secp.privateKeyVerify(Buffer.alloc(32, 0)), false);
+    });
+
+    it('privateKeyVerify: 超范围私钥返回 false', function () {
+      // n = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+      const n = Buffer.from('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', 'hex');
+      assert.strictEqual(secp.privateKeyVerify(n), false);
+    });
+
+    it('privateKeyVerify: 长度不是 32 返回 false', function () {
+      assert.strictEqual(secp.privateKeyVerify(Buffer.alloc(31, 1)), false);
+      assert.strictEqual(secp.privateKeyVerify(Buffer.alloc(33, 1)), false);
+    });
+  });
+
+  // ==========================================================
+  // 2. 公钥创建与验证
+  // ==========================================================
+  describe('公钥操作', function () {
+    // 已知测试向量：私钥 1 → 压缩公钥
+    // priv=1 → pub=0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
+    const PRIV_ONE = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex');
+    const PUB_ONE_COMPRESSED = '0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798'.toLowerCase();
+    const PUB_ONE_UNCOMPRESSED = '0479BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8'.toLowerCase();
+
+    it('publicKeyCreate: 已知私钥生成压缩公钥', function () {
+      const pub = secp.publicKeyCreate(PRIV_ONE, true);
+      assert.strictEqual(hex(pub), PUB_ONE_COMPRESSED);
+    });
+
+    it('publicKeyCreate: 已知私钥生成非压缩公钥', function () {
+      const pub = secp.publicKeyCreate(PRIV_ONE, false);
+      assert.strictEqual(hex(pub), PUB_ONE_UNCOMPRESSED);
+    });
+
+    it('publicKeyCreate: 默认生成压缩公钥', function () {
+      const pub = secp.publicKeyCreate(PRIV_ONE);
+      assert.strictEqual(pub.length, 33);
+    });
+
+    it('publicKeyConvert: 压缩→非压缩', function () {
+      const compressed = secp.publicKeyCreate(PRIV_ONE, true);
+      const uncompressed = secp.publicKeyConvert(compressed, false);
+      assert.strictEqual(hex(uncompressed), PUB_ONE_UNCOMPRESSED);
+    });
+
+    it('publicKeyConvert: 非压缩→压缩', function () {
+      const uncompressed = secp.publicKeyCreate(PRIV_ONE, false);
+      const compressed = secp.publicKeyConvert(uncompressed, true);
+      assert.strictEqual(hex(compressed), PUB_ONE_COMPRESSED);
+    });
+
+    it('publicKeyVerify: 有效公钥返回 true', function () {
+      assert.strictEqual(secp.publicKeyVerify(Buffer.from(PUB_ONE_COMPRESSED, 'hex')), true);
+      assert.strictEqual(secp.publicKeyVerify(Buffer.from(PUB_ONE_UNCOMPRESSED, 'hex')), true);
+    });
+
+    it('publicKeyVerify: 无效公钥返回 false', function () {
+      assert.strictEqual(secp.publicKeyVerify(Buffer.alloc(33, 0)), false);
+      assert.strictEqual(secp.publicKeyVerify(Buffer.alloc(0)), false);
+    });
+
+    it('generateKey → publicKeyCreate: 生成密钥对一致性', function () {
+      for (let i = 0; i < 10; i++) {
+        const priv = secp.generatePrivateKey();
+        const pubC = secp.publicKeyCreate(priv, true);
+        const pubU = secp.publicKeyCreate(priv, false);
+        // 验证压缩/非压缩表示同一公钥
+        const converted = secp.publicKeyConvert(pubC, false);
+        assert.strictEqual(hex(converted), hex(pubU));
+      }
+    });
+  });
+
+  // ==========================================================
+  // 3. 签名与验证 (RFC 6979 确定性签名)
+  // ==========================================================
+  describe('签名与验证', function () {
+    // RFC 6979 Appendix A.2.5 测试向量
+    // SHA-256("sample")
+    const RFC6979_PRIV = Buffer.from('C9AFA9D845BA75166B5C215767B1D6934E50C3DB36E89B127B8A622B120F6721', 'hex');
+    const RFC6979_MSG = Buffer.from('AF2BDBE1AA9B6EC1E2ADE1D694F41FC71A831D0268E9891562113D8A62ADD1BF', 'hex');
+    // 这个私钥对 "sample" 签名应该能验证
+    const SAMPLE_HASH = Buffer.from('AF2BDBE1AA9B6EC1E2ADE1D694F41FC71A831D0268E9891562113D8A62ADD1BF', 'hex');
+
+    it('sign: 生成 DER 签名', function () {
+      const sig = secp.sign(SAMPLE_HASH, RFC6979_PRIV);
+      assert(Buffer.isBuffer(sig));
+      // DER 签名长度大约 70-73 字节
+      assert(sig.length >= 68 && sig.length <= 73, `unexpected sig length: ${sig.length}`);
+    });
+
+    it('sign → verify: 签名后可成功验证 (同一密钥)', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey(); // 32 random bytes
+
+      const sig = secp.sign(msg, priv);
+      const result = secp.verify(msg, sig, pub);
+      assert.strictEqual(result, true);
+    });
+
+    it('verify: 错误公钥无法验证', function () {
+      const privA = secp.generatePrivateKey();
+      const privB = secp.generatePrivateKey();
+      const pubB = secp.publicKeyCreate(privB, true);
+      const msg = secp.generatePrivateKey();
+
+      const sig = secp.sign(msg, privA);
+      const result = secp.verify(msg, sig, pubB);
+      assert.strictEqual(result, false);
+    });
+
+    it('verify: 篡改消息无法验证', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey();
+
+      const sig = secp.sign(msg, priv);
+      const tampered = Buffer.from(msg);
+      tampered[0] ^= 1;
+      const result = secp.verify(tampered, sig, pub);
+      assert.strictEqual(result, false);
+    });
+
+    it('verify: 空签名返回 false', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey();
+      assert.strictEqual(secp.verify(msg, Buffer.alloc(0), pub), false);
+    });
+
+    it('verify: 空公钥返回 false', function () {
+      const priv = secp.generatePrivateKey();
+      const msg = secp.generatePrivateKey();
+      const sig = secp.sign(msg, priv);
+      assert.strictEqual(secp.verify(msg, sig, Buffer.alloc(0)), false);
+    });
+
+    it('确定性: 同一消息和私钥产生相同签名', function () {
+      const priv = secp.generatePrivateKey();
+      const msg = secp.generatePrivateKey();
+      const sig1 = secp.sign(msg, priv);
+      const sig2 = secp.sign(msg, priv);
+      assert(hex(sig1) === hex(sig2), 'deterministic signatures must be identical');
+    });
+
+    it('不同消息产生不同签名', function () {
+      const priv = secp.generatePrivateKey();
+      const msg1 = secp.generatePrivateKey();
+      const msg2 = secp.generatePrivateKey();
+      // 确保消息不同
+      while (msg1.equals(msg2)) {
+        msg2.fill(0);
+        msg2[0] = msg1[0] ^ 0xFF;
+      }
+      const sig1 = secp.sign(msg1, priv);
+      const sig2 = secp.sign(msg2, priv);
+      assert(!sig1.equals(sig2));
+    });
+  });
+
+  // ==========================================================
+  // 4. DER 格式转换
+  // ==========================================================
+  describe('DER 格式转换', function () {
+    it('toDER → fromDER: 往返转换', function () {
+      const priv = secp.generatePrivateKey();
+      const msg = secp.generatePrivateKey();
+      const der = secp.sign(msg, priv);
+
+      const compact = secp.fromDER(der);
+      assert.strictEqual(compact.length, 64);
+
+      const der2 = secp.toDER(compact);
+      // 重新解析验证
+      const compact2 = secp.fromDER(der2);
+      assert.strictEqual(hex(compact), hex(compact2));
+    });
+
+    it('toDER → verify: 往返后可验证', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey();
+      const der = secp.sign(msg, priv);
+
+      const compact = secp.fromDER(der);
+      const der2 = secp.toDER(compact);
+
+      assert.strictEqual(secp.verify(msg, der2, pub), true);
+    });
+
+    it('fromDER: 无效输入不崩溃', function () {
+      // 无效 DER 应该抛出或返回异常值
+      try {
+        secp.fromDER(Buffer.alloc(10, 0xFF));
+        // 如果没抛异常也是可以接受的，只要不崩溃
+      } catch (e) {
+        // 预期可能抛异常
+      }
+    });
+
+    it('toDER → isLowS: 低S值验证', function () {
+      const priv = secp.generatePrivateKey();
+      const msg = secp.generatePrivateKey();
+      const der = secp.sign(msg, priv);
+      assert.strictEqual(secp.isLowS(der), true, 'normal signature should have low S');
+    });
+
+    it('isLowS: 无效输入返回 false', function () {
+      assert.strictEqual(secp.isLowS(Buffer.alloc(0)), false);
+      assert.strictEqual(secp.isLowS(Buffer.alloc(10, 0xFF)), false);
+    });
+  });
+
+  // ==========================================================
+  // 5. ECDH 密钥交换
+  // ==========================================================
+  describe('ECDH 密钥交换', function () {
+    it('ecdh: 双方计算得到相同的共享密钥', function () {
+      const privA = secp.generatePrivateKey();
+      const privB = secp.generatePrivateKey();
+      const pubA = secp.publicKeyCreate(privA, true);
+      const pubB = secp.publicKeyCreate(privB, true);
+
+      const sharedA = secp.ecdh(pubB, privA); // A用B的公钥+自己的私钥
+      const sharedB = secp.ecdh(pubA, privB); // B用A的公钥+自己的私钥
+
+      assert.strictEqual(hex(sharedA), hex(sharedB));
+    });
+
+    it('ecdh: 返回 32 字节', function () {
+      const privA = secp.generatePrivateKey();
+      const privB = secp.generatePrivateKey();
+      const pubB = secp.publicKeyCreate(privB, true);
+
+      const shared = secp.ecdh(pubB, privA);
+      assert.strictEqual(shared.length, 32);
+    });
+
+    it('ecdh: 不同密钥对产生不同共享密钥', function () {
+      const p1 = secp.generatePrivateKey();
+      const p2 = secp.generatePrivateKey();
+      const p3 = secp.generatePrivateKey();
+      const pub2 = secp.publicKeyCreate(p2, true);
+      const pub3 = secp.publicKeyCreate(p3, true);
+
+      const s12 = secp.ecdh(pub2, p1);
+      const s13 = secp.ecdh(pub3, p1);
+      assert(!s12.equals(s13));
+    });
+  });
+
+  // ==========================================================
+  // 6. 公钥恢复
+  // ==========================================================
+  describe('公钥恢复', function () {
+    it('recover: 可从签名恢复原公钥', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const msg = secp.generatePrivateKey();
+      const sig = secp.sign(msg, priv);
+
+      // 尝试 4 种 recovery id
+      let recovered = null;
+      for (let j = 0; j < 4; j++) {
+        const rec = secp.recover(msg, sig, j, true);
+        if (rec && hex(rec) === hex(pub)) {
+          recovered = rec;
+          break;
+        }
+      }
+      assert(recovered !== null, 'should recover the original public key');
+    });
+
+    it('recover: 无效签名返回 null', function () {
+      const msg = secp.generatePrivateKey();
+      const invalidSig = Buffer.alloc(70, 0xFF);
+      const result = secp.recover(msg, invalidSig, 0, true);
+      assert.strictEqual(result, null);
+    });
+  });
+
+  // ==========================================================
+  // 7. Tweak 操作
+  // ==========================================================
+  describe('Tweak 操作', function () {
+    it('privateKeyTweakAdd: (key + tweak) % n', function () {
+      const priv = secp.generatePrivateKey();
+      const tweak = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex');
+      const tweaked = secp.privateKeyTweakAdd(priv, tweak);
+      assert.strictEqual(tweaked.length, 32);
+      assert(secp.privateKeyVerify(tweaked));
+      // 加1后应该与原私钥不同（除非原私钥恰好是n-1）
+      if (hex(priv) !== 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140') {
+        assert(!tweaked.equals(priv));
+      }
+    });
+
+    it('publicKeyTweakAdd: G * tweak + pubkey', function () {
+      const priv = secp.generatePrivateKey();
+      const pub = secp.publicKeyCreate(priv, true);
+      const tweak = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex');
+
+      const tweakedPub = secp.publicKeyTweakAdd(pub, tweak, true);
+      assert.strictEqual(tweakedPub.length, 33);
+      assert(secp.publicKeyVerify(tweakedPub));
+
+      // 验证：手动加1后私钥的公钥应等于原公钥加G
+      const tweakedPriv = secp.privateKeyTweakAdd(priv, tweak);
+      const expectedPub = secp.publicKeyCreate(tweakedPriv, true);
+      assert.strictEqual(hex(tweakedPub), hex(expectedPub),
+        'publicKeyTweakAdd result should match privateKeyTweakAdd + publicKeyCreate');
+    });
+  });
+
+  // ==========================================================
+  // 8. binding 常量
+  // ==========================================================
+  describe('常量', function () {
+    it('binding: 始终为 false (非native)', function () {
+      assert.strictEqual(secp.binding, false);
+    });
+  });
+
+  // ==========================================================
+  // 9. verifyData + secret 集成测试
+  // ==========================================================
+  describe('上层集成: verifyData & Secret', function () {
+    const verifyData = require('../../src/utils/verifyData');
+    const Secret = require('../../src/utils/secret');
+
+    it('generateKey → signObj → verifyObj: 完整流程', function () {
+      const keys = verifyData.generateKey();
+      assert.strictEqual(typeof keys.private, 'string');
+      assert.strictEqual(typeof keys.public, 'string');
+      assert.strictEqual(keys.private.length, 64); // hex of 32 bytes
+      assert.strictEqual(keys.public.length, 66);   // hex of 33 bytes (compressed)
+
+      const obj = { action: 'transfer', amount: 100, to: 'abc' };
+      const sig = verifyData.signObj(obj, keys.private);
+      assert.strictEqual(typeof sig, 'string');
+
+      const ok = verifyData.verifyObj(obj, sig, keys.public);
+      assert.strictEqual(ok, true);
+    });
+
+    it('generateKey: 用已知私钥生成公钥', function () {
+      const privHex = '0000000000000000000000000000000000000000000000000000000000000001';
+      const keys = verifyData.generateKey(privHex);
+      assert.strictEqual(keys.private, privHex);
+      // 压缩公钥，33字节 hex = 66 chars
+      assert.strictEqual(keys.public.length, 66);
+    });
+
+    it('verifyObj: 错误签名应失败', function () {
+      const keysA = verifyData.generateKey();
+      const keysB = verifyData.generateKey();
+      const obj = { msg: 'test' };
+      const sig = verifyData.signObj(obj, keysA.private);
+      // 用B的公钥验证A的签名 → 应该失败
+      const ok = verifyData.verifyObj(obj, sig, keysB.public);
+      assert.strictEqual(ok, false);
+    });
+
+    it('verifyObj: 篡改消息应失败', function () {
+      const keys = verifyData.generateKey();
+      const obj = { msg: 'test' };
+      const sig = verifyData.signObj(obj, keys.private);
+      const tampered = { msg: 'hacked' };
+      const ok = verifyData.verifyObj(tampered, sig, keys.public);
+      assert.strictEqual(ok, false);
+    });
+
+    it('Secret: 创建、握手、获取公钥', function () {
+      const secret = new Secret();
+      const pub = secret.input.getPublicKey();
+      assert(Buffer.isBuffer(pub));
+      assert.strictEqual(pub.length, 33);
+
+      const priv = secret.input.privateKey;
+      assert(Buffer.isBuffer(priv));
+      assert.strictEqual(priv.length, 32);
+      assert(secp.privateKeyVerify(priv));
+    });
+
+    it('Secret: 双方握手后共享密钥一致', function () {
+      const alice = new Secret();
+      const bob = new Secret();
+
+      const alicePub = alice.input.getPublicKey();
+      const bobPub = bob.input.getPublicKey();
+
+      alice.input.init(bobPub);
+      bob.output.init(alicePub);
+
+      // 双方应完成 ECDH
+      assert.strictEqual(alice.input.sid.length, 32);
+      assert.strictEqual(bob.output.sid.length, 32);
+    });
+  });
+
+});

package/webpack.config.js

@@ -5,15 +5,22 @@ module.exports = {
   entry: './src/index.js',
   output: {
       path: path.resolve(__dirname, 'lib'),
-      filename: `gamerpc${config.version}.js`
+      filename: `gamerpc${config.version}.js`,
+      library: {
+          name: 'toolkit',
+          type: 'umd',
+      },
+      globalObject: 'this',
   },
-  module:{
-    rules:[ 
-      {
-          test:/\.js$/,
-          exclude:/node_modules/,
-          loader:'babel-loader'
+  target: 'web',
+  mode: 'production',
+  resolve: {
+      fallback: {
+          "assert": require.resolve("assert/"),
+          "buffer": require.resolve("buffer/"),
+          "crypto": require.resolve("crypto-browserify"),
+          "stream": require.resolve("stream-browserify"),
+          "util": require.resolve("util/"),
       }
-    ]
   }
-}
+};

package/.babelrc

@@ -1,16 +0,0 @@
-{
-    "presets": [
-        ["env"],
-        ["es2015", { "modules": false }],
-        ["stage-2"]
-    ],
-    "plugins": [[
-        "transform-runtime",
-        {
-            "helpers": false,
-            "polyfill": false,
-            "regenerator": true,
-            "moduleName": "babel-runtime"
-        }
-    ]]
-}

package/test/game/mgr.js

@@ -1,80 +0,0 @@
-/**
- * 联机单元测试：远程管理
- */
-
-const assert = require('assert')
-
-//引入游戏云连接器，创建连接器对象
-const {gameconn} = require('../../src/')
-const remote = new gameconn({
-    "UrlHead": "http",              //协议选择: http/https
-    "webserver": { 
-        //注意：如果需要负载均衡，这里一般指定负载均衡服务器地址，否则直接填写业务主机地址
-        "host": "127.0.0.1",        //远程主机地址
-        "authPort": 9601,           //签证主机端口
-        "port": 9901                //远程主机端口
-    },
-}).setFetch(require('node-fetch')); //设置node环境下兼容的fetch函数
-
-//切换为长连模式
-//remote.setmode(remote.CommMode.ws);
-
-//这里需要填充管理员登录信息
-let admin = {
-    openid: '',
-    openkey: '',
-}
-
-describe('远程管理', () => {
-    it.skip('执行索引服远程指令 remote.printInfo', async () => {
-        await remote.init(/*初始化连接器，只保留原始配置信息*/).login({
-            domain: 'CoreOfIndex',
-            openid: admin.openid,
-            openkey: admin.openkey,
-        });
-    
-        let msg = await remote.fetching({func: "remote.printInfo"});
-        console.log(msg);
-    });
-    
-    it.skip('透过索引服执行业务服远程指令 remote.command printInfo', async () => {
-        await remote.init(/*初始化连接器，只保留原始配置信息*/).login({
-            domain: 'CoreOfIndex',
-            openid: admin.openid,
-            openkey: admin.openkey,
-        });
-    
-        let msg = await remote.fetching({func: "remote.command", data: ['printInfo', 'CoreOfChickIOS', '1']});
-        console.log(msg);
-    });
-
-    it('模拟用户注册并登录', async () => {
-        //执行登录操作，通过配置对象传入用户信息，并指定签证方式为两阶段认证
-        let auth = {
-            cpId: 'c376af60-cab5-11ed-90e8-25399b14218a',
-            addr: '10000000',
-            name: 'bookman',
-            bonus: '',
-            time: Date.now(),
-        };
-
-        //需要正确填充 auth.sign, 此处采用模拟命令填充, 注意命令 testSign 只在测试模式下开启
-        await remote.init().login({
-            domain: 'CoreOfIndex',
-            openid: admin.openid,
-            openkey: admin.openkey,
-        });
-        let msg = await remote.fetching({func: "remote.command", data: ['testSign', 'CoreOfChickIOS', '1', auth]});
-        auth.sign = msg['CoreOfChickIOS.1'].sign;
-
-        let ret = await remote.init().login({
-            domain: 'CoreOfChickIOS',      //登录域
-            openid: `bxs.${auth.addr}`,    //用户登录标识，含验证方式
-            auth,
-        });
-        if(!!ret) {
-            ret = await remote.fetching({func: "test.echo"});
-            assert(ret.code == 0);
-        }
-    });
-});