Merge pull request #788 from EOSIO/release/21.0.x

Brad Hart · web-flow · commit 1cf9bf53d21d · 2020-08-12T13:33:33.000-04:00
Release for 21.0.3
diff --git a/docs.json b/docs.json
@@ -1,20 +1,20 @@
 {
 	"name": "eosjs",
 	"generators": [
-    {
+		{
 			"name": "collate_markdown",
-			"options": {
-				"docs_dir": "docs"
+			"options": { 
+				"docs_dir": "docs" 
 			}
 		},
 		{
 			"name": "typedoc",
 			"options": {
-				"disable_filters": true
-			},
-			"filters": [
-				{ "name":  "remove_extension" }
-			]
+				"disable_default_filters": true,
+				"filters": [
+					{ "name":  "remove_extension" }
+				]
+			}
 		}
 	]
 }
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "eosjs",
-  "version": "21.0.2",
+  "version": "21.0.3",
   "description": "Talk to eos API",
   "main": "dist/index.js",
   "scripts": {
@@ -33,18 +33,18 @@
   "devDependencies": {
     "@blockone/eslint-config-blockone": "^3.0.0",
     "@types/elliptic": "^6.4.12",
-    "@types/jest": "^26.0.4",
-    "@types/node": "^14.0.23",
+    "@types/jest": "^26.0.9",
+    "@types/node": "^14.0.27",
     "@types/pako": "^1.0.1",
-    "cypress": "^4.10.0",
+    "cypress": "^4.12.1",
     "eosjs-ecc": "^4.0.7",
     "eslint": "^6.8.0",
-    "jest": "^26.1.0",
+    "jest": "^26.3.0",
     "jest-fetch-mock": "^3.0.3",
-    "ts-jest": "^26.1.2",
+    "ts-jest": "^26.2.0",
     "ts-loader": "^7.0.5",
-    "typescript": "^3.9.6",
-    "webpack": "^4.43.0",
+    "typescript": "^3.9.7",
+    "webpack": "^4.44.1",
     "webpack-cli": "^3.3.12"
   },
   "resolutions": {
diff --git a/src/PrivateKey.ts b/src/PrivateKey.ts
@@ -58,9 +58,12 @@ export class PrivateKey {
     }
 
     /** Sign a message or hashed message digest with private key */
-    public sign(data: BNInput, shouldHash: boolean = true, encoding: string = 'utf8'): Signature {
+    public sign(data: BNInput, shouldHash: boolean = true, encoding: BufferEncoding = 'utf8'): Signature {
         if (shouldHash) {
-            data = this.ec.hash().update(data, encoding).digest();
+            if (typeof data === 'string') {
+                data = Buffer.from(data, encoding);
+            }
+            data = this.ec.hash().update(data).digest();
         }
         let tries = 0;
         let signature: Signature;
diff --git a/src/Signature.ts b/src/Signature.ts
@@ -86,19 +86,25 @@ export class Signature {
     }
 
     /** Verify a signature with a message or hashed message digest and public key */
-    public verify(data: BNInput, publicKey: PublicKey, shouldHash: boolean = true, encoding: string = 'utf8'): boolean {
+    public verify(data: BNInput, publicKey: PublicKey, shouldHash: boolean = true, encoding: BufferEncoding = 'utf8'): boolean {
         if (shouldHash) {
-            data = this.ec.hash().update(data, encoding).digest();
+            if (typeof data === 'string') {
+                data = Buffer.from(data, encoding);
+            }
+            data = this.ec.hash().update(data).digest();
         }
         const ellipticSignature = this.toElliptic();
         const ellipticPublicKey = publicKey.toElliptic();
         return this.ec.verify(data, ellipticSignature, ellipticPublicKey, encoding);
     }
 
     /** Recover a public key from a message or hashed message digest and signature */
-    public recover(data: BNInput, shouldHash: boolean = true, encoding: string = 'utf8'): PublicKey {
+    public recover(data: BNInput, shouldHash: boolean = true, encoding: BufferEncoding = 'utf8'): PublicKey {
         if (shouldHash) {
-            data = this.ec.hash().update(data, encoding).digest();
+            if (typeof data === 'string') {
+                data = Buffer.from(data, encoding);
+            }
+            data = this.ec.hash().update(data).digest();
         }
         const ellipticSignature = this.toElliptic();
         const recoveredPublicKey = this.ec.recoverPubKey(
diff --git a/src/eosjs-ecc-migration.ts b/src/eosjs-ecc-migration.ts
@@ -49,29 +49,29 @@ export const ecc = {
             return false;
         }
     },
-    sign: (data: string|Buffer, privateKey: string|PrivateKey, encoding: string = 'utf8'): string => {
+    sign: (data: string|Buffer, privateKey: string|PrivateKey, encoding: BufferEncoding = 'utf8'): string => {
         const privKey = typeof privateKey === 'string' ? PrivateKey.fromString(privateKey) : privateKey;
         const signature = privKey.sign(data, true, encoding);
         return signature.toString();
     },
-    signHash: (dataSha256: string|Buffer, privateKey: string|PrivateKey, encoding: string = 'hex') => {
+    signHash: (dataSha256: string|Buffer, privateKey: string|PrivateKey, encoding: BufferEncoding = 'hex') => {
         const privKey = typeof privateKey === 'string' ? PrivateKey.fromString(privateKey) : privateKey;
         const signature = privKey.sign(dataSha256, false, encoding);
         return signature.toString();
     },
     verify: (
-        signature: string, data: string, pubKey: string|PublicKey, encoding: string = 'utf8', hashData: boolean = true
+        signature: string, data: string, pubKey: string|PublicKey, encoding: BufferEncoding = 'utf8', hashData: boolean = true
     ): boolean => {
         const publicKey = typeof pubKey === 'string' ? PublicKey.fromString(pubKey) : pubKey;
         const sig = Signature.fromString(signature);
         return sig.verify(data, publicKey, hashData, encoding);
     },
-    recover: (signature: string, data: string, encoding: string = 'utf8'): string => {
+    recover: (signature: string, data: string, encoding: BufferEncoding = 'utf8'): string => {
         const sig = Signature.fromString(signature);
         const publicKey = sig.recover(data, true, encoding);
         return publicKey.toLegacyString();
     },
-    recoverHash: (signature: string, dataSha256: string|Buffer, encoding: string = 'hex'): string => {
+    recoverHash: (signature: string, dataSha256: string|Buffer, encoding: BufferEncoding = 'hex'): string => {
         const sig = Signature.fromString(signature);
         const publicKey = sig.recover(dataSha256, false, encoding);
         return publicKey.toLegacyString();
diff --git a/src/tests/eosjs-ecc-migration.test.ts b/src/tests/eosjs-ecc-migration.test.ts
@@ -91,35 +91,35 @@ describe('ecc Migration', () => {
 
     it('verifies `sign`, `recover`, and `verify` functions are consistent between ecc objects', () => {
         const dataAsString = 'some string';
-        const eccSig = ecc.sign(dataAsString, privateKeys[0]);
-        const eccMigrationSig = eccMigration.sign(dataAsString, privateKeys[0]);
+        const eccSig = ecc.sign(dataAsString, privateKeys[0], 'utf8');
+        const eccMigrationSig = eccMigration.sign(dataAsString, privateKeys[0], 'utf8');
 
         // signatures are different
         expect(eccSig).not.toEqual(eccMigrationSig);
 
-        const eccKPub = ecc.recover(eccSig, dataAsString);
-        const eccMigrationKPub = eccMigration.recover(eccMigrationSig, dataAsString);
+        const eccKPub = ecc.recover(eccSig, dataAsString, 'utf8');
+        const eccMigrationKPub = eccMigration.recover(eccMigrationSig, dataAsString, 'utf8');
         expect(eccKPub).toEqual(eccMigrationKPub);
     });
 
     it('verifies `signHash`, `recoverHash`, and `sha256` functions are consistent between ecc objects', () => {
         console.warn = jest.fn();
         const dataAsString = 'some string';
 
-        const eccHash = Buffer.from(ecc.sha256(dataAsString, 'hex', 'utf8'), 'hex');
-        const eccMigrationHash = Buffer.from(eccMigration.sha256(dataAsString, 'hex', 'utf8') as Buffer);
+        const eccHash = Buffer.from(ecc.sha256(dataAsString), 'hex');
+        const eccMigrationHash = Buffer.from(eccMigration.sha256(dataAsString, 'hex', 'utf8') as string, 'hex');
         expect(console.warn).toBeCalledWith('Argument `encoding` is deprecated');
         expect(console.warn).toBeCalledWith('Argument `resultEncoding` is deprecated');
         expect(eccHash).toEqual(eccMigrationHash);
 
-        const eccSig = ecc.signHash(eccHash, privateKeys[0]);
-        const eccMigrationSig = eccMigration.signHash(eccMigrationHash, privateKeys[0]);
+        const eccSig = ecc.signHash(eccHash, privateKeys[0], 'utf8');
+        const eccMigrationSig = eccMigration.signHash(eccMigrationHash, privateKeys[0], 'utf8');
 
         // signatures are different
         expect(eccSig).not.toEqual(eccMigrationSig);
 
-        const eccKPub = ecc.recoverHash(eccSig, eccHash);
-        const eccMigrationKPub = eccMigration.recoverHash(eccSig, eccMigrationHash);
+        const eccKPub = ecc.recoverHash(eccSig, eccHash, 'utf8');
+        const eccMigrationKPub = eccMigration.recoverHash(eccSig, eccMigrationHash, 'utf8');
         expect(eccKPub).toEqual(eccMigrationKPub);
     });
 });
diff --git a/src/tests/eosjs-ecc-verification.test.js b/src/tests/eosjs-ecc-verification.test.js
@@ -3,7 +3,7 @@ const ecc = require('eosjs-ecc');
 
 const { ec } = require('elliptic');
 
-const { Signature, PrivateKey, PublicKey } = require('../eosjs-key-conversions');
+const { Signature, PrivateKey, PublicKey, sha256 } = require('../eosjs-key-conversions');
 const {
     JsSignatureProvider,
 } = require('../eosjs-jssig');
@@ -52,23 +52,25 @@ describe('JsSignatureProvider', () => {
             const ellipticHashedStringAsBuffer = Buffer.from(ellipticEc.hash().update(dataAsString).digest(), 'hex');
             expect(eccHashedString).toEqual(ellipticHashedStringAsBuffer);
 
-            const eccSig = ecc.sign(dataAsString, KPriv);
-            const ellipticSig = KPrivElliptic.sign(ellipticHashedStringAsBuffer);
+            const eccSig = ecc.sign(dataAsString, KPriv, 'utf8');
+            const ellipticSig = KPrivElliptic.sign(ellipticHashedStringAsBuffer, 'utf8');
 
-            const eccKPub = ecc.recover(eccSig, dataAsString);
+            const eccKPub = ecc.recover(eccSig, dataAsString, 'utf8');
             const ellipticRecoveredKPub = ellipticEc.recoverPubKey(
                 ellipticHashedStringAsBuffer,
                 ellipticSig,
-                ellipticSig.recoveryParam
+                ellipticSig.recoveryParam,
+                'utf8'
             );
             const ellipticKPub = ellipticEc.keyFromPublic(ellipticRecoveredKPub);
             expect(PublicKey.fromElliptic(ellipticKPub, KeyType.k1).toString()).toEqual(k1FormatPublicKeys[idx]);
 
-            const eccValid = ecc.verify(eccSig, dataAsString, eccKPub);
+            const eccValid = ecc.verify(eccSig, dataAsString, eccKPub, 'utf8');
             const ellipticValid = ellipticEc.verify(
                 ellipticHashedStringAsBuffer,
                 ellipticSig,
-                ellipticEc.keyFromPublic(ellipticKPub)
+                ellipticEc.keyFromPublic(ellipticKPub),
+                'utf8'
             );
             expect(eccValid).toEqual(true);
             expect(ellipticValid).toEqual(true);
@@ -88,14 +90,15 @@ describe('JsSignatureProvider', () => {
             const ellipticHashedStringAsBuffer = Buffer.from(ellipticEc.hash().update(dataAsString).digest(), 'hex');
             expect(eccHashedString).toEqual(ellipticHashedStringAsBuffer);
 
-            const eccSig = ecc.sign(dataAsString, KPriv);
+            const eccSig = ecc.sign(dataAsString, KPriv, 'utf8');
 
             const ellipticSig = Signature.fromString(eccSig).toElliptic();
-            const recoveredKPub = ecc.recover(eccSig, dataAsString);
+            const recoveredKPub = ecc.recover(eccSig, dataAsString, 'utf8');
             const ellipticRecoveredKPub = ellipticEc.recoverPubKey(
                 ellipticHashedStringAsBuffer,
                 ellipticSig,
-                ellipticSig.recoveryParam
+                ellipticSig.recoveryParam,
+                'utf8'
             );
 
             const ellipticKPub = ellipticEc.keyFromPublic(ellipticRecoveredKPub);
@@ -105,7 +108,8 @@ describe('JsSignatureProvider', () => {
             const ellipticValid = ellipticEc.verify(
                 ellipticHashedStringAsBuffer,
                 ellipticSig,
-                ellipticEc.keyFromPublic(ellipticKPub)
+                ellipticEc.keyFromPublic(ellipticKPub),
+                'utf8'
             );
             expect(ellipticValid).toEqual(true);
         }
@@ -122,19 +126,67 @@ describe('JsSignatureProvider', () => {
 
             const ellipticHashedStringAsBuffer = Buffer.from(ellipticEc.hash().update(dataAsString).digest(), 'hex');
 
-            const ellipticSig = KPrivElliptic.sign(ellipticHashedStringAsBuffer);
+            const ellipticSig = KPrivElliptic.sign(ellipticHashedStringAsBuffer, 'utf8');
             const ellipticSigAsString = Signature.fromElliptic(ellipticSig, KeyType.k1).toString();
 
-            const recoveredKPub = ecc.recover(ellipticSigAsString, dataAsString);
+            const recoveredKPub = ecc.recover(ellipticSigAsString, dataAsString, 'utf8');
             const ellipticRecoveredKPub = ellipticEc.recoverPubKey(
                 ellipticHashedStringAsBuffer,
                 ellipticSig,
-                ellipticSig.recoveryParam
+                ellipticSig.recoveryParam,
+                'utf8'
             );
             const ellipticKPub = ellipticEc.keyFromPublic(ellipticRecoveredKPub);
             expect(PublicKey.fromElliptic(ellipticKPub, KeyType.k1).toString()).toEqual(k1FormatPublicKeys[idx]);
 
-            const eccValid = ecc.verify(ellipticSigAsString, dataAsString, recoveredKPub);
+            const eccValid = ecc.verify(ellipticSigAsString, dataAsString, recoveredKPub, 'utf8');
+            expect(eccValid).toEqual(true);
+        }
+    });
+
+    it('ensure eosjs verifies eosjs-ecc\'s Sigs', () => {
+        for (let idx=0; idx<privateKeys.length; idx++) {
+            const KPriv = privateKeys[idx];
+            const privateKey = PrivateKey.fromString(KPriv);
+
+            const dataAsString = 'some string';
+
+            const eccHashedString = Buffer.from(ecc.sha256(dataAsString), 'hex');
+            const eosjsHashedStringAsBuffer = Buffer.from(sha256(dataAsString), 'hex');
+            expect(eccHashedString).toEqual(eosjsHashedStringAsBuffer);
+
+            const eccSig = ecc.sign(dataAsString, KPriv, 'utf8');
+
+            const eosjsSig = Signature.fromString(eccSig);
+            const recoveredKPub = ecc.recover(eccSig, dataAsString, 'utf8');
+            const eosjsRecoveredKPub = eosjsSig.recover(dataAsString, true, 'utf8');
+
+            expect(eosjsRecoveredKPub.toLegacyString()).toEqual(recoveredKPub);
+            expect(eosjsRecoveredKPub.toString()).toEqual(k1FormatPublicKeys[idx]);
+
+            const eosjsValid = eosjsSig.verify(dataAsString, eosjsRecoveredKPub, true, 'utf8');
+            expect(eosjsValid).toEqual(true);
+        }
+    });
+
+    it('ensure ecc verifies eosjs\'s Sigs', () => {
+        for (let idx=0; idx<privateKeys.length; idx++) {
+            const KPriv = privateKeys[idx];
+            const privateKey = PrivateKey.fromString(KPriv);
+
+            const dataAsString = 'some string';
+
+            const eosjsHashedStringAsBuffer = Buffer.from(sha256(dataAsString), 'hex');
+
+            const eosjsSig = privateKey.sign(eosjsHashedStringAsBuffer, false, 'utf8');
+            const eosjsSigAsString = eosjsSig.toString();
+
+            const recoveredKPub = ecc.recover(eosjsSigAsString, dataAsString, 'utf8');
+            const eosjsRecoveredKPub = eosjsSig.recover(dataAsString, true, 'utf8');
+            expect(eosjsRecoveredKPub.toLegacyString()).toEqual(recoveredKPub);
+            expect(eosjsRecoveredKPub.toString()).toEqual(k1FormatPublicKeys[idx]);
+
+            const eccValid = ecc.verify(eosjsSigAsString, dataAsString, recoveredKPub, 'utf8');
             expect(eccValid).toEqual(true);
         }
     });
diff --git a/src/tests/eosjs-jssig.test.ts b/src/tests/eosjs-jssig.test.ts
@@ -196,6 +196,19 @@ describe('JsSignatureProvider', () => {
             const valid = sig.verify(dataAsString, KPub, true);
             expect(valid).toEqual(true);
         });
+
+        it('Ensure elliptic sign, recover, verify flow works with shouldHash and encoding', () => {
+            const KPrivStr = privateKeys[0];
+            const KPriv = PrivateKey.fromString(KPrivStr);
+
+            const dataAsString = 'some string';
+            const sig = KPriv.sign(dataAsString, true, 'utf8');
+            const KPub = sig.recover(dataAsString, true, 'utf8');
+
+            expect(KPub.toString()).toEqual(k1FormatPublicKeys[0]);
+            const valid = sig.verify(dataAsString, KPub, true, 'utf8');
+            expect(valid).toEqual(true);
+        });
     });
 
     describe('p256 elliptic', () => {
@@ -338,5 +351,18 @@ describe('JsSignatureProvider', () => {
             const valid = sig.verify(dataAsString, KPub, true);
             expect(valid).toEqual(true);
         });
+
+        it('Ensure elliptic sign, recover, verify flow works with shouldHash and encoding', () => {
+            const KPrivStr = privateKeysR1[0];
+            const KPriv = PrivateKey.fromString(KPrivStr);
+
+            const dataAsString = 'some string';
+            const sig = KPriv.sign(dataAsString, true, 'utf8');
+            const KPub = sig.recover(dataAsString, true, 'utf8');
+
+            expect(KPub.toString()).toEqual(r1FormatPublicKeys[0]);
+            const valid = sig.verify(dataAsString, KPub, true, 'utf8');
+            expect(valid).toEqual(true);
+        });
     });
 });
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -1,20 +1,20 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "eosjs",`
`3`	`3`	`"generators": [`
`4`		`- {`
	`4`	`+ {`
`5`	`5`	`"name": "collate_markdown",`
`6`		`- "options": {`
`7`		`- "docs_dir": "docs"`
	`6`	`+ "options": {`
	`7`	`+ "docs_dir": "docs"`
`8`	`8`	`}`
`9`	`9`	`},`
`10`	`10`	`{`
`11`	`11`	`"name": "typedoc",`
`12`	`12`	`"options": {`
`13`		`- "disable_filters": true`
`14`		`- },`
`15`		`- "filters": [`
`16`		`- { "name": "remove_extension" }`
`17`		`- ]`
	`13`	`+ "disable_default_filters": true,`
	`14`	`+ "filters": [`
	`15`	`+ { "name": "remove_extension" }`
	`16`	`+ ]`
	`17`	`+ }`
`18`	`18`	`}`
`19`	`19`	`]`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,9 +58,12 @@ export class PrivateKey {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`/** Sign a message or hashed message digest with private key */`
`61`		`- public sign(data: BNInput, shouldHash: boolean = true, encoding: string = 'utf8'): Signature {`
	`61`	`+ public sign(data: BNInput, shouldHash: boolean = true, encoding: BufferEncoding = 'utf8'): Signature {`
`62`	`62`	`if (shouldHash) {`
`63`		`- data = this.ec.hash().update(data, encoding).digest();`
	`63`	`+ if (typeof data === 'string') {`
	`64`	`+ data = Buffer.from(data, encoding);`
	`65`	`+ }`
	`66`	`+ data = this.ec.hash().update(data).digest();`
`64`	`67`	`}`
`65`	`68`	`let tries = 0;`
`66`	`69`	`let signature: Signature;`