update util functions and more tests

Author: billbsing

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## Release 0.2.11
++   can import/export private key from openssl standard encrypted base64 format
++   At the moment PEM PKCS8 format not supported
++   utils function 'hexToByteArray', 'isHexString', 'wordArrayToByteArray' and 'byteArrayToWordArray' to support the new crypto library
+
 ## Release 0.2.10
 +   removed cypto, pem-file packages and replaced with @noble/ed25519 and crypto-key-composer
 

src/KeyPair.ts

@@ -39,10 +39,10 @@ export class KeyPair {
         return new KeyPair(publicKey, privateKey)
     }
     /**
-     * Imports a keypair from a PKCS8 fromated text string. You need to pass the correct password, to decrypt
+     * Imports a keypair from a encrypted base64 text string. You need to pass the correct password, to decrypt
      * the private key stored in the text string.
      *
-     * @param text PKCS8 fromated text with the private key encrypted.
+     * @param text Encrpted base64 fromated text with the private key encrypted.
      * @param password Password to decrypt the private key.
      * @param publicKeyText Optional public key encoded in PEM format, if non provided, the public key
      * can be obtained from the private key.
@@ -57,7 +57,7 @@ export class KeyPair {
     }
 
     /**
-     * Imports a private key file. The key file is in the format as PKCS8 text. The private key is encrypted.
+     * Imports a private key file. The key file is in the format as a encrpted base64 text. The private key is encrypted.
      *
      * @param filename Filename containing the encrypted private key.
      * @param password Password to decrypt the private key.
@@ -75,11 +75,11 @@ export class KeyPair {
     }
 
     /**
-     * Export the keypair to a PKCS8 fromatted text string. The private key is encrypted using the provided password.
+     * Export the keypair to a encrypt base64 fromatted text string. The private key is encrypted using the provided password.
      *
      * @param password Password to encrypt the private key.
      *
-     * @returns The encrpted private key as a PKCS8 formatted string.
+     * @returns The encrpted private key as a encrypted base64 formatted string.
      *
      */
     public exportToString(password: string): string {
@@ -88,7 +88,7 @@ export class KeyPair {
     }
 
     /**
-     * Same as `exportToText` this writes the exported tex to a file.
+     * Same as `exportToText` this writes the exported text to a file.
      *
      * @param password Password to encrypt the private key.
      *

src/Utils.ts

@@ -12,21 +12,7 @@ interface IWordArray {
     words: Uint32Array
     sigBytes: number
 }
-export function hexToBytes(hex: string): Uint8Array {
-    if (typeof hex !== 'string') {
-        throw new TypeError('hexToBytes: expected string, got ' + typeof hex)
-    }
-    if (hex.length % 2) throw new Error('hexToBytes: received invalid unpadded hex')
-    const array = new Uint8Array(hex.length / 2)
-    for (let i = 0; i < array.length; i++) {
-        const j = i * 2
-        const hexByte = hex.slice(j, j + 2)
-        const byte = Number.parseInt(hexByte, 16)
-        if (Number.isNaN(byte) || byte < 0) throw new Error('Invalid byte sequence')
-        array[i] = byte
-    }
-    return array
-}
+
 
 /**
  * Return true if the number or string is an address value. This does not check the network for a valid
@@ -125,7 +111,7 @@ export function remove0xPrefix(value: string): string {
 export function toPublicKeyChecksum(publicKey: string): string {
     const publicKeyClean = remove0xPrefix(publicKey).toLowerCase()
     let result = '0x'
-    const hashData = sha3_256(hexToBytes(publicKeyClean))
+    const hashData = sha3_256(hexToByteArray(publicKeyClean))
     for (let index = 0; index < hashData.length && index < publicKeyClean.length; index++) {
         if (parseInt(hashData.charAt(index), 16) > 7) {
             result = result.concat(publicKeyClean.charAt(index).toUpperCase())
@@ -163,8 +149,33 @@ export function isPublicKeyChecksum(publicKey: string): boolean {
     return remove0xPrefix(publicKey) && remove0xPrefix(publicKey) == remove0xPrefix(toPublicKeyChecksum(publicKey))
 }
 
+/**
+ * Returns true if the string is a hex string
+ *
+ */
+export function isHexSring(hex: string): boolean {
+    return hex !== null && hex.match(/^[0-9a-f]+$/gi) !== null
+}
+
+/**
+ * Returns a Uint8Array of a hex string. The hex string must only contain
+ * characters from 0 - 9 and a-f
+ */
+export function hexToByteArray(hex: string): Uint8Array {
+    if ( !isHexSring(hex)) {
+        throw TypeError(`the hex string ${hex} contains non hex characters`)
+    }
+    const pairs = hex.match(/[0-9a-f]{2}/ig)
+    const values = pairs.map((p) => {
+        return parseInt(p, 16)
+    })
+    return new Uint8Array(values)
+}
+
+
 /*
  * Code originally copied from crypto-js for conversion Latin1 to and from WordArray
+ * but changed to return/input Uint8Array
  *
  */
 export function wordArrayToByteArray(wordArray: IWordArray): Uint8Array {

test/unit/Utils.test.ts

@@ -4,7 +4,7 @@
 
 */
 
-import { assert } from 'chai'
+import { assert, expect } from 'chai'
 import { randomInt, randomBytes } from 'crypto'
 
 import { Account } from '../../src/Account'
@@ -13,6 +13,7 @@ import {
     isAddress,
     isPublicKey,
     isPublicKeyChecksum,
+    hexToByteArray,
     prefix0x,
     remove0xPrefix,
     toAddress,
@@ -22,6 +23,12 @@ import {
 } from '../../src/Utils'
 
 const PUBLIC_ADDRESS = '0x5288fec4153b702430771dfac8aed0b21cafca4344dae0d47b97f0bf532b3306'
+const PUBLIC_ADDRESS_BYTES = [
+    0x52, 0x88, 0xFE, 0xC4, 0x15, 0x3B, 0x70, 0x24,
+    0x30, 0x77, 0x1D, 0xFA, 0xC8, 0xAE, 0xD0, 0xB2,
+    0x1C, 0xAF, 0xCA, 0x43, 0x44, 0xDA, 0xE0, 0xD4,
+    0x7B, 0x97, 0xF0, 0xBF, 0x53, 0x2B, 0x33, 0x06
+]
 const PUBLIC_ADDRESS_CHECHKSUM = '0x5288Fec4153b702430771DFAC8AeD0B21CAFca4344daE0d47B97F0bf532b3306'
 
 
@@ -128,6 +135,18 @@ describe('Utils module', () => {
         })
     })
 
+    describe('hexToBytes', () => {
+        it('should convert a hex string to Uint8Array', () => {
+            expect(() => hexToByteArray(PUBLIC_ADDRESS)).to.throw(TypeError, /contains non hex characters/)
+
+            let result = hexToByteArray(remove0xPrefix(PUBLIC_ADDRESS))
+            assert.equal(Uint8Array.from(PUBLIC_ADDRESS_BYTES).toString(), result.toString())
+
+            result = hexToByteArray(remove0xPrefix(PUBLIC_ADDRESS_CHECHKSUM))
+            assert.equal(Uint8Array.from(PUBLIC_ADDRESS_BYTES).toString(), result.toString())
+
+        })
+    })
     describe('Convert Uint8Array to and from WordArray for crypto-js', () => {
         it('should convert to word array', () => {
             const testLength = 64