Initial commit of improvements resulting from bitaddress.org

Author: Weston Siegenthaler

src/address.js

@@ -4,9 +4,11 @@ Bitcoin.Address = function (bytes) {
   }
   this.hash = bytes;
 
-  this.version = 0x00;
+  this.version = Bitcoin.Address.networkVersion;
 };
 
+Bitcoin.Address.networkVersion = 0x00; // mainnet
+
 /**
  * Serialize this object as a standard Bitcoin address.
  *

src/eckey.js

@@ -15,17 +15,33 @@ Bitcoin.ECKey = (function () {
       // Prepend zero byte to prevent interpretation as negative integer
       this.priv = BigInteger.fromByteArrayUnsigned(input);
     } else if ("string" == typeof input) {
-      if (input.length == 51 && input[0] == '5') {
-        // Base58 encoded private key
-        this.priv = BigInteger.fromByteArrayUnsigned(ECKey.decodeString(input));
+      var bytes = null;
+      if (ECKey.isWalletImportFormat(input)) {
+        bytes = ECKey.decodeWalletImportFormat(input);
+      } else if (ECKey.isCompressedWalletImportFormat(input)) {
+        bytes = ECKey.decodeCompressedWalletImportFormat(input);
+        this.compressed = true;
+      } else if (ECKey.isMiniFormat(input)) {
+        bytes = Crypto.SHA256(input, { asBytes: true });
+      } else if (ECKey.isHexFormat(input)) {
+        bytes = Crypto.util.hexToBytes(input);
+      } else if (ECKey.isBase64Format(input)) {
+        bytes = Crypto.util.base64ToBytes(input);
+      }
+
+      if (bytes == null || bytes.length != 32) {
+        this.priv = null;
       } else {
         // Prepend zero byte to prevent interpretation as negative integer
-        this.priv = BigInteger.fromByteArrayUnsigned(Crypto.util.base64ToBytes(input));
+        this.priv = BigInteger.fromByteArrayUnsigned(bytes);
       }
     }
-    this.compressed = !!ECKey.compressByDefault;
+
+    this.compressed = (this.compressed == undefined) ? !!ECKey.compressByDefault : this.compressed;
   };
 
+  ECKey.privateKeyPrefix = 0x80; // mainnet 0x80    testnet 0xEF
+
   /**
    * Whether public keys should be returned compressed by default.
    */
@@ -36,22 +52,45 @@ Bitcoin.ECKey = (function () {
    */
   ECKey.prototype.setCompressed = function (v) {
     this.compressed = !!v;
+    if (this.pubPoint) this.pubPoint.compressed = this.compressed;
+    return this;
   };
 
   /**
-   * Return public key in DER encoding.
+   * Return public key as a byte array in DER encoding.
    */
   ECKey.prototype.getPub = function () {
-    return this.getPubPoint().getEncoded(this.compressed);
+    if (this.compressed) {
+      if (this.pubComp) return this.pubComp;
+      return this.pubComp = this.getPubPoint().getEncoded(1);
+    } else {
+      if (this.pubUncomp) return this.pubUncomp;
+      return this.pubUncomp = this.getPubPoint().getEncoded(0);
+    }
   };
 
   /**
    * Return public point as ECPoint object.
    */
   ECKey.prototype.getPubPoint = function () {
-    if (!this.pub) this.pub = ecparams.getG().multiply(this.priv);
+    if (!this.pubPoint) {
+      this.pubPoint = ecparams.getG().multiply(this.priv);
+      this.pubPoint.compressed = this.compressed;
+    }
+    return this.pubPoint;
+  };
 
-    return this.pub;
+  /**
+   * Return public key as hexadecimal string.
+   */
+  ECKey.prototype.getPubKeyHex = function () {
+    if (this.compressed) {
+      if (this.pubKeyHexComp) return this.pubKeyHexComp;
+      return this.pubKeyHexComp = Crypto.util.bytesToHex(this.getPub()).toString().toUpperCase();
+    } else {
+      if (this.pubKeyHexUncomp) return this.pubKeyHexUncomp;
+      return this.pubKeyHexUncomp = Crypto.util.bytesToHex(this.getPub()).toString().toUpperCase();
+    }
   };
 
   /**
@@ -61,9 +100,13 @@ Bitcoin.ECKey = (function () {
    * a byte array.
    */
   ECKey.prototype.getPubKeyHash = function () {
-    if (this.pubKeyHash) return this.pubKeyHash;
-
-    return this.pubKeyHash = Bitcoin.Util.sha256ripe160(this.getPub());
+    if (this.compressed) {
+      if (this.pubKeyHashComp) return this.pubKeyHashComp;
+      return this.pubKeyHashComp = Bitcoin.Util.sha256ripe160(this.getPub());
+    } else {
+      if (this.pubKeyHashUncomp) return this.pubKeyHashUncomp;
+      return this.pubKeyHashUncomp = Bitcoin.Util.sha256ripe160(this.getPub());
+    }
   };
 
   ECKey.prototype.getBitcoinAddress = function () {
@@ -72,24 +115,66 @@ Bitcoin.ECKey = (function () {
     return addr;
   };
 
-  ECKey.prototype.getExportedPrivateKey = function () {
-    var hash = this.priv.toByteArrayUnsigned();
-    while (hash.length < 32) hash.unshift(0);
-    hash.unshift(0x80);
-    var checksum = Crypto.SHA256(Crypto.SHA256(hash, {asBytes: true}), {asBytes: true});
-    var bytes = hash.concat(checksum.slice(0,4));
-    return Bitcoin.Base58.encode(bytes);
+  /**
+   * Takes a public point as a hex string or byte array
+   */
+  ECKey.prototype.setPub = function (pub) {
+    // byte array
+    if (Bitcoin.Util.isArray(pub)) {
+      pub = Crypto.util.bytesToHex(pub).toString().toUpperCase();
+    }
+    var ecPoint = ecparams.getCurve().decodePointHex(pub);
+    this.setCompressed(ecPoint.compressed);
+    this.pubPoint = ecPoint;
+    return this;
   };
 
-  ECKey.prototype.setPub = function (pub) {
-    this.pub = ECPointFp.decodeFrom(ecparams.getCurve(), pub);
+  /**
+   * Private key encoded as standard Wallet Import Format (WIF)
+   */
+  ECKey.prototype.getBitcoinWalletImportFormat = function () {
+    var bytes = this.getBitcoinPrivateKeyByteArray();
+    bytes.unshift(ECKey.privateKeyPrefix); // prepend 0x80 byte
+    if (this.compressed) bytes.push(0x01); // append 0x01 byte for compressed format
+    var checksum = Crypto.SHA256(Crypto.SHA256(bytes, { asBytes: true }), { asBytes: true });
+    bytes = bytes.concat(checksum.slice(0, 4));
+    var privWif = Bitcoin.Base58.encode(bytes);
+    return privWif;
+  };
+
+  /**
+   * Private key encoded as hexadecimal string.
+   */
+  ECKey.prototype.getBitcoinHexFormat = function () {
+    return Crypto.util.bytesToHex(this.getBitcoinPrivateKeyByteArray()).toString().toUpperCase();
+  };
+
+  /**
+   * Private key encoded as Base64 string.
+   */
+  ECKey.prototype.getBitcoinBase64Format = function () {
+    return Crypto.util.bytesToBase64(this.getBitcoinPrivateKeyByteArray());
+  };
+
+  /**
+   * Private key encoded as raw byte array.
+   */
+  ECKey.prototype.getBitcoinPrivateKeyByteArray = function () {
+    // Get a copy of private key as a byte array
+    var bytes = this.priv.toByteArrayUnsigned();
+    // zero pad if private key is less than 32 bytes 
+    while (bytes.length < 32) bytes.unshift(0x00);
+    return bytes;
   };
 
   ECKey.prototype.toString = function (format) {
-    if (format === "base64") {
-      return Crypto.util.bytesToBase64(this.priv.toByteArrayUnsigned());
+    format = format || "";
+    if (format.toString().toLowerCase() == "base64" || format.toString().toLowerCase() == "b64") {
+      return this.getBitcoinBase64Format(); // Base 64
+    } else if (format.toString().toLowerCase() == "wif") {
+      return this.getBitcoinWalletImportFormat(); // Wallet Import Format
     } else {
-      return Crypto.util.bytesToHex(this.priv.toByteArrayUnsigned());
+      return this.getBitcoinHexFormat(); // Hex
     }
   };
 
@@ -102,10 +187,10 @@ Bitcoin.ECKey = (function () {
   };
 
   /**
-   * Parse an exported private key contained in a string.
+   * Parse a wallet import format private key contained in a string.
    */
-  ECKey.decodeString = function (string) {
-    var bytes = Bitcoin.Base58.decode(string);
+  ECKey.decodeWalletImportFormat = function (privStr) {
+    var bytes = Bitcoin.Base58.decode(privStr);
 
     var hash = bytes.slice(0, 33);
 
@@ -120,12 +205,82 @@ Bitcoin.ECKey = (function () {
 
     var version = hash.shift();
 
-    if (version != 0x80) {
+    if (version != ECKey.privateKeyPrefix) {
       throw "Version "+version+" not supported!";
     }
 
     return hash;
   };
 
+  /**
+   * Parse a compressed wallet import format private key contained in a string.
+   */
+  ECKey.decodeCompressedWalletImportFormat = function (privStr) {
+    var bytes = Bitcoin.Base58.decode(privStr);
+    var hash = bytes.slice(0, 34);
+    var checksum = Crypto.SHA256(Crypto.SHA256(hash, { asBytes: true }), { asBytes: true });
+    if (checksum[0] != bytes[34] ||
+      checksum[1] != bytes[35] ||
+      checksum[2] != bytes[36] ||
+      checksum[3] != bytes[37]) {
+        throw "Checksum validation failed!";
+      }
+    var version = hash.shift();
+    if (version != ECKey.privateKeyPrefix) {
+      throw "Version " + version + " not supported!";
+    }
+    hash.pop();
+    return hash;
+  };
+
+  /**
+   * Detects keys in hex format (64 characters [0-9A-F]).
+   */
+  ECKey.isHexFormat = function (key) {
+    key = key.toString();
+    return /^[A-Fa-f0-9]{64}$/.test(key);
+  };
+
+  /**
+   * Detects keys in base58 format (51 characters base58, always starts with a '5')
+   */
+  ECKey.isWalletImportFormat = function (key) {
+    key = key.toString();
+    return (ECKey.privateKeyPrefix == ECKey.privateKeyPrefix) ?
+      (/^5[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{50}$/.test(key)) :
+      (/^9[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{50}$/.test(key));
+  };
+
+  /**
+   * Detects keys in standard Wallet Import Format (52 characters base58)
+   */
+  ECKey.isCompressedWalletImportFormat = function (key) {
+    key = key.toString();
+    return (ECKey.privateKeyPrefix == ECKey.privateKeyPrefix) ?
+      (/^[LK][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(key)) :
+      (/^c[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(key));
+  };
+
+  /**
+   * Detects keys in base64 format (44 characters)
+   */
+  ECKey.isBase64Format = function (key) {
+    key = key.toString();
+    return (/^[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789=+\/]{44}$/.test(key));
+  };
+
+  /**
+   * Detects keys in 'mini' format (22, 26 or 30 characters, always starts with an 'S')
+   */
+  ECKey.isMiniFormat = function (key) {
+    key = key.toString();
+    var validChars22 = /^S[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{21}$/.test(key);
+    var validChars26 = /^S[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{25}$/.test(key);
+    var validChars30 = /^S[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{29}$/.test(key);
+    var testBytes = Crypto.SHA256(key + "?", { asBytes: true });
+
+    return ((testBytes[0] === 0x00 || testBytes[0] === 0x01) && (validChars22 || validChars26 || validChars30));
+  };
+
   return ECKey;
 })();

src/util.js

@@ -218,6 +218,15 @@ Bitcoin.Util = {
    */
   sha256ripe160: function (data) {
     return Crypto.RIPEMD160(Crypto.SHA256(data, {asBytes: true}), {asBytes: true});
+  },
+  /**
+   * Calculate SHA256(SHA256(data)).
+   *
+   * Takes an arbitrary byte array as inputs and returns the doubly hashed
+   * data as a byte array.
+   */
+  dsha256: function (data) {
+    return Crypto.SHA256(Crypto.SHA256(data, { asBytes: true }), { asBytes: true });
   }
 };