Restored core crypto component to use SignSchema rather than NetworkType

Author: rg911

src/core/crypto/Crypto.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { NetworkType } from '../../model/blockchain/NetworkType';
 import { WalletAlgorithm } from '../../model/wallet/WalletAlgorithm';
 import { Convert as convert } from '../format/Convert';
 import { KeyPair } from './KeyPair';
@@ -221,16 +220,16 @@ export class Crypto {
      * @param {string} msg - A text message
      * @param {Uint8Array} iv - An initialization vector
      * @param {Uint8Array} salt - A salt
-     * @param {NetworkType} networkType - Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @return {string} - The encoded message
      */
-    public static _encode = (senderPriv, recipientPub, msg, iv, salt, networkType: NetworkType) => {
+    public static _encode = (senderPriv, recipientPub, msg, iv, salt, signSchema: SignSchema) => {
         // Errors
         if (!senderPriv || !recipientPub || !msg || !iv || !salt) { throw new Error('Missing argument !'); }
         // Processing
-        const keyPair = KeyPair.createKeyPairFromPrivateKeyString(senderPriv, networkType);
+        const keyPair = KeyPair.createKeyPairFromPrivateKeyString(senderPriv, signSchema);
         const pk = convert.hexToUint8(recipientPub);
-        const encKey = utility.ua2words(KeyPair.deriveSharedKey(keyPair, pk, salt, networkType), 32);
+        const encKey = utility.ua2words(KeyPair.deriveSharedKey(keyPair, pk, salt, signSchema), 32);
         const encIv = {
             iv: utility.ua2words(iv, 16),
         };
@@ -246,16 +245,16 @@ export class Crypto {
      * @param {string} senderPriv - A sender private key
      * @param {string} recipientPub - A recipient public key
      * @param {string} msg - A text message
-     * @param {NetworkType} networkType - Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @return {string} - The encoded message
      */
-    public static encode = (senderPriv, recipientPub, msg, networkType: NetworkType) => {
+    public static encode = (senderPriv, recipientPub, msg, signSchema: SignSchema) => {
         // Errors
         if (!senderPriv || !recipientPub || !msg) { throw new Error('Missing argument !'); }
         // Processing
         const iv = Crypto.randomBytes(16);
         const salt = Crypto.randomBytes(32);
-        const encoded = Crypto._encode(senderPriv, recipientPub, msg, iv, salt, networkType);
+        const encoded = Crypto._encode(senderPriv, recipientPub, msg, iv, salt, signSchema);
         // Result
         return encoded;
     }
@@ -266,16 +265,16 @@ export class Crypto {
      * @param {string} recipientPrivate - A recipient private key
      * @param {string} senderPublic - A sender public key
      * @param {Uint8Array} _payload - An encrypted message payload in bytes
-     * @param {NetworkType} networkType - Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @return {string} - The decoded payload as hex
      */
-    public static _decode = (recipientPrivate, senderPublic, payload, iv, salt, networkType: NetworkType) => {
+    public static _decode = (recipientPrivate, senderPublic, payload, iv, salt, signSchema: SignSchema) => {
         // Error
         if (!recipientPrivate || !senderPublic || !payload) { throw new Error('Missing argument !'); }
         // Processing
-        const keyPair = KeyPair.createKeyPairFromPrivateKeyString(recipientPrivate, networkType);
+        const keyPair = KeyPair.createKeyPairFromPrivateKeyString(recipientPrivate, signSchema);
         const pk = convert.hexToUint8(senderPublic);
-        const encKey = utility.ua2words(KeyPair.deriveSharedKey(keyPair, pk, salt, networkType), 32);
+        const encKey = utility.ua2words(KeyPair.deriveSharedKey(keyPair, pk, salt, signSchema), 32);
         const encIv = {
             iv: utility.ua2words(iv, 16),
         };
@@ -292,19 +291,19 @@ export class Crypto {
      *
      * @param {string} recipientPrivate - A recipient private key
      * @param {string} senderPublic - A sender public key
-     * @param {string} _payload - An encrypted message payload
-     * @param {NetworkType} networkType - Catapult network identifier
+     * @param {string} payload - An encrypted message payload
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @return {string} - The decoded payload as hex
      */
-    public static decode = (recipientPrivate, senderPublic, _payload, networkType: NetworkType) => {
+    public static decode = (recipientPrivate, senderPublic, payload, signSchema: SignSchema) => {
         // Error
-        if (!recipientPrivate || !senderPublic || !_payload) { throw new Error('Missing argument !'); }
+        if (!recipientPrivate || !senderPublic || !payload) { throw new Error('Missing argument !'); }
         // Processing
-        const binPayload = convert.hexToUint8(_payload);
-        const payload = new Uint8Array(binPayload.buffer, 48);
+        const binPayload = convert.hexToUint8(payload);
+        const payloadBuffer = new Uint8Array(binPayload.buffer, 48);
         const salt = new Uint8Array(binPayload.buffer, 0, 32);
         const iv = new Uint8Array(binPayload.buffer, 32, 16);
-        const decoded = Crypto._decode(recipientPrivate, senderPublic, payload, iv, salt, networkType);
+        const decoded = Crypto._decode(recipientPrivate, senderPublic, payloadBuffer, iv, salt, signSchema);
         return decoded;
     }
 
@@ -318,18 +317,4 @@ export class Crypto {
         const crypto = require('crypto');
         return crypto.randomBytes(length);
     }
-
-    /**
-     * Resolve signature schema from given network type
-     *
-     * @param {NetworkType} networkType - Network type
-     *
-     * @return {SignSchema}
-     */
-    public static resolveNetworkType(networkType: NetworkType): SignSchema {
-        if (networkType === NetworkType.MAIN_NET || networkType === NetworkType.TEST_NET) {
-            return SignSchema.KECCAK;
-        }
-        return SignSchema.SHA3;
-    }
 }

src/core/crypto/KeyPair.ts

@@ -15,21 +15,22 @@
  */
 import { NetworkType } from '../../model/blockchain/NetworkType';
 import { Convert as convert } from '../format';
+import { SignSchema } from './SignSchema';
 import * as Utility from './Utilities';
 
 export class KeyPair {
     /**
      * Creates a key pair from a private key string.
      * @param {string} privateKeyString A hex encoded private key string.
-     * @param {networkType} networkType Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {module:crypto/keyPair~KeyPair} The key pair.
      */
-    public static createKeyPairFromPrivateKeyString = (privateKeyString: string, networkType: NetworkType) => {
+    public static createKeyPairFromPrivateKeyString = (privateKeyString: string, signSchema: SignSchema) => {
         const privateKey = convert.hexToUint8(privateKeyString);
         if (Utility.Key_Size !== privateKey.length) {
             throw Error(`private key has unexpected size: ${privateKey.length}`);
         }
-        const publicKey = Utility.catapult_crypto.extractPublicKey(privateKey, Utility.catapult_hash.func, networkType);
+        const publicKey = Utility.catapult_crypto.extractPublicKey(privateKey, Utility.catapult_hash.func, signSchema);
         return {
             privateKey,
             publicKey,
@@ -40,24 +41,24 @@ export class KeyPair {
      * Signs a data buffer with a key pair.
      * @param {module:crypto/keyPair~KeyPair} keyPair The key pair to use for signing.
      * @param {Uint8Array} data The data to sign.
-     * @param {networkType} networkType Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {Uint8Array} The signature.
      */
-    public static sign = (keyPair, data: Uint8Array, networkType: NetworkType) => {
+    public static sign = (keyPair, data: Uint8Array, signSchema: SignSchema) => {
         return Utility.catapult_crypto.sign(data, keyPair.publicKey, keyPair.privateKey,
-                Utility.catapult_hash.createHasher(64, networkType));
+                Utility.catapult_hash.createHasher(64, signSchema));
     }
 
     /**
      * Verifies a signature.
      * @param {module:crypto/keyPair~PublicKey} publicKey The public key to use for verification.
      * @param {Uint8Array} data The data to verify.
      * @param {Uint8Array} signature The signature to verify.
-     * @param {networkType} networkType Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {boolean} true if the signature is verifiable, false otherwise.
      */
-    public static verify = (publicKey, data: Uint8Array, signature: Uint8Array, networkType: NetworkType) => {
-        return Utility.catapult_crypto.verify(publicKey, data, signature, Utility.catapult_hash.createHasher(64, networkType));
+    public static verify = (publicKey, data: Uint8Array, signature: Uint8Array, signSchema: SignSchema) => {
+        return Utility.catapult_crypto.verify(publicKey, data, signature, Utility.catapult_hash.createHasher(64, signSchema));
     }
 
     /**
@@ -66,16 +67,16 @@ export class KeyPair {
      * @param {module:crypto/keyPair~KeyPair} keyPair The key pair for which to create the shared key.
      * @param {Uint8Array} publicKey The public key for which to create the shared key.
      * @param {Uint8Array} salt A salt that should be applied to the shared key.
-     * @param {networkType} networkType Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {Uint8Array} The shared key.
      */
-    public static deriveSharedKey = (keyPair, publicKey: Uint8Array, salt: Uint8Array, networkType: NetworkType) => {
+    public static deriveSharedKey = (keyPair, publicKey: Uint8Array, salt: Uint8Array, signSchema: SignSchema) => {
         if (Utility.Key_Size !== salt.length) {
             throw Error(`salt has unexpected size: ${salt.length}`);
         }
         if (Utility.Key_Size !== publicKey.length) {
             throw Error(`public key has unexpected size: ${salt.length}`);
         }
-        return Utility.catapult_crypto.deriveSharedKey(salt, keyPair.privateKey, publicKey, Utility.catapult_hash.func, networkType);
+        return Utility.catapult_crypto.deriveSharedKey(salt, keyPair.privateKey, publicKey, Utility.catapult_hash.func, signSchema);
     }
 }

src/core/crypto/SHA3Hasher.ts

@@ -17,7 +17,6 @@
 import { keccak256, keccak512, sha3_256, sha3_512 } from 'js-sha3';
 import { NetworkType } from '../../model/blockchain/NetworkType';
 import { Convert as convert, RawArray as array } from '../format';
-import { Crypto } from './Crypto';
 import { SignSchema } from './SignSchema';
 
 export class SHA3Hasher {
@@ -26,25 +25,25 @@ export class SHA3Hasher {
      * @param {Uint8Array} dest The computed hash destination.
      * @param {Uint8Array} data The data to hash.
      * @param {numeric} length The hash length in bytes.
-     * @param {NetworkType} networkType Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      */
-    public static func = (dest, data, length, networkType: NetworkType) => {
-        const hasher = SHA3Hasher.getHasher(length, networkType);
+    public static func = (dest, data, length, signSchema: SignSchema) => {
+        const hasher = SHA3Hasher.getHasher(length, signSchema);
         const hash = hasher.arrayBuffer(data);
         array.copy(dest, array.uint8View(hash));
     }
 
     /**
      * Creates a hasher object.
      * @param {numeric} length The hash length in bytes.
-     * @param {NetworkType} networkType Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {object} The hasher.
      */
-    public static createHasher = (length = 64, networkType: NetworkType) => {
+    public static createHasher = (length = 64, signSchema: SignSchema) => {
         let hash;
         return {
             reset: () => {
-                hash = SHA3Hasher.getHasher(length, networkType).create();
+                hash = SHA3Hasher.getHasher(length, signSchema).create();
             },
             update: (data: any) => {
                 if (data instanceof Uint8Array) {
@@ -64,11 +63,10 @@ export class SHA3Hasher {
     /**
      * Get a hasher instance.
      * @param {numeric} length The hash length in bytes.
-     * @param {NetworkType} networkType Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {object} The hasher.
      */
-    public static getHasher = (length = 64, networkType: NetworkType) => {
-        const signSchema = Crypto.resolveNetworkType(networkType);
+    public static getHasher = (length = 64, signSchema: SignSchema) => {
         return {
             32: signSchema === SignSchema.SHA3 ? sha3_256 : keccak256,
             64: signSchema === SignSchema.SHA3 ? sha3_512 : keccak512 ,
@@ -78,11 +76,24 @@ export class SHA3Hasher {
     /**
      * Create a hasher instance with given payload bytes and return hash array buffer.
      * @param {Uint8Array} payload Payload in bytes.
-     * @param {NetworkType} networkType Catapult network identifier
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {ArrayBuffer}
      */
-    public static getHashArrayBuffer(payload: Uint8Array, networkType: NetworkType): ArrayBuffer {
-        const signSchema = Crypto.resolveNetworkType(networkType);
+    public static getHashArrayBuffer(payload: Uint8Array, signSchema: SignSchema): ArrayBuffer {
         return signSchema === SignSchema.SHA3 ? sha3_256.arrayBuffer(payload) : keccak256.arrayBuffer(payload);
     }
+
+    /**
+     * Resolve signature schema from given network type
+     *
+     * @param {NetworkType} networkType - Network type
+     *
+     * @return {SignSchema}
+     */
+    public static resolveSignSchema(networkType: NetworkType): SignSchema {
+        if (networkType === NetworkType.MAIN_NET || networkType === NetworkType.TEST_NET) {
+            return SignSchema.KECCAK;
+        }
+        return SignSchema.SHA3;
+    }
 }

src/core/crypto/Utilities.ts

@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { NetworkType } from '../../model/blockchain/NetworkType';
+
 import { RawArray as array } from '../format';
 import * as nacl from './nacl_catapult';
 import { SHA3Hasher as sha3Hasher } from './SHA3Hasher';
+import { SignSchema } from './SignSchema';
 export const CryptoJS = require('crypto-js');
 export const Key_Size = 32;
 export const Signature_Size = 64;
@@ -74,9 +75,9 @@ export const catapult_crypto = (function() {
         d[31] |= 64;
     }
 
-    function prepareForScalarMult(sk, hashfunc, networkType: NetworkType) {
+    function prepareForScalarMult(sk, hashfunc, signSchema: SignSchema) {
         const d = new Uint8Array(Hash_Size);
-        hashfunc(d, sk, Hash_Size, networkType);
+        hashfunc(d, sk, Hash_Size, signSchema);
         clamp(d);
         return d;
     }
@@ -108,9 +109,9 @@ export const catapult_crypto = (function() {
     })();
 
     return {
-        extractPublicKey: (sk, hashfunc, networkType: NetworkType) => {
+        extractPublicKey: (sk, hashfunc, signSchema: SignSchema) => {
             const c = nacl;
-            const d = prepareForScalarMult(sk, hashfunc, networkType);
+            const d = prepareForScalarMult(sk, hashfunc, signSchema);
 
             const p = [c.gf(), c.gf(), c.gf(), c.gf()];
             const pk = new Uint8Array(Key_Size);
@@ -201,9 +202,9 @@ export const catapult_crypto = (function() {
             return 0 === c.crypto_verify_32(signature, 0, t, 0);
         },
 
-        deriveSharedKey: (salt, sk, pk, hashfunc, networkType: NetworkType) => {
+        deriveSharedKey: (salt, sk, pk, hashfunc, signSchema: SignSchema) => {
             const c = nacl;
-            const d = prepareForScalarMult(sk, hashfunc, networkType);
+            const d = prepareForScalarMult(sk, hashfunc, signSchema);
 
             // sharedKey = pack(p = d (derived from sk) * q (derived from pk))
             const q = [c.gf(), c.gf(), c.gf(), c.gf()];
@@ -218,7 +219,7 @@ export const catapult_crypto = (function() {
             }
             // return the hash of the result
             const sharedKeyHash = new Uint8Array(Key_Size);
-            hashfunc(sharedKeyHash, sharedKey, Key_Size, networkType);
+            hashfunc(sharedKeyHash, sharedKey, Key_Size, signSchema);
             return sharedKeyHash;
         },
     };

src/core/crypto/nacl_catapult.ts

@@ -672,11 +672,11 @@ export const cleanup = (arr) => {
     }
 };
 
-export const crypto_shared_key_hash = (shared, pk, sk, hashfunc, networkType) => {
+export const crypto_shared_key_hash = (shared, pk, sk, hashfunc, signSchema) => {
     const d = new Uint8Array(64);
     const p = [gf(), gf(), gf(), gf()];
 
-    hashfunc(d, sk, 32, networkType);
+    hashfunc(d, sk, 32, signSchema);
     d[0] &= 248;
     d[31] &= 127;
     d[31] |= 64;

src/core/format/RawAddress.ts

@@ -16,7 +16,7 @@
 
 import { keccak256, sha3_256 } from 'js-sha3';
 import RIPEMD160 = require('ripemd160');
-import { Crypto, SignSchema} from '../crypto';
+import { SignSchema} from '../crypto';
 import { SHA3Hasher } from '../crypto/SHA3Hasher';
 import { Base32 } from './Base32';
 import { Convert } from './Convert';
@@ -81,7 +81,7 @@ export class RawAddress {
     public static publicKeyToAddress = (publicKey: Uint8Array,
                                         networkIdentifier: number): Uint8Array => {
         // step 1: sha3 hash of the public key
-        const signSchema = Crypto.resolveNetworkType(networkIdentifier);
+        const signSchema = SHA3Hasher.resolveSignSchema(networkIdentifier);
         const publicKeyHash = signSchema === SignSchema.SHA3 ? sha3_256.arrayBuffer(publicKey) : keccak256.arrayBuffer(publicKey);
 
         // step 2: ripemd160 hash of (1)
@@ -110,7 +110,7 @@ export class RawAddress {
      * @returns {boolean} true if the decoded address is valid, false otherwise.
      */
     public static isValidAddress = (decoded: Uint8Array, networkIdentifier: number): boolean => {
-        const signSchema = Crypto.resolveNetworkType(networkIdentifier);
+        const signSchema = SHA3Hasher.resolveSignSchema(networkIdentifier);
         const hash = signSchema === SignSchema.SHA3 ? sha3_256.create() : keccak256.create();
         const checksumBegin = RawAddress.constants.sizes.addressDecoded - RawAddress.constants.sizes.checksum;
         hash.update(decoded.subarray(0, checksumBegin));