ethereumjs / keythereum / 62

pending completion

Build # 62

Build Type

push

travis-ci

Committed by

tinybike

Commit Message

Revert "Merge pull request #7 from thinkloop/newer-scrypt"

This reverts commit 663bfefa0, reversing
changes made to 47e7edb59.

Run Details

25 of 25 new or added lines in 1 file covered. (100.0%)

164 of 179 relevant lines covered (91.62%)

210.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.62

/index.js

/**
 * keythereum: create/import/export ethereum keys
 * @author Jack Peterson (jack@tinybike.net)
 */

"use strict";

var NODE_JS = (typeof module !== "undefined") && process && !process.browser;

var path = (NODE_JS) ? require("path") : null;
var fs = (NODE_JS) ? require("fs") : null;
var crypto = require("crypto");
var uuid = require("node-uuid");
var validator = require("validator");
var ecdsa = new (require("elliptic").ec)("secp256k1");
var pubToAddress = require("ethereumjs-util").pubToAddress;
var keccak = require("./lib/keccak");
var scrypt = require("./lib/scrypt")(280000000);

// convert string to buffer
function str2buf(str, enc) {
    if (str.constructor === String) {
        if (enc) {
            str = new Buffer(str, enc);
        } else {
            if (validator.isHexadecimal(str)) {
                str = new Buffer(str, "hex");
            } else if (validator.isBase64(str)) {
                str = new Buffer(str, "base64");
            } else {
                str = new Buffer(str);
            }
        }
    }
    return str;
}

// convert hex to UTF-16LE
function hex2utf16le(input) {
    var output = '';
    for (var i = 0, l = input.length; i < l; i += 4) {
        output += '\\u' + input.slice(i+2, i+4) + input.slice(i, i+2);
    }
    return JSON.parse('"' + output + '"');
}

function isFunction(f) {
    return Object.prototype.toString.call(f) === "[object Function]";
}

