Merge pull request #254 from rg911/task/g253_signSchema_refactoring

JAV-18 [Github #253] Signature Schema Refactoring

Author: rg911

src/core/crypto/Crypto.ts

@@ -17,8 +17,9 @@
 import { WalletAlgorithm } from '../../model/wallet/WalletAlgorithm';
 import { Convert as convert } from '../format/Convert';
 import { KeyPair } from './KeyPair';
-import * as utility from './Utilities';
 import { SignSchema } from './SignSchema';
+import * as utility from './Utilities';
+// tslint:disable-next-line: no-var-requires
 const CryptoJS = require('crypto-js');
 export class Crypto {
     /**
@@ -219,10 +220,10 @@ export class Crypto {
      * @param {string} msg - A text message
      * @param {Uint8Array} iv - An initialization vector
      * @param {Uint8Array} salt - A salt
-     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @return {string} - The encoded message
      */
-    public static _encode = (senderPriv, recipientPub, msg, iv, salt, signSchema: SignSchema = SignSchema.SHA3) => {
+    public static _encode = (senderPriv, recipientPub, msg, iv, salt, signSchema: SignSchema) => {
         // Errors
         if (!senderPriv || !recipientPub || !msg || !iv || !salt) { throw new Error('Missing argument !'); }
         // Processing
@@ -244,10 +245,10 @@ export class Crypto {
      * @param {string} senderPriv - A sender private key
      * @param {string} recipientPub - A recipient public key
      * @param {string} msg - A text message
-     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @return {string} - The encoded message
      */
-    public static encode = (senderPriv, recipientPub, msg, signSchema: SignSchema = SignSchema.SHA3) => {
+    public static encode = (senderPriv, recipientPub, msg, signSchema: SignSchema) => {
         // Errors
         if (!senderPriv || !recipientPub || !msg) { throw new Error('Missing argument !'); }
         // Processing
@@ -264,10 +265,10 @@ 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 {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @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, signSchema: SignSchema = SignSchema.SHA3) => {
+    public static _decode = (recipientPrivate, senderPublic, payload, iv, salt, signSchema: SignSchema) => {
         // Error
         if (!recipientPrivate || !senderPublic || !payload) { throw new Error('Missing argument !'); }
         // Processing
@@ -290,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 {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @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, signSchema: SignSchema = SignSchema.SHA3) => {
+    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, signSchema);
+        const decoded = Crypto._decode(recipientPrivate, senderPublic, payloadBuffer, iv, salt, signSchema);
         return decoded;
     }
 

src/core/crypto/KeyPair.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { NetworkType } from '../../model/blockchain/NetworkType';
 import { Convert as convert } from '../format';
 import { SignSchema } from './SignSchema';
 import * as Utility from './Utilities';
@@ -21,18 +22,15 @@ export class KeyPair {
     /**
      * Creates a key pair from a private key string.
      * @param {string} privateKeyString A hex encoded private key string.
-     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {module:crypto/keyPair~KeyPair} The key pair.
      */
-    public static createKeyPairFromPrivateKeyString = (privateKeyString, signSchema = SignSchema.SHA3) => {
+    public static createKeyPairFromPrivateKeyString = (privateKeyString: string, signSchema: SignSchema) => {
         const privateKey = convert.hexToUint8(privateKeyString);
-
-        // KECCAK_REVERSED_KEY uses reversed private key.
-        const secretKey = signSchema === SignSchema.SHA3 ? privateKey : convert.hexToUint8Reverse(privateKeyString);
         if (Utility.Key_Size !== privateKey.length) {
             throw Error(`private key has unexpected size: ${privateKey.length}`);
         }
-        const publicKey = Utility.catapult_crypto.extractPublicKey(secretKey, Utility.catapult_hash.func, signSchema);
+        const publicKey = Utility.catapult_crypto.extractPublicKey(privateKey, Utility.catapult_hash.func, signSchema);
         return {
             privateKey,
             publicKey,
@@ -43,16 +41,11 @@ 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 {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {Uint8Array} The signature.
      */
-    public static sign = (keyPair, data, signSchema = SignSchema.SHA3) => {
-        let secretKey = keyPair.privateKey;
-        // KECCAK_REVERSED_KEY uses reversed private key.
-        if (signSchema === SignSchema.KECCAK_REVERSED_KEY) {
-            secretKey = convert.hexToUint8Reverse(convert.uint8ToHex(secretKey));
-        }
-        return Utility.catapult_crypto.sign(data, keyPair.publicKey, secretKey,
+    public static sign = (keyPair, data: Uint8Array, signSchema: SignSchema) => {
+        return Utility.catapult_crypto.sign(data, keyPair.publicKey, keyPair.privateKey,
                 Utility.catapult_hash.createHasher(64, signSchema));
     }
 
@@ -61,10 +54,10 @@ export class KeyPair {
      * @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 {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @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, signature, signSchema = SignSchema.SHA3) => {
+    public static verify = (publicKey, data: Uint8Array, signature: Uint8Array, signSchema: SignSchema) => {
         return Utility.catapult_crypto.verify(publicKey, data, signature, Utility.catapult_hash.createHasher(64, signSchema));
     }
 
@@ -74,21 +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 {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {Uint8Array} The shared key.
      */
-    public static deriveSharedKey = (keyPair, publicKey, salt, signSchema = SignSchema.SHA3) => {
+    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}`);
         }
-        let secretKey = keyPair.privateKey;
-        // KECCAK_REVERSED_KEY uses reversed private key.
-        if (signSchema === SignSchema.KECCAK_REVERSED_KEY) {
-            secretKey = convert.hexToUint8Reverse(convert.uint8ToHex(secretKey));
-        }
-        return Utility.catapult_crypto.deriveSharedKey(salt, secretKey, publicKey, Utility.catapult_hash.func, signSchema);
+        return Utility.catapult_crypto.deriveSharedKey(salt, keyPair.privateKey, publicKey, Utility.catapult_hash.func, signSchema);
     }
 }

src/core/crypto/SHA3Hasher.ts

@@ -15,6 +15,7 @@
  */
 
 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 { SignSchema } from './SignSchema';
 
@@ -24,9 +25,9 @@ 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 {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      */
-    public static func = (dest, data, length, signSchema = SignSchema.SHA3) => {
+    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));
@@ -35,10 +36,10 @@ export class SHA3Hasher {
     /**
      * Creates a hasher object.
      * @param {numeric} length The hash length in bytes.
-     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {object} The hasher.
      */
-    public static createHasher = (length = 64, signSchema = SignSchema.SHA3) => {
+    public static createHasher = (length = 64, signSchema: SignSchema) => {
         let hash;
         return {
             reset: () => {
@@ -62,13 +63,27 @@ export class SHA3Hasher {
     /**
      * Get a hasher instance.
      * @param {numeric} length The hash length in bytes.
-     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK(NIS1) / SHA3(Catapult))
      * @returns {object} The hasher.
      */
-    public static getHasher = (length = 64, signSchema = SignSchema.SHA3) => {
+    public static getHasher = (length = 64, signSchema: SignSchema) => {
         return {
             32: signSchema === SignSchema.SHA3 ? sha3_256 : keccak256,
             64: signSchema === SignSchema.SHA3 ? sha3_512 : keccak512 ,
         } [length];
     }
+
+    /**
+     * 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/SignSchema.ts

@@ -15,10 +15,10 @@
  */
 
  /**
-  * [KECCAK_REVERSED_KEY]: Keccak hash algorithm with reversed private keys.
+  * [KECCAK]: Keccak hash algorithm.
   * [SHA3]: SHA3 hash algorithm without key reversal
   */
 export enum SignSchema {
-    KECCAK_REVERSED_KEY = 1,
+    KECCAK = 1,
     SHA3 = 2,
 }

src/core/crypto/Utilities.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import { RawArray as array } from '../format';
 import * as nacl from './nacl_catapult';
 import { SHA3Hasher as sha3Hasher } from './SHA3Hasher';

src/core/format/RawAddress.ts

@@ -16,7 +16,9 @@
 
 import { keccak256, sha3_256 } from 'js-sha3';
 import RIPEMD160 = require('ripemd160');
-import { SignSchema } from '../crypto';
+import { NetworkType } from '../../model/blockchain/NetworkType';
+import { SignSchema} from '../crypto';
+import { SHA3Hasher } from '../crypto/SHA3Hasher';
 import { Base32 } from './Base32';
 import { Convert } from './Convert';
 import { RawArray } from './RawArray';
@@ -74,28 +76,28 @@ export class RawAddress {
     /**
      * Converts a public key to a decoded address for a specific network.
      * @param {Uint8Array} publicKey The public key.
-     * @param {number} networkIdentifier The network identifier.
-     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {NetworkType} networkType The network identifier.
      * @returns {Uint8Array} The decoded address corresponding to the inputs.
      */
     public static publicKeyToAddress = (publicKey: Uint8Array,
-                                        networkIdentifier: number,
-                                        signSchema: SignSchema = SignSchema.SHA3): Uint8Array => {
+                                        networkType: NetworkType): Uint8Array => {
         // step 1: sha3 hash of the public key
+        const signSchema = SHA3Hasher.resolveSignSchema(networkType);
         const publicKeyHash = signSchema === SignSchema.SHA3 ? sha3_256.arrayBuffer(publicKey) : keccak256.arrayBuffer(publicKey);
 
         // step 2: ripemd160 hash of (1)
         const ripemdHash = new RIPEMD160().update(new Buffer(publicKeyHash)).digest();
 
         // step 3: add network identifier byte in front of (2)
         const decodedAddress = new Uint8Array(RawAddress.constants.sizes.addressDecoded);
-        decodedAddress[0] = networkIdentifier;
+        decodedAddress[0] = networkType;
         RawArray.copy(decodedAddress, ripemdHash, RawAddress.constants.sizes.ripemd160, 1);
 
         // step 4: concatenate (3) and the checksum of (3)
         const hash = signSchema === SignSchema.SHA3 ?
             sha3_256.arrayBuffer(decodedAddress.subarray(0, RawAddress.constants.sizes.ripemd160 + 1)) :
             keccak256.arrayBuffer(decodedAddress.subarray(0, RawAddress.constants.sizes.ripemd160 + 1));
+
         RawArray.copy(decodedAddress, RawArray.uint8View(hash),
             RawAddress.constants.sizes.checksum, RawAddress.constants.sizes.ripemd160 + 1);
 
@@ -105,10 +107,11 @@ export class RawAddress {
     /**
      * Determines the validity of a decoded address.
      * @param {Uint8Array} decoded The decoded address.
-     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @param {NetworkType} networkType The network identifier.
      * @returns {boolean} true if the decoded address is valid, false otherwise.
      */
-    public static isValidAddress = (decoded: Uint8Array, signSchema: SignSchema = SignSchema.SHA3): boolean => {
+    public static isValidAddress = (decoded: Uint8Array, networkType: NetworkType): boolean => {
+        const signSchema = SHA3Hasher.resolveSignSchema(networkType);
         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));
@@ -120,16 +123,17 @@ export class RawAddress {
     /**
      * Determines the validity of an encoded address string.
      * @param {string} encoded The encoded address string.
+     * @param {NetworkType} networkType The network identifier.
      * @returns {boolean} true if the encoded address string is valid, false otherwise.
      */
-    public static isValidEncodedAddress = (encoded: string): boolean => {
+    public static isValidEncodedAddress = (encoded: string, networkType: NetworkType): boolean => {
         if (RawAddress.constants.sizes.addressEncoded !== encoded.length) {
             return false;
         }
 
         try {
             const decoded = RawAddress.stringToAddress(encoded);
-            return RawAddress.isValidAddress(decoded);
+            return RawAddress.isValidAddress(decoded, networkType);
         } catch (err) {
             return false;
         }

src/core/utils/TransactionMapping.ts

@@ -35,12 +35,10 @@ export class TransactionMapping {
      * Create transaction class from payload binary.
      * @param {string} payload The transaction binary payload
      * @param {Boolean} isEmbedded Is embedded transaction (Default: false)
-     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
      * @returns {Transaction | InnerTransaction} The transaction class.
      */
     public static createFromPayload(payload: string,
-                                    isEmbedded = false,
-                                    signSchema = SignSchema.SHA3): Transaction | InnerTransaction {
-        return CreateTransactionFromPayload(payload, isEmbedded, signSchema);
+                                    isEmbedded = false): Transaction | InnerTransaction {
+        return CreateTransactionFromPayload(payload, isEmbedded);
     }
 }