module.exports = {

    browser: !NODE_JS,

    constants: {

        // Suppress logging
        quiet: false,

        // Symmetric cipher for private key encryption
        cipher: "aes-128-ctr",

        // Initialization vector size in bytes
        ivBytes: 16,

        // ECDSA private key size in bytes
        keyBytes: 32,

        // Key derivation function parameters
        pbkdf2: {
            c: 65536,
            dklen: 32,
            hash: "sha256",
            prf: "hmac-sha256"
        },
        scrypt: {
            dklen: 32,
            n: 65536,
            r: 1,
            p: 8
        }
    },

    /**
     * Symmetric private key encryption using secret (derived) key.
     * @param {buffer|string} plaintext Text to be encrypted.
     * @param {buffer|string} key Secret key.
     * @param {buffer|string} iv Initialization vector.
     * @param {string=} algo Encryption algorithm (default: constants.cipher).
     * @return {string} Base64 encrypted text.
     */
    encrypt: function (plaintext, key, iv, algo) {
        var cipher, ciphertext;

        if (plaintext.constructor === String) plaintext = str2buf(plaintext);
        if (key.constructor === String) key = str2buf(key);
        if (iv.constructor === String) iv = str2buf(iv);

        cipher = crypto.createCipheriv(algo || this.constants.cipher, key, iv);
        ciphertext = cipher.update(plaintext.toString("hex"), "hex", "base64");

        return ciphertext + cipher.final("base64");
    },

    /**
     * Symmetric private key decryption using secret (derived) key.
     * @param {buffer|string} ciphertext Text to be decrypted.
     * @param {buffer|string} key Secret key.
     * @param {buffer|string} iv Initialization vector.
     * @param {string=} algo Encryption algorithm (default: constants.cipher).
     * @return {string} Hex decryped text.
     */
    decrypt: function (ciphertext, key, iv, algo) {
        var decipher, plaintext;

        if (ciphertext.constructor === String) ciphertext = str2buf(ciphertext);
        if (key.constructor === String) key = str2buf(key);
        if (iv.constructor === String) iv = str2buf(iv);

        decipher = crypto.createDecipheriv(algo || this.constants.cipher, key, iv);
        plaintext = decipher.update(ciphertext.toString("base64"), "base64", "hex");

        return plaintext + decipher.final("hex");
    },

    /**
     * Derive Ethereum address from private key.
     * @param {buffer|string} privateKey ECDSA private key.
     * @return {string} Hex-encoded Ethereum address.
     */
    privateKeyToAddress: function (privateKey) {

        if (privateKey.constructor === String)
            privateKey = str2buf(privateKey);

        return "0x" + pubToAddress(new Buffer(
            ecdsa.keyFromPrivate(privateKey).getPublic("arr")
        )).toString("hex");
    },

    /**
     * Calculate message authentication code from secret (derived) key and
     * encrypted text.  The MAC is the keccak-256 hash of the byte array
     * formed by concatenating the second 16 bytes of the derived key with
     * the ciphertext key's contents.
     * @param {buffer|string} derivedKey Secret key derived from password.
     * @param {buffer|string} ciphertext Text encrypted with secret key.
     * @return {string} Hex-encoded MAC.
     */
    getMAC: function (derivedKey, ciphertext) {
        if (derivedKey !== undefined && derivedKey !== null &&
            ciphertext !== undefined && ciphertext !== null)
        {
            if (derivedKey.constructor === Buffer)
                derivedKey = derivedKey.toString("hex");

            if (ciphertext.constructor === Buffer)
                ciphertext = ciphertext.toString("hex");

            return keccak(
                hex2utf16le(derivedKey.slice(32, 64) + ciphertext)
            );
        }
    },

    /**
     * Derive secret key from password with key dervation function.
     * @param {string|buffer} password User-supplied password.
     * @param {string|buffer} salt Randomly generated salt.
     * @param {Object=} options Encryption parameters.
     * @param {string=} options.kdf Key derivation function (default: pbkdf2).
     * @param {string=} options.cipher Symmetric cipher (default: constants.cipher).
     * @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).
     * @param {function=} cb Callback function (optional).
     * @return {buffer} Secret key derived from password.
     */
    deriveKey: function (password, salt, options, cb) {
        if (password && salt) {
            options = options || {};
            options.kdfparams = options.kdfparams || {};

            // convert strings to buffers
            if (password.constructor === String)
                password = str2buf(password, "utf8");
            if (salt.constructor === String)
                salt = str2buf(salt);

            // use scrypt as key derivation function
            if (options.kdf === "scrypt") {

                try {

                    if (isFunction(cb)) {

                        setTimeout(function () {
                            cb(new Buffer(
                                scrypt.to_hex(scrypt.crypto_scrypt(
                                    password,
                                    salt,
                                    options.kdfparams.n || this.constants.scrypt.n,
                                    options.kdfparams.r || this.constants.scrypt.r,
                                    options.kdfparams.p || this.constants.scrypt.p,
                                    options.kdfparams.dklen || this.constants.scrypt.dklen
                                )
                            ), "hex"));
                        }.bind(this), 0);

                    } else {

                        return new Buffer(
                            scrypt.to_hex(scrypt.crypto_scrypt(
                                password,
                                salt,
                                options.kdfparams.n || this.constants.scrypt.n,
                                options.kdfparams.r || this.constants.scrypt.r,
                                options.kdfparams.p || this.constants.scrypt.p,
                                options.kdfparams.dklen || this.constants.scrypt.dklen
                            )
                        ), "hex");

                    }

                } catch (ex) {
                    if (isFunction(cb)) {
                        cb(ex);
                    } else {
                        return ex;
                    }
                }

            // use default key derivation function (PBKDF2)
            } else {

                var prf = options.kdfparams.prf || this.constants.pbkdf2.prf;
                if (prf === "hmac-sha256") prf = "sha256";

                if (isFunction(cb)) {

                    crypto.pbkdf2(
                        password,
                        salt,
                        options.kdfparams.c || this.constants.pbkdf2.c,
                        options.kdfparams.dklen || this.constants.pbkdf2.dklen,
                        prf,
                        function (ex, derivedKey) {
                            if (ex) return ex;
                            cb(derivedKey);
                        }
                    );

                } else {
                    
                    try {
                        return crypto.pbkdf2Sync(
                            password,
                            salt,
                            options.kdfparams.c || this.constants.pbkdf2.c,
                            options.kdfparams.dklen || this.constants.pbkdf2.dklen,
                            prf
                        );

                    } catch (ex) {
                        return ex;
                    }
                }
            }
        }
    },

    /**
     * Generate random numbers for private key, initialization vector,
     * and salt (for key derivation).
     * @param {Object=} params Encryption options (defaults: constants).
     * @param {string=} params.keyBytes Private key size in bytes.
     * @param {string=} params.ivBytes Initialization vector size in bytes.
     * @param {function=} cb Callback function (optional).
     * @return {Object<string,buffer>} Private key, IV and salt.
     */
    create: function (params, cb) {
        params = params || {};
        var keyBytes = params.keyBytes || this.constants.keyBytes;
        var ivBytes = params.ivBytes || this.constants.ivBytes;

        // asynchronous key generation if callback is provided
        if (isFunction(cb)) {

            // generate private key
            crypto.randomBytes(keyBytes, function (ex, privateKey) {
                if (ex) {
                    cb(ex);
                } else {

                    // generate random initialization vector
                    crypto.randomBytes(ivBytes, function (ex, iv) {
                        if (ex) {
                            cb(ex);
                        } else {

                            // generate random salt
                            crypto.randomBytes(keyBytes, function (ex, salt) {
                                if (ex) {
                                    cb(ex);
                                } else {

                                    cb({
                                        privateKey: privateKey,
                                        iv: iv,
                                        salt: salt
                                    });
                                }
                            });
                        }

                    }); // crypto.randomBytes
                }

            }); // crypto.randomBytes

        // synchronous key generation
        } else {

            try {
                return {
                    privateKey: crypto.randomBytes(keyBytes),
                    iv: crypto.randomBytes(ivBytes),
                    salt: crypto.randomBytes(keyBytes)
                };

            // couldn't generate key: not enough entropy?
            } catch (ex) {
                return ex;
            }
        }
    },

    /**
     * Assemble key data object in secret-storage format.
     * @param {buffer} derivedKey Password-derived secret key.
     * @param {buffer} privateKey Private key.
     * @param {buffer} salt Randomly generated salt.
     * @param {buffer} iv Initialization vector.
     * @param {Object=} options Encryption parameters.
     * @param {string=} options.kdf Key derivation function (default: pbkdf2).
     * @param {string=} options.cipher Symmetric cipher (default: constants.cipher).
     * @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).
     * @return {Object}
     */
    marshal: function(derivedKey, privateKey, salt, iv, options) {
        var ciphertext, keyObject;
        options = options || {};
        options.kdfparams = options.kdfparams || {};

        // encrypt using first 16 bytes of derived key
        ciphertext = new Buffer(this.encrypt(
            privateKey,
            derivedKey.slice(0, 16),
            iv
        ), "base64").toString("hex");

        keyObject = {
            address: this.privateKeyToAddress(privateKey).slice(2),
            crypto: {
                cipher: options.cipher || this.constants.cipher,
                ciphertext: ciphertext,
                cipherparams: { iv: iv.toString("hex") },
                mac: this.getMAC(derivedKey, ciphertext)
            },
            id: uuid.v4(), // random 128-bit UUID
            version: 3
        };

        if (options.kdf === "scrypt") {
            keyObject.crypto.kdf = "scrypt";
            keyObject.crypto.kdfparams = {
                dklen: options.kdfparams.dklen || this.constants.scrypt.dklen,
                n: options.kdfparams.n || this.constants.scrypt.n,
                r: options.kdfparams.r || this.constants.scrypt.r,
                p: options.kdfparams.p || this.constants.scrypt.p,
                salt: salt.toString("hex")
            };

        } else {
            keyObject.crypto.kdf = "pbkdf2";
            keyObject.crypto.kdfparams = {
                c: options.kdfparams.c || this.constants.pbkdf2.c,
                dklen: options.kdfparams.dklen || this.constants.pbkdf2.dklen,
                prf: options.kdfparams.prf || this.constants.pbkdf2.prf,
                salt: salt.toString("hex")
            };
        }

        return keyObject;
    },

    /**
     * Export private key to keystore secret-storage format.
     * @param {string|buffer} password User-supplied password.
     * @param {string|buffer} privateKey Private key.
     * @param {string|buffer} salt Randomly generated salt.
     * @param {string|buffer} iv Initialization vector.
     * @param {Object=} options Encryption parameters.
     * @param {string=} options.kdf Key derivation function (default: pbkdf2).
     * @param {string=} options.cipher Symmetric cipher (default: constants.cipher).
     * @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).
     * @param {function=} cb Callback function (optional).
     * @return {Object}
     */
    dump: function (password, privateKey, salt, iv, options, cb) {
        options = options || {};
        if (iv.constructor === String) iv = str2buf(iv);
        if (privateKey.constructor === String) privateKey = str2buf(privateKey);

        // asynchronous if callback provided
        if (isFunction(cb)) {

            this.deriveKey(
                password,
                salt,
                options,
                function (derivedKey) {
                    cb(this.marshal(
                        derivedKey,
                        privateKey,
                        salt,
                        iv,
                        options
                    ));
                }.bind(this)
            );

        // synchronous if no callback
        } else {

            return this.marshal(
                this.deriveKey(password, salt, options),
                privateKey,
                salt,
                iv,
                options
            );
        }
    },

    /**
     * Recover plaintext private key from secret-storage key object.
     * @param {Object} keyObject Keystore object.
     * @param {function=} cb Callback function (optional).
     * @return {buffer} Plaintext private key.
     */
    recover: function (password, keyObject, cb) {
        var self = this;
        var keyObjectCrypto = keyObject.Crypto || keyObject.crypto;

        function verifyAndDecrypt(derivedKey, salt, iv, ciphertext) {

            // verify that message authentication codes match
            var mac = self.getMAC(derivedKey, ciphertext);
            if (mac === keyObjectCrypto.mac) {

                return new Buffer(self.decrypt(
                    ciphertext,
                    derivedKey.slice(0, 16),
                    iv
                ), "hex");
            
            } else {
                throw new Error("message authentication code mismatch");
            }
        }

        var iv = keyObjectCrypto.cipherparams.iv;
        var salt = keyObjectCrypto.kdfparams.salt;
        var ciphertext = keyObjectCrypto.ciphertext;

        if (iv && iv.constructor === String) iv = str2buf(iv);
        if (salt && salt.constructor === String) salt = str2buf(salt);
        if (ciphertext && ciphertext.constructor === String)
            ciphertext = str2buf(ciphertext);

        if (keyObjectCrypto.kdf === "scrypt") {
            this.constants.scrypt = {
                n: keyObjectCrypto.kdfparams.n,
                r: keyObjectCrypto.kdfparams.r,
                p: keyObjectCrypto.kdfparams.p,
                dklen: keyObjectCrypto.kdfparams.dklen
            };
        } else {
            if (keyObjectCrypto.kdfparams.prf !== "hmac-sha256") {
                throw new Error("PBKDF2 only supported with HMAC-SHA256");
            }
            this.constants.pbkdf2.c = keyObjectCrypto.kdfparams.c;
            this.constants.pbkdf2.dklen = keyObjectCrypto.kdfparams.dklen;
        }

        // derive secret key from password
        if (isFunction(cb)) {
            this.deriveKey(password, salt, keyObjectCrypto, function (derivedKey) {
                cb(verifyAndDecrypt(derivedKey, salt, iv, ciphertext));
            });
        } else {
            return verifyAndDecrypt(
                this.deriveKey(password, salt, keyObjectCrypto),
                salt,
                iv,
                ciphertext
            );
        }
    },

    /**
     * Export formatted JSON to keystore file.
     * @param {Object} keyObject Keystore object.
     * @param {string=} keystore Path to keystore folder (default: "keystore").
     * @param {function=} cb Callback function (optional).
     * @return {string} JSON filename (Node.js) or JSON string (browser).
     */
    exportToFile: function (keyObject, keystore, cb) {
        var self = this;
        var outfile, outpath, json;

        function instructions(outpath) {
            if (!self.constants.quiet) {
                console.log(
                    "Saved to file:\n" + outpath + "\n"+
                    "To use with geth, copy this file to your Ethereum "+
                    "keystore folder (usually ~/.ethereum/keystore)."
                );
            }
        }

        keystore = keystore || "keystore";
        outfile = "UTC--" + new Date().toISOString() + "--" + keyObject.address;
        outpath = path.join(keystore, outfile);
        json = JSON.stringify(keyObject);

        if (this.browser) {
            if (!isFunction(cb)) return json;
            return cb(json);
        }
        if (!isFunction(cb)) {
            fs.writeFileSync(outpath, json);
            instructions(outpath);
            return outpath;
        }
        return fs.writeFile(outpath, json, function (ex) {
            if (ex) throw ex;
            instructions(outpath);
            cb(outpath);
        });
    },

    /**
     * Import key data object from keystore JSON file.
     * (Note: Node.js only!)
     * @param {string} address Ethereum address to import.
     * @param {string=} datadir Ethereum data directory (default: ~/.ethereum).
     * @param {function=} cb Callback function (optional).
     * @return {Object} Keystore data file's contents.
     */
    importFromFile: function (address, datadir, cb) {
        address = address.replace('0x', '');

        function findKeyfile(keystore, address, files) {
            var filepath = null;
            for (var i = 0, len = files.length; i < len; ++i) {
                if (files[i].indexOf(address) > -1) {
                    filepath = path.join(keystore, files[i]);
                    if (fs.lstatSync(filepath).isDirectory()) {
                        filepath = path.join(filepath, files[i]);
                    }
                    break;
                }
            }
            return filepath;
        }

        if (this.browser) {
            throw new Error("method only available in Node.js");
        }
        datadir = datadir || path.join(process.env.HOME, ".ethereum");
        var keystore = path.join(datadir, "keystore");
        if (!isFunction(cb)) {
            var filepath = findKeyfile(keystore, address, fs.readdirSync(keystore));
            if (filepath) {
                return JSON.parse(fs.readFileSync(filepath));
            } else {
                throw new Error(
                    "could not find key file for address " + address
                );
            }
        }
        fs.readdir(keystore, function (ex, files) {
            if (ex) return cb(ex);
            var filepath = findKeyfile(keystore, address, files);
            if (filepath) return cb(JSON.parse(fs.readFileSync(filepath)));
            return new Error(
                "could not find key file for address " + address
            );
        });
    }

};

1	/**
2	* keythereum: create/import/export ethereum keys
3	* @author Jack Peterson (jack@tinybike.net)
4	*/
5
6	"use strict";
7
8	var NODE_JS = (typeof module !== "undefined") && process && !process.browser;	5✔
9
10	var path = (NODE_JS) ? require("path") : null;	5✔
11	var fs = (NODE_JS) ? require("fs") : null;	5✔
12	var crypto = require("crypto");	5✔
13	var uuid = require("node-uuid");	5✔
14	var validator = require("validator");	5✔
15	var ecdsa = new (require("elliptic").ec)("secp256k1");	5✔
16	var pubToAddress = require("ethereumjs-util").pubToAddress;	5✔
17	var keccak = require("./lib/keccak");	5✔
18	var scrypt = require("./lib/scrypt")(280000000);	5✔
19
20	// convert string to buffer
21	function str2buf(str, enc) {	5✔
22	if (str.constructor === String) {	400✔
23	if (enc) {	400✔
24	str = new Buffer(str, enc);	80✔
25	} else {
26	if (validator.isHexadecimal(str)) {	320✔
27	str = new Buffer(str, "hex");	250✔
28	} else if (validator.isBase64(str)) {	70✔
29	str = new Buffer(str, "base64");	70✔
30	} else {
31	str = new Buffer(str);	×
32	}
33	}
34	}
35	return str;	400✔
36	}
37
38	// convert hex to UTF-16LE
39	function hex2utf16le(input) {	5✔
40	var output = '';	70✔
41	for (var i = 0, l = input.length; i < l; i += 4) {	70✔
42	output += '\\u' + input.slice(i+2, i+4) + input.slice(i, i+2);	1,680✔
43	}
44	return JSON.parse('"' + output + '"');	70✔
45	}
46
47	function isFunction(f) {	5✔
48	return Object.prototype.toString.call(f) === "[object Function]";	3,240✔
49	}
50
51	module.exports = {	5✔
52
53	browser: !NODE_JS,
54
55	constants: {
56
57	// Suppress logging
58	quiet: false,
59
60	// Symmetric cipher for private key encryption
61	cipher: "aes-128-ctr",
62
63	// Initialization vector size in bytes
64	ivBytes: 16,
65
66	// ECDSA private key size in bytes
67	keyBytes: 32,
68
69	// Key derivation function parameters
70	pbkdf2: {
71	c: 65536,
72	dklen: 32,
73	hash: "sha256",
74	prf: "hmac-sha256"
75	},
76	scrypt: {
77	dklen: 32,
78	n: 65536,
79	r: 1,
80	p: 8
81	}
82	},
83
84	/**
85	* Symmetric private key encryption using secret (derived) key.
86	* @param {buffer\|string} plaintext Text to be encrypted.
87	* @param {buffer\|string} key Secret key.
88	* @param {buffer\|string} iv Initialization vector.
89	* @param {string=} algo Encryption algorithm (default: constants.cipher).
90	* @return {string} Base64 encrypted text.
91	*/
92	encrypt: function (plaintext, key, iv, algo) {
93	var cipher, ciphertext;	50✔
94
95	if (plaintext.constructor === String) plaintext = str2buf(plaintext);	50✔
96	if (key.constructor === String) key = str2buf(key);	50✔
97	if (iv.constructor === String) iv = str2buf(iv);	50✔
98
99	cipher = crypto.createCipheriv(algo \|\| this.constants.cipher, key, iv);	50✔
100	ciphertext = cipher.update(plaintext.toString("hex"), "hex", "base64");	50✔
101
102	return ciphertext + cipher.final("base64");	50✔
103	},
104
105	/**
106	* Symmetric private key decryption using secret (derived) key.
107	* @param {buffer\|string} ciphertext Text to be decrypted.
108	* @param {buffer\|string} key Secret key.
109	* @param {buffer\|string} iv Initialization vector.
110	* @param {string=} algo Encryption algorithm (default: constants.cipher).
111	* @return {string} Hex decryped text.
112	*/
113	decrypt: function (ciphertext, key, iv, algo) {
114	var decipher, plaintext;	70✔
115
116	if (ciphertext.constructor === String) ciphertext = str2buf(ciphertext);	70✔
117	if (key.constructor === String) key = str2buf(key);	70✔
118	if (iv.constructor === String) iv = str2buf(iv);	70✔
119
120	decipher = crypto.createDecipheriv(algo \|\| this.constants.cipher, key, iv);	70✔
121	plaintext = decipher.update(ciphertext.toString("base64"), "base64", "hex");	70✔
122
123	return plaintext + decipher.final("hex");	70✔
124	},
125
126	/**
127	* Derive Ethereum address from private key.
128	* @param {buffer\|string} privateKey ECDSA private key.
129	* @return {string} Hex-encoded Ethereum address.
130	*/
131	privateKeyToAddress: function (privateKey) {
132
133	if (privateKey.constructor === String)	50✔
134	privateKey = str2buf(privateKey);	20✔
135
136	return "0x" + pubToAddress(new Buffer(	50✔
137	ecdsa.keyFromPrivate(privateKey).getPublic("arr")
138	)).toString("hex");
139	},
140
141	/**
142	* Calculate message authentication code from secret (derived) key and
143	* encrypted text. The MAC is the keccak-256 hash of the byte array
144	* formed by concatenating the second 16 bytes of the derived key with
145	* the ciphertext key's contents.
146	* @param {buffer\|string} derivedKey Secret key derived from password.
147	* @param {buffer\|string} ciphertext Text encrypted with secret key.
148	* @return {string} Hex-encoded MAC.
149	*/
150	getMAC: function (derivedKey, ciphertext) {
151	if (derivedKey !== undefined && derivedKey !== null &&	70✔
152	ciphertext !== undefined && ciphertext !== null)
153	{
154	if (derivedKey.constructor === Buffer)	70✔
155	derivedKey = derivedKey.toString("hex");	60✔
156
157	if (ciphertext.constructor === Buffer)	70✔
158	ciphertext = ciphertext.toString("hex");	40✔
159
160	return keccak(	70✔
161	hex2utf16le(derivedKey.slice(32, 64) + ciphertext)
162	);
163	}
164	},
165
166	/**
167	* Derive secret key from password with key dervation function.
168	* @param {string\|buffer} password User-supplied password.
169	* @param {string\|buffer} salt Randomly generated salt.
170	* @param {Object=} options Encryption parameters.
171	* @param {string=} options.kdf Key derivation function (default: pbkdf2).
172	* @param {string=} options.cipher Symmetric cipher (default: constants.cipher).
173	* @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).
174	* @param {function=} cb Callback function (optional).
175	* @return {buffer} Secret key derived from password.
176	*/
177	deriveKey: function (password, salt, options, cb) {
178	if (password && salt) {	80✔
179	options = options \|\| {};	80✔
180	options.kdfparams = options.kdfparams \|\| {};	80✔
181
182	// convert strings to buffers
183	if (password.constructor === String)	80✔
184	password = str2buf(password, "utf8");	80✔
185	if (salt.constructor === String)	80✔
186	salt = str2buf(salt);	40✔
187
188	// use scrypt as key derivation function
189	if (options.kdf === "scrypt") {	80✔
190
191	try {	40✔
192
193	if (isFunction(cb)) {	40✔
194
195	setTimeout(function () {	20✔
196	cb(new Buffer(	20✔
197	scrypt.to_hex(scrypt.crypto_scrypt(
198	password,
199	salt,
200	options.kdfparams.n \|\| this.constants.scrypt.n,
201	options.kdfparams.r \|\| this.constants.scrypt.r,
202	options.kdfparams.p \|\| this.constants.scrypt.p,
203	options.kdfparams.dklen \|\| this.constants.scrypt.dklen
204	)
205	), "hex"));
206	}.bind(this), 0);
207
208	} else {
209
210	return new Buffer(	20✔
211	scrypt.to_hex(scrypt.crypto_scrypt(
212	password,
213	salt,
214	options.kdfparams.n \|\| this.constants.scrypt.n,
215	options.kdfparams.r \|\| this.constants.scrypt.r,
216	options.kdfparams.p \|\| this.constants.scrypt.p,
217	options.kdfparams.dklen \|\| this.constants.scrypt.dklen
218	)
219	), "hex");
220
221	}
222
223	} catch (ex) {
224	if (isFunction(cb)) {	×
225	cb(ex);	×
226	} else {
227	return ex;	×
228	}
229	}
230
231	// use default key derivation function (PBKDF2)
232	} else {
233
234	var prf = options.kdfparams.prf \|\| this.constants.pbkdf2.prf;	40✔
235	if (prf === "hmac-sha256") prf = "sha256";	40✔
236
237	if (isFunction(cb)) {	40✔
238
239	crypto.pbkdf2(	20✔
240	password,
241	salt,
242	options.kdfparams.c \|\| this.constants.pbkdf2.c,
243	options.kdfparams.dklen \|\| this.constants.pbkdf2.dklen,
244	prf,
245	function (ex, derivedKey) {
246	if (ex) return ex;	20✔
247	cb(derivedKey);	20✔
248	}
249	);
250
251	} else {
252
253	try {	20✔
254	return crypto.pbkdf2Sync(	20✔
255	password,
256	salt,
257	options.kdfparams.c \|\| this.constants.pbkdf2.c,
258	options.kdfparams.dklen \|\| this.constants.pbkdf2.dklen,
259	prf
260	);
261
262	} catch (ex) {
263	return ex;	×
264	}
265	}
266	}
267	}
268	},
269
270	/**
271	* Generate random numbers for private key, initialization vector,
272	* and salt (for key derivation).
273	* @param {Object=} params Encryption options (defaults: constants).
274	* @param {string=} params.keyBytes Private key size in bytes.
275	* @param {string=} params.ivBytes Initialization vector size in bytes.
276	* @param {function=} cb Callback function (optional).
277	* @return {Object<string,buffer>} Private key, IV and salt.
278	*/
279	create: function (params, cb) {
280	params = params \|\| {};	3,000✔
281	var keyBytes = params.keyBytes \|\| this.constants.keyBytes;	3,000✔
282	var ivBytes = params.ivBytes \|\| this.constants.ivBytes;	3,000✔
283
284	// asynchronous key generation if callback is provided
285	if (isFunction(cb)) {	3,000✔
286
287	// generate private key
288	crypto.randomBytes(keyBytes, function (ex, privateKey) {	1,500✔
289	if (ex) {	1,500✔
290	cb(ex);	×
291	} else {
292
293	// generate random initialization vector
294	crypto.randomBytes(ivBytes, function (ex, iv) {	1,500✔
295	if (ex) {	1,500✔
296	cb(ex);	×
297	} else {
298
299	// generate random salt
300	crypto.randomBytes(keyBytes, function (ex, salt) {	1,500✔
301	if (ex) {	1,500✔
302	cb(ex);	×
303	} else {
304
305	cb({	1,500✔
306	privateKey: privateKey,
307	iv: iv,
308	salt: salt
309	});
310	}
311	});
312	}
313
314	}); // crypto.randomBytes
315	}
316
317	}); // crypto.randomBytes
318
319	// synchronous key generation
320	} else {
321
322	try {	1,500✔
323	return {	1,500✔
324	privateKey: crypto.randomBytes(keyBytes),
325	iv: crypto.randomBytes(ivBytes),
326	salt: crypto.randomBytes(keyBytes)
327	};
328
329	// couldn't generate key: not enough entropy?
330	} catch (ex) {
331	return ex;	×
332	}
333	}
334	},
335
336	/**
337	* Assemble key data object in secret-storage format.
338	* @param {buffer} derivedKey Password-derived secret key.
339	* @param {buffer} privateKey Private key.
340	* @param {buffer} salt Randomly generated salt.
341	* @param {buffer} iv Initialization vector.
342	* @param {Object=} options Encryption parameters.
343	* @param {string=} options.kdf Key derivation function (default: pbkdf2).
344	* @param {string=} options.cipher Symmetric cipher (default: constants.cipher).
345	* @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).
346	* @return {Object}
347	*/
348	marshal: function(derivedKey, privateKey, salt, iv, options) {
349	var ciphertext, keyObject;	20✔
350	options = options \|\| {};	20✔
351	options.kdfparams = options.kdfparams \|\| {};	20✔
352
353	// encrypt using first 16 bytes of derived key
354	ciphertext = new Buffer(this.encrypt(	20✔
355	privateKey,
356	derivedKey.slice(0, 16),
357	iv
358	), "base64").toString("hex");
359
360	keyObject = {	20✔
361	address: this.privateKeyToAddress(privateKey).slice(2),
362	crypto: {
363	cipher: options.cipher \|\| this.constants.cipher,
364	ciphertext: ciphertext,
365	cipherparams: { iv: iv.toString("hex") },
366	mac: this.getMAC(derivedKey, ciphertext)
367	},
368	id: uuid.v4(), // random 128-bit UUID
369	version: 3
370	};
371
372	if (options.kdf === "scrypt") {	20✔
373	keyObject.crypto.kdf = "scrypt";	10✔
374	keyObject.crypto.kdfparams = {	10✔
375	dklen: options.kdfparams.dklen \|\| this.constants.scrypt.dklen,
376	n: options.kdfparams.n \|\| this.constants.scrypt.n,
377	r: options.kdfparams.r \|\| this.constants.scrypt.r,
378	p: options.kdfparams.p \|\| this.constants.scrypt.p,
379	salt: salt.toString("hex")
380	};
381
382	} else {
383	keyObject.crypto.kdf = "pbkdf2";	10✔
384	keyObject.crypto.kdfparams = {	10✔
385	c: options.kdfparams.c \|\| this.constants.pbkdf2.c,
386	dklen: options.kdfparams.dklen \|\| this.constants.pbkdf2.dklen,
387	prf: options.kdfparams.prf \|\| this.constants.pbkdf2.prf,
388	salt: salt.toString("hex")
389	};
390	}
391
392	return keyObject;	20✔
393	},
394
395	/**
396	* Export private key to keystore secret-storage format.
397	* @param {string\|buffer} password User-supplied password.
398	* @param {string\|buffer} privateKey Private key.
399	* @param {string\|buffer} salt Randomly generated salt.
400	* @param {string\|buffer} iv Initialization vector.
401	* @param {Object=} options Encryption parameters.
402	* @param {string=} options.kdf Key derivation function (default: pbkdf2).
403	* @param {string=} options.cipher Symmetric cipher (default: constants.cipher).
404	* @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).
405	* @param {function=} cb Callback function (optional).
406	* @return {Object}
407	*/
408	dump: function (password, privateKey, salt, iv, options, cb) {
409	options = options \|\| {};	20✔
410	if (iv.constructor === String) iv = str2buf(iv);	20✔
411	if (privateKey.constructor === String) privateKey = str2buf(privateKey);	20✔
412
413	// asynchronous if callback provided
414	if (isFunction(cb)) {	20✔
415
416	this.deriveKey(	10✔
417	password,
418	salt,
419	options,
420	function (derivedKey) {
421	cb(this.marshal(	10✔
422	derivedKey,
423	privateKey,
424	salt,
425	iv,
426	options
427	));
428	}.bind(this)
429	);
430
431	// synchronous if no callback
432	} else {
433
434	return this.marshal(	10✔
435	this.deriveKey(password, salt, options),
436	privateKey,
437	salt,
438	iv,
439	options
440	);
441	}
442	},
443
444	/**
445	* Recover plaintext private key from secret-storage key object.
446	* @param {Object} keyObject Keystore object.
447	* @param {function=} cb Callback function (optional).
448	* @return {buffer} Plaintext private key.
449	*/
450	recover: function (password, keyObject, cb) {
451	var self = this;	40✔
452	var keyObjectCrypto = keyObject.Crypto \|\| keyObject.crypto;	40✔
453
454	function verifyAndDecrypt(derivedKey, salt, iv, ciphertext) {	5✔
455
456	// verify that message authentication codes match
457	var mac = self.getMAC(derivedKey, ciphertext);	40✔
458	if (mac === keyObjectCrypto.mac) {	40✔
459
460	return new Buffer(self.decrypt(	40✔
461	ciphertext,
462	derivedKey.slice(0, 16),
463	iv
464	), "hex");
465
466	} else {
467	throw new Error("message authentication code mismatch");	×
468	}
469	}
470
471	var iv = keyObjectCrypto.cipherparams.iv;	40✔
472	var salt = keyObjectCrypto.kdfparams.salt;	40✔
473	var ciphertext = keyObjectCrypto.ciphertext;	40✔
474
475	if (iv && iv.constructor === String) iv = str2buf(iv);	40✔
476	if (salt && salt.constructor === String) salt = str2buf(salt);	40✔
477	if (ciphertext && ciphertext.constructor === String)	40✔
478	ciphertext = str2buf(ciphertext);	40✔
479
480	if (keyObjectCrypto.kdf === "scrypt") {	40✔
481	this.constants.scrypt = {	20✔
482	n: keyObjectCrypto.kdfparams.n,
483	r: keyObjectCrypto.kdfparams.r,
484	p: keyObjectCrypto.kdfparams.p,
485	dklen: keyObjectCrypto.kdfparams.dklen
486	};
487	} else {
488	if (keyObjectCrypto.kdfparams.prf !== "hmac-sha256") {	20✔
489	throw new Error("PBKDF2 only supported with HMAC-SHA256");	×
490	}
491	this.constants.pbkdf2.c = keyObjectCrypto.kdfparams.c;	20✔
492	this.constants.pbkdf2.dklen = keyObjectCrypto.kdfparams.dklen;	20✔
493	}
494
495	// derive secret key from password
496	if (isFunction(cb)) {	40✔
497	this.deriveKey(password, salt, keyObjectCrypto, function (derivedKey) {	20✔
498	cb(verifyAndDecrypt(derivedKey, salt, iv, ciphertext));	20✔
499	});
500	} else {
501	return verifyAndDecrypt(	20✔
502	this.deriveKey(password, salt, keyObjectCrypto),
503	salt,
504	iv,
505	ciphertext
506	);
507	}
508	},
509
510	/**
511	* Export formatted JSON to keystore file.
512	* @param {Object} keyObject Keystore object.
513	* @param {string=} keystore Path to keystore folder (default: "keystore").
514	* @param {function=} cb Callback function (optional).
515	* @return {string} JSON filename (Node.js) or JSON string (browser).
516	*/
517	exportToFile: function (keyObject, keystore, cb) {
518	var self = this;	20✔
519	var outfile, outpath, json;	20✔
520
521	function instructions(outpath) {	5✔
522	if (!self.constants.quiet) {	10✔
523	console.log(	×
524	"Saved to file:\n" + outpath + "\n"+
525	"To use with geth, copy this file to your Ethereum "+
526	"keystore folder (usually ~/.ethereum/keystore)."
527	);
528	}
529	}
530
531	keystore = keystore \|\| "keystore";	20✔
532	outfile = "UTC--" + new Date().toISOString() + "--" + keyObject.address;	20✔
533	outpath = path.join(keystore, outfile);	20✔
534	json = JSON.stringify(keyObject);	20✔
535
536	if (this.browser) {	20✔
537	if (!isFunction(cb)) return json;	10✔
538	return cb(json);	5✔
539	}
540	if (!isFunction(cb)) {	10✔
541	fs.writeFileSync(outpath, json);	5✔
542	instructions(outpath);	5✔
543	return outpath;	5✔
544	}
545	return fs.writeFile(outpath, json, function (ex) {	5✔
546	if (ex) throw ex;	5✔
547	instructions(outpath);	5✔
548	cb(outpath);	5✔
549	});
550	},
551
552	/**
553	* Import key data object from keystore JSON file.
554	* (Note: Node.js only!)
555	* @param {string} address Ethereum address to import.
556	* @param {string=} datadir Ethereum data directory (default: ~/.ethereum).
557	* @param {function=} cb Callback function (optional).
558	* @return {Object} Keystore data file's contents.
559	*/
560	importFromFile: function (address, datadir, cb) {
561	address = address.replace('0x', '');	80✔
562
563	function findKeyfile(keystore, address, files) {	5✔
564	var filepath = null;	80✔
565	for (var i = 0, len = files.length; i < len; ++i) {	80✔
566	if (files[i].indexOf(address) > -1) {	320✔
567	filepath = path.join(keystore, files[i]);	80✔
568	if (fs.lstatSync(filepath).isDirectory()) {	80✔
569	filepath = path.join(filepath, files[i]);	30✔
570	}
571	break;	80✔
572	}
573	}
574	return filepath;	80✔
575	}
576
577	if (this.browser) {	80✔
578	throw new Error("method only available in Node.js");	×
579	}
580	datadir = datadir \|\| path.join(process.env.HOME, ".ethereum");	80✔
581	var keystore = path.join(datadir, "keystore");	80✔
582	if (!isFunction(cb)) {	80✔
583	var filepath = findKeyfile(keystore, address, fs.readdirSync(keystore));	40✔
584	if (filepath) {	40✔
585	return JSON.parse(fs.readFileSync(filepath));	40✔
586	} else {
587	throw new Error(	×
588	"could not find key file for address " + address
589	);
590	}
591	}
592	fs.readdir(keystore, function (ex, files) {	40✔
593	if (ex) return cb(ex);	40✔
594	var filepath = findKeyfile(keystore, address, files);	40✔
595	if (filepath) return cb(JSON.parse(fs.readFileSync(filepath)));	40✔
596	return new Error(	×
597	"could not find key file for address " + address
598	);
599	});
600	}
601
602	};

ethereumjs / keythereum / 62

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous