pbca26
8 years ago
29 changed files with 7199 additions and 428 deletions
@ -0,0 +1,164 @@ |
|||
import { |
|||
triggerToaster, |
|||
getNewKMDAddresses |
|||
} from '../actionCreators'; |
|||
import { |
|||
logGuiHttp, |
|||
guiLogState |
|||
} from './log'; |
|||
import Config from '../../config'; |
|||
|
|||
function getNewAddress(coin) { // TODO: remove(?)
|
|||
return new Promise((resolve, reject) => { |
|||
const payload = { |
|||
mode: null, |
|||
chain: coin, |
|||
cmd: 'getnewaddress' |
|||
}; |
|||
|
|||
const _fetchConfig = { |
|||
method: 'POST', |
|||
headers: { |
|||
'Content-Type': 'application/json', |
|||
}, |
|||
body: JSON.stringify({ 'payload': payload }), |
|||
}; |
|||
|
|||
fetch( |
|||
`http://127.0.0.1:${Config.agamaPort}/shepherd/cli`, |
|||
_fetchConfig |
|||
) |
|||
.catch(function(error) { |
|||
console.log(error); |
|||
dispatch( |
|||
triggerToaster( |
|||
'genJumblrAddress + getKMDAddressesNative', |
|||
'Error', |
|||
'error' |
|||
) |
|||
); |
|||
}) |
|||
.then(response => response.json()) |
|||
.then(json => { |
|||
resolve(json.result ? json.result : json); |
|||
}) |
|||
}); |
|||
} |
|||
|
|||
export function setJumblrAddress(coin, type, address) { |
|||
return new Promise((resolve, reject) => { |
|||
const payload = { |
|||
mode: null, |
|||
chain: coin, |
|||
cmd: type === 'deposit' ? 'jumblr_deposit' : 'jumblr_secret', |
|||
params: [address], |
|||
}; |
|||
|
|||
const _fetchConfig = { |
|||
method: 'POST', |
|||
headers: { |
|||
'Content-Type': 'application/json', |
|||
}, |
|||
body: JSON.stringify({ 'payload': payload }), |
|||
}; |
|||
|
|||
fetch( |
|||
`http://127.0.0.1:${Config.agamaPort}/shepherd/cli`, |
|||
_fetchConfig |
|||
) |
|||
.catch(function(error) { |
|||
console.log(error); |
|||
dispatch( |
|||
triggerToaster( |
|||
'setJumblrAddress', |
|||
'Error', |
|||
'error' |
|||
) |
|||
); |
|||
}) |
|||
.then(response => response.json()) |
|||
.then(json => { |
|||
resolve(json); |
|||
}); |
|||
}); |
|||
} |
|||
|
|||
function dumpPrivkey(coin, key) { |
|||
return new Promise((resolve, reject) => { |
|||
const payload = { |
|||
mode: null, |
|||
chain: coin, |
|||
cmd: 'dumpprivkey', |
|||
params: [key], |
|||
}; |
|||
|
|||
const _fetchConfig = { |
|||
method: 'POST', |
|||
headers: { |
|||
'Content-Type': 'application/json', |
|||
}, |
|||
body: JSON.stringify({ 'payload': payload }), |
|||
}; |
|||
|
|||
fetch( |
|||
`http://127.0.0.1:${Config.agamaPort}/shepherd/cli`, |
|||
_fetchConfig |
|||
) |
|||
.catch(function(error) { |
|||
console.log(error); |
|||
dispatch( |
|||
triggerToaster( |
|||
'dumpPrivkey ', |
|||
'Error', |
|||
'error' |
|||
) |
|||
); |
|||
}) |
|||
.then(response => response.json()) |
|||
.then(json => { |
|||
resolve(json.result ? json.result : json); |
|||
}) |
|||
}); |
|||
} |
|||
|
|||
export function importPrivkey(coin, key) { |
|||
return new Promise((resolve, reject) => { |
|||
const payload = { |
|||
mode: null, |
|||
chain: coin, |
|||
cmd: 'importprivkey', |
|||
params: [ |
|||
key, |
|||
'', |
|||
false |
|||
], |
|||
}; |
|||
|
|||
const _fetchConfig = { |
|||
method: 'POST', |
|||
headers: { |
|||
'Content-Type': 'application/json', |
|||
}, |
|||
body: JSON.stringify({ 'payload': payload }), |
|||
}; |
|||
|
|||
fetch( |
|||
`http://127.0.0.1:${Config.agamaPort}/shepherd/cli`, |
|||
_fetchConfig |
|||
) |
|||
.catch(function(error) { |
|||
console.log(error); |
|||
dispatch( |
|||
triggerToaster( |
|||
'importPrivkey ', |
|||
'Error', |
|||
'error' |
|||
) |
|||
); |
|||
}) |
|||
.then(response => response.json()) |
|||
.then(json => { |
|||
resolve(json.result ? json.result : json); |
|||
}) |
|||
}); |
|||
} |
|||
@ -0,0 +1,57 @@ |
|||
// Array.prototype.map function is in the public domain.
|
|||
// Production steps of ECMA-262, Edition 5, 15.4.4.19
|
|||
// Reference: http://es5.github.com/#x15.4.4.19
|
|||
if (!Array.prototype.map) { |
|||
Array.prototype.map = function (callback, thisArg) { |
|||
var T, A, k; |
|||
if (this == null) { |
|||
throw new TypeError(" this is null or not defined"); |
|||
} |
|||
// 1. Let O be the result of calling ToObject passing the |this| value as the argument.
|
|||
var O = Object(this); |
|||
// 2. Let lenValue be the result of calling the Get internal method of O with the argument "length".
|
|||
// 3. Let len be ToUint32(lenValue).
|
|||
var len = O.length >>> 0; |
|||
// 4. If IsCallable(callback) is false, throw a TypeError exception.
|
|||
// See: http://es5.github.com/#x9.11
|
|||
if ({}.toString.call(callback) != "[object Function]") { |
|||
throw new TypeError(callback + " is not a function"); |
|||
} |
|||
// 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
|
|||
if (thisArg) { |
|||
T = thisArg; |
|||
} |
|||
// 6. Let A be a new array created as if by the expression new Array(len) where Array is
|
|||
// the standard built-in constructor with that name and len is the value of len.
|
|||
A = new Array(len); |
|||
// 7. Let k be 0
|
|||
k = 0; |
|||
// 8. Repeat, while k < len
|
|||
while (k < len) { |
|||
var kValue, mappedValue; |
|||
// a. Let Pk be ToString(k).
|
|||
// This is implicit for LHS operands of the in operator
|
|||
// b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.
|
|||
// This step can be combined with c
|
|||
// c. If kPresent is true, then
|
|||
if (k in O) { |
|||
// i. Let kValue be the result of calling the Get internal method of O with argument Pk.
|
|||
kValue = O[k]; |
|||
// ii. Let mappedValue be the result of calling the Call internal method of callback
|
|||
// with T as the this value and argument list containing kValue, k, and O.
|
|||
mappedValue = callback.call(T, kValue, k, O); |
|||
// iii. Call the DefineOwnProperty internal method of A with arguments
|
|||
// Pk, Property Descriptor {Value: mappedValue, Writable: true, Enumerable: true, Configurable: true},
|
|||
// and false.
|
|||
// In browsers that support Object.defineProperty, use the following:
|
|||
// Object.defineProperty(A, Pk, { value: mappedValue, writable: true, enumerable: true, configurable: true });
|
|||
// For best browser support, use the following:
|
|||
A[k] = mappedValue; |
|||
} |
|||
// d. Increase k by 1.
|
|||
k++; |
|||
} |
|||
// 9. return A
|
|||
return A; |
|||
}; |
|||
} |
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,295 @@ |
|||
/* |
|||
* Copyright (c) 2010-2011 Intalio Pte, All Rights Reserved |
|||
* |
|||
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|||
* of this software and associated documentation files (the "Software"), to deal |
|||
* in the Software without restriction, including without limitation the rights |
|||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|||
* copies of the Software, and to permit persons to whom the Software is |
|||
* furnished to do so, subject to the following conditions: |
|||
* |
|||
* The above copyright notice and this permission notice shall be included in |
|||
* all copies or substantial portions of the Software. |
|||
* |
|||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|||
* THE SOFTWARE. |
|||
*/ |
|||
// https://github.com/cheongwy/node-scrypt-js
|
|||
(function () { |
|||
|
|||
var MAX_VALUE = 2147483647; |
|||
var workerUrl = null; |
|||
|
|||
//function scrypt(byte[] passwd, byte[] salt, int N, int r, int p, int dkLen)
|
|||
/* |
|||
* N = Cpu cost |
|||
* r = Memory cost |
|||
* p = parallelization cost |
|||
* |
|||
*/ |
|||
window.Crypto_scrypt = function (passwd, salt, N, r, p, dkLen, callback) { |
|||
if (N == 0 || (N & (N - 1)) != 0) throw Error("N must be > 0 and a power of 2"); |
|||
|
|||
if (N > MAX_VALUE / 128 / r) throw Error("Parameter N is too large"); |
|||
if (r > MAX_VALUE / 128 / p) throw Error("Parameter r is too large"); |
|||
|
|||
var PBKDF2_opts = { iterations: 1, hasher: Crypto.SHA256, asBytes: true }; |
|||
|
|||
var B = Crypto.PBKDF2(passwd, salt, p * 128 * r, PBKDF2_opts); |
|||
|
|||
try { |
|||
var i = 0; |
|||
var worksDone = 0; |
|||
var makeWorker = function () { |
|||
if (!workerUrl) { |
|||
var code = '(' + scryptCore.toString() + ')()'; |
|||
var blob; |
|||
try { |
|||
blob = new Blob([code], { type: "text/javascript" }); |
|||
} catch (e) { |
|||
window.BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder; |
|||
blob = new BlobBuilder(); |
|||
blob.append(code); |
|||
blob = blob.getBlob("text/javascript"); |
|||
} |
|||
workerUrl = URL.createObjectURL(blob); |
|||
} |
|||
var worker = new Worker(workerUrl); |
|||
worker.onmessage = function (event) { |
|||
var Bi = event.data[0], Bslice = event.data[1]; |
|||
worksDone++; |
|||
|
|||
if (i < p) { |
|||
worker.postMessage([N, r, p, B, i++]); |
|||
} |
|||
|
|||
var length = Bslice.length, destPos = Bi * 128 * r, srcPos = 0; |
|||
while (length--) { |
|||
B[destPos++] = Bslice[srcPos++]; |
|||
} |
|||
|
|||
if (worksDone == p) { |
|||
callback(Crypto.PBKDF2(passwd, B, dkLen, PBKDF2_opts)); |
|||
} |
|||
}; |
|||
return worker; |
|||
}; |
|||
var workers = [makeWorker(), makeWorker()]; |
|||
workers[0].postMessage([N, r, p, B, i++]); |
|||
if (p > 1) { |
|||
workers[1].postMessage([N, r, p, B, i++]); |
|||
} |
|||
} catch (e) { |
|||
window.setTimeout(function () { |
|||
scryptCore(); |
|||
callback(Crypto.PBKDF2(passwd, B, dkLen, PBKDF2_opts)); |
|||
}, 0); |
|||
} |
|||
|
|||
// using this function to enclose everything needed to create a worker (but also invokable directly for synchronous use)
|
|||
function scryptCore() { |
|||
var XY = [], V = []; |
|||
|
|||
if (typeof B === 'undefined') { |
|||
onmessage = function (event) { |
|||
var data = event.data; |
|||
var N = data[0], r = data[1], p = data[2], B = data[3], i = data[4]; |
|||
|
|||
var Bslice = []; |
|||
arraycopy32(B, i * 128 * r, Bslice, 0, 128 * r); |
|||
smix(Bslice, 0, r, N, V, XY); |
|||
|
|||
postMessage([i, Bslice]); |
|||
}; |
|||
} else { |
|||
for (var i = 0; i < p; i++) { |
|||
smix(B, i * 128 * r, r, N, V, XY); |
|||
} |
|||
} |
|||
|
|||
function smix(B, Bi, r, N, V, XY) { |
|||
var Xi = 0; |
|||
var Yi = 128 * r; |
|||
var i; |
|||
|
|||
arraycopy32(B, Bi, XY, Xi, Yi); |
|||
|
|||
for (i = 0; i < N; i++) { |
|||
arraycopy32(XY, Xi, V, i * Yi, Yi); |
|||
blockmix_salsa8(XY, Xi, Yi, r); |
|||
} |
|||
|
|||
for (i = 0; i < N; i++) { |
|||
var j = integerify(XY, Xi, r) & (N - 1); |
|||
blockxor(V, j * Yi, XY, Xi, Yi); |
|||
blockmix_salsa8(XY, Xi, Yi, r); |
|||
} |
|||
|
|||
arraycopy32(XY, Xi, B, Bi, Yi); |
|||
} |
|||
|
|||
function blockmix_salsa8(BY, Bi, Yi, r) { |
|||
var X = []; |
|||
var i; |
|||
|
|||
arraycopy32(BY, Bi + (2 * r - 1) * 64, X, 0, 64); |
|||
|
|||
for (i = 0; i < 2 * r; i++) { |
|||
blockxor(BY, i * 64, X, 0, 64); |
|||
salsa20_8(X); |
|||
arraycopy32(X, 0, BY, Yi + (i * 64), 64); |
|||
} |
|||
|
|||
for (i = 0; i < r; i++) { |
|||
arraycopy32(BY, Yi + (i * 2) * 64, BY, Bi + (i * 64), 64); |
|||
} |
|||
|
|||
for (i = 0; i < r; i++) { |
|||
arraycopy32(BY, Yi + (i * 2 + 1) * 64, BY, Bi + (i + r) * 64, 64); |
|||
} |
|||
} |
|||
|
|||
function R(a, b) { |
|||
return (a << b) | (a >>> (32 - b)); |
|||
} |
|||
|
|||
function salsa20_8(B) { |
|||
var B32 = new Array(32); |
|||
var x = new Array(32); |
|||
var i; |
|||
|
|||
for (i = 0; i < 16; i++) { |
|||
B32[i] = (B[i * 4 + 0] & 0xff) << 0; |
|||
B32[i] |= (B[i * 4 + 1] & 0xff) << 8; |
|||
B32[i] |= (B[i * 4 + 2] & 0xff) << 16; |
|||
B32[i] |= (B[i * 4 + 3] & 0xff) << 24; |
|||
} |
|||
|
|||
arraycopy(B32, 0, x, 0, 16); |
|||
|
|||
for (i = 8; i > 0; i -= 2) { |
|||
x[4] ^= R(x[0] + x[12], 7); x[8] ^= R(x[4] + x[0], 9); |
|||
x[12] ^= R(x[8] + x[4], 13); x[0] ^= R(x[12] + x[8], 18); |
|||
x[9] ^= R(x[5] + x[1], 7); x[13] ^= R(x[9] + x[5], 9); |
|||
x[1] ^= R(x[13] + x[9], 13); x[5] ^= R(x[1] + x[13], 18); |
|||
x[14] ^= R(x[10] + x[6], 7); x[2] ^= R(x[14] + x[10], 9); |
|||
x[6] ^= R(x[2] + x[14], 13); x[10] ^= R(x[6] + x[2], 18); |
|||
x[3] ^= R(x[15] + x[11], 7); x[7] ^= R(x[3] + x[15], 9); |
|||
x[11] ^= R(x[7] + x[3], 13); x[15] ^= R(x[11] + x[7], 18); |
|||
x[1] ^= R(x[0] + x[3], 7); x[2] ^= R(x[1] + x[0], 9); |
|||
x[3] ^= R(x[2] + x[1], 13); x[0] ^= R(x[3] + x[2], 18); |
|||
x[6] ^= R(x[5] + x[4], 7); x[7] ^= R(x[6] + x[5], 9); |
|||
x[4] ^= R(x[7] + x[6], 13); x[5] ^= R(x[4] + x[7], 18); |
|||
x[11] ^= R(x[10] + x[9], 7); x[8] ^= R(x[11] + x[10], 9); |
|||
x[9] ^= R(x[8] + x[11], 13); x[10] ^= R(x[9] + x[8], 18); |
|||
x[12] ^= R(x[15] + x[14], 7); x[13] ^= R(x[12] + x[15], 9); |
|||
x[14] ^= R(x[13] + x[12], 13); x[15] ^= R(x[14] + x[13], 18); |
|||
} |
|||
|
|||
for (i = 0; i < 16; ++i) B32[i] = x[i] + B32[i]; |
|||
|
|||
for (i = 0; i < 16; i++) { |
|||
var bi = i * 4; |
|||
B[bi + 0] = (B32[i] >> 0 & 0xff); |
|||
B[bi + 1] = (B32[i] >> 8 & 0xff); |
|||
B[bi + 2] = (B32[i] >> 16 & 0xff); |
|||
B[bi + 3] = (B32[i] >> 24 & 0xff); |
|||
} |
|||
} |
|||
|
|||
function blockxor(S, Si, D, Di, len) { |
|||
var i = len >> 6; |
|||
while (i--) { |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
|
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
|
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
|
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
|
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
|
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
|
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
|
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++]; |
|||
} |
|||
} |
|||
|
|||
function integerify(B, bi, r) { |
|||
var n; |
|||
|
|||
bi += (2 * r - 1) * 64; |
|||
|
|||
n = (B[bi + 0] & 0xff) << 0; |
|||
n |= (B[bi + 1] & 0xff) << 8; |
|||
n |= (B[bi + 2] & 0xff) << 16; |
|||
n |= (B[bi + 3] & 0xff) << 24; |
|||
|
|||
return n; |
|||
} |
|||
|
|||
function arraycopy(src, srcPos, dest, destPos, length) { |
|||
while (length--) { |
|||
dest[destPos++] = src[srcPos++]; |
|||
} |
|||
} |
|||
|
|||
function arraycopy32(src, srcPos, dest, destPos, length) { |
|||
var i = length >> 5; |
|||
while (i--) { |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
|
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
|
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
|
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++]; |
|||
} |
|||
} |
|||
} // scryptCore
|
|||
}; // window.Crypto_scrypt
|
|||
})(); |
|||
@ -0,0 +1,407 @@ |
|||
/*! |
|||
* Crypto-JS v2.5.4 AES.js |
|||
* http://code.google.com/p/crypto-js/
|
|||
* Copyright (c) 2009-2013, Jeff Mott. All rights reserved. |
|||
* http://code.google.com/p/crypto-js/wiki/License
|
|||
*/ |
|||
(function () { |
|||
|
|||
// Shortcuts
|
|||
var C = Crypto, |
|||
util = C.util, |
|||
charenc = C.charenc, |
|||
UTF8 = charenc.UTF8; |
|||
|
|||
// Precomputed SBOX
|
|||
var SBOX = [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, |
|||
0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, |
|||
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, |
|||
0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, |
|||
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, |
|||
0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, |
|||
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, |
|||
0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, |
|||
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, |
|||
0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, |
|||
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, |
|||
0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, |
|||
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, |
|||
0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, |
|||
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, |
|||
0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, |
|||
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, |
|||
0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, |
|||
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, |
|||
0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, |
|||
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, |
|||
0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, |
|||
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, |
|||
0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, |
|||
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, |
|||
0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, |
|||
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, |
|||
0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, |
|||
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, |
|||
0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, |
|||
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, |
|||
0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16]; |
|||
|
|||
// Compute inverse SBOX lookup table
|
|||
for (var INVSBOX = [], i = 0; i < 256; i++) INVSBOX[SBOX[i]] = i; |
|||
|
|||
// Compute multiplication in GF(2^8) lookup tables
|
|||
var MULT2 = [], |
|||
MULT3 = [], |
|||
MULT9 = [], |
|||
MULTB = [], |
|||
MULTD = [], |
|||
MULTE = []; |
|||
|
|||
function xtime(a, b) { |
|||
for (var result = 0, i = 0; i < 8; i++) { |
|||
if (b & 1) result ^= a; |
|||
var hiBitSet = a & 0x80; |
|||
a = (a << 1) & 0xFF; |
|||
if (hiBitSet) a ^= 0x1b; |
|||
b >>>= 1; |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
for (var i = 0; i < 256; i++) { |
|||
MULT2[i] = xtime(i, 2); |
|||
MULT3[i] = xtime(i, 3); |
|||
MULT9[i] = xtime(i, 9); |
|||
MULTB[i] = xtime(i, 0xB); |
|||
MULTD[i] = xtime(i, 0xD); |
|||
MULTE[i] = xtime(i, 0xE); |
|||
} |
|||
|
|||
// Precomputed RCon lookup
|
|||
var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]; |
|||
|
|||
// Inner state
|
|||
var state = [[], [], [], []], |
|||
keylength, |
|||
nrounds, |
|||
keyschedule; |
|||
|
|||
var AES = C.AES = { |
|||
|
|||
/** |
|||
* Public API |
|||
*/ |
|||
|
|||
encrypt: function (message, password, options) { |
|||
|
|||
options = options || {}; |
|||
|
|||
// Determine mode
|
|||
var mode = options.mode || new C.mode.OFB; |
|||
|
|||
// Allow mode to override options
|
|||
if (mode.fixOptions) mode.fixOptions(options); |
|||
|
|||
var |
|||
|
|||
// Convert to bytes if message is a string
|
|||
m = ( |
|||
message.constructor == String ? |
|||
UTF8.stringToBytes(message) : |
|||
message |
|||
), |
|||
|
|||
// Generate random IV
|
|||
iv = options.iv || util.randomBytes(AES._blocksize * 4), |
|||
|
|||
// Generate key
|
|||
k = ( |
|||
password.constructor == String ? |
|||
// Derive key from pass-phrase
|
|||
C.PBKDF2(password, iv, 32, { asBytes: true }) : |
|||
// else, assume byte array representing cryptographic key
|
|||
password |
|||
); |
|||
|
|||
// Encrypt
|
|||
AES._init(k); |
|||
mode.encrypt(AES, m, iv); |
|||
|
|||
// Return ciphertext
|
|||
m = options.iv ? m : iv.concat(m); |
|||
return (options && options.asBytes) ? m : util.bytesToBase64(m); |
|||
|
|||
}, |
|||
|
|||
decrypt: function (ciphertext, password, options) { |
|||
|
|||
options = options || {}; |
|||
|
|||
// Determine mode
|
|||
var mode = options.mode || new C.mode.OFB; |
|||
|
|||
// Allow mode to override options
|
|||
if (mode.fixOptions) mode.fixOptions(options); |
|||
|
|||
var |
|||
|
|||
// Convert to bytes if ciphertext is a string
|
|||
c = ( |
|||
ciphertext.constructor == String ? |
|||
util.base64ToBytes(ciphertext) : |
|||
ciphertext |
|||
), |
|||
|
|||
// Separate IV and message
|
|||
iv = options.iv || c.splice(0, AES._blocksize * 4), |
|||
|
|||
// Generate key
|
|||
k = ( |
|||
password.constructor == String ? |
|||
// Derive key from pass-phrase
|
|||
C.PBKDF2(password, iv, 32, { asBytes: true }) : |
|||
// else, assume byte array representing cryptographic key
|
|||
password |
|||
); |
|||
|
|||
// Decrypt
|
|||
AES._init(k); |
|||
mode.decrypt(AES, c, iv); |
|||
|
|||
// Return plaintext
|
|||
return (options && options.asBytes) ? c : UTF8.bytesToString(c); |
|||
|
|||
}, |
|||
|
|||
|
|||
/** |
|||
* Package private methods and properties |
|||
*/ |
|||
|
|||
_blocksize: 4, |
|||
|
|||
_encryptblock: function (m, offset) { |
|||
|
|||
// Set input
|
|||
for (var row = 0; row < AES._blocksize; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] = m[offset + col * 4 + row]; |
|||
} |
|||
|
|||
// Add round key
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] ^= keyschedule[col][row]; |
|||
} |
|||
|
|||
for (var round = 1; round < nrounds; round++) { |
|||
|
|||
// Sub bytes
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] = SBOX[state[row][col]]; |
|||
} |
|||
|
|||
// Shift rows
|
|||
state[1].push(state[1].shift()); |
|||
state[2].push(state[2].shift()); |
|||
state[2].push(state[2].shift()); |
|||
state[3].unshift(state[3].pop()); |
|||
|
|||
// Mix columns
|
|||
for (var col = 0; col < 4; col++) { |
|||
|
|||
var s0 = state[0][col], |
|||
s1 = state[1][col], |
|||
s2 = state[2][col], |
|||
s3 = state[3][col]; |
|||
|
|||
state[0][col] = MULT2[s0] ^ MULT3[s1] ^ s2 ^ s3; |
|||
state[1][col] = s0 ^ MULT2[s1] ^ MULT3[s2] ^ s3; |
|||
state[2][col] = s0 ^ s1 ^ MULT2[s2] ^ MULT3[s3]; |
|||
state[3][col] = MULT3[s0] ^ s1 ^ s2 ^ MULT2[s3]; |
|||
|
|||
} |
|||
|
|||
// Add round key
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] ^= keyschedule[round * 4 + col][row]; |
|||
} |
|||
|
|||
} |
|||
|
|||
// Sub bytes
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] = SBOX[state[row][col]]; |
|||
} |
|||
|
|||
// Shift rows
|
|||
state[1].push(state[1].shift()); |
|||
state[2].push(state[2].shift()); |
|||
state[2].push(state[2].shift()); |
|||
state[3].unshift(state[3].pop()); |
|||
|
|||
// Add round key
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] ^= keyschedule[nrounds * 4 + col][row]; |
|||
} |
|||
|
|||
// Set output
|
|||
for (var row = 0; row < AES._blocksize; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
m[offset + col * 4 + row] = state[row][col]; |
|||
} |
|||
|
|||
}, |
|||
|
|||
_decryptblock: function (c, offset) { |
|||
|
|||
// Set input
|
|||
for (var row = 0; row < AES._blocksize; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] = c[offset + col * 4 + row]; |
|||
} |
|||
|
|||
// Add round key
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] ^= keyschedule[nrounds * 4 + col][row]; |
|||
} |
|||
|
|||
for (var round = 1; round < nrounds; round++) { |
|||
|
|||
// Inv shift rows
|
|||
state[1].unshift(state[1].pop()); |
|||
state[2].push(state[2].shift()); |
|||
state[2].push(state[2].shift()); |
|||
state[3].push(state[3].shift()); |
|||
|
|||
// Inv sub bytes
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] = INVSBOX[state[row][col]]; |
|||
} |
|||
|
|||
// Add round key
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] ^= keyschedule[(nrounds - round) * 4 + col][row]; |
|||
} |
|||
|
|||
// Inv mix columns
|
|||
for (var col = 0; col < 4; col++) { |
|||
|
|||
var s0 = state[0][col], |
|||
s1 = state[1][col], |
|||
s2 = state[2][col], |
|||
s3 = state[3][col]; |
|||
|
|||
state[0][col] = MULTE[s0] ^ MULTB[s1] ^ MULTD[s2] ^ MULT9[s3]; |
|||
state[1][col] = MULT9[s0] ^ MULTE[s1] ^ MULTB[s2] ^ MULTD[s3]; |
|||
state[2][col] = MULTD[s0] ^ MULT9[s1] ^ MULTE[s2] ^ MULTB[s3]; |
|||
state[3][col] = MULTB[s0] ^ MULTD[s1] ^ MULT9[s2] ^ MULTE[s3]; |
|||
|
|||
} |
|||
|
|||
} |
|||
|
|||
// Inv shift rows
|
|||
state[1].unshift(state[1].pop()); |
|||
state[2].push(state[2].shift()); |
|||
state[2].push(state[2].shift()); |
|||
state[3].push(state[3].shift()); |
|||
|
|||
// Inv sub bytes
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] = INVSBOX[state[row][col]]; |
|||
} |
|||
|
|||
// Add round key
|
|||
for (var row = 0; row < 4; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
state[row][col] ^= keyschedule[col][row]; |
|||
} |
|||
|
|||
// Set output
|
|||
for (var row = 0; row < AES._blocksize; row++) { |
|||
for (var col = 0; col < 4; col++) |
|||
c[offset + col * 4 + row] = state[row][col]; |
|||
} |
|||
|
|||
}, |
|||
|
|||
|
|||
/** |
|||
* Private methods |
|||
*/ |
|||
|
|||
_init: function (k) { |
|||
keylength = k.length / 4; |
|||
nrounds = keylength + 6; |
|||
AES._keyexpansion(k); |
|||
}, |
|||
|
|||
// Generate a key schedule
|
|||
_keyexpansion: function (k) { |
|||
|
|||
keyschedule = []; |
|||
|
|||
for (var row = 0; row < keylength; row++) { |
|||
keyschedule[row] = [ |
|||
k[row * 4], |
|||
k[row * 4 + 1], |
|||
k[row * 4 + 2], |
|||
k[row * 4 + 3] |
|||
]; |
|||
} |
|||
|
|||
for (var row = keylength; row < AES._blocksize * (nrounds + 1); row++) { |
|||
|
|||
var temp = [ |
|||
keyschedule[row - 1][0], |
|||
keyschedule[row - 1][1], |
|||
keyschedule[row - 1][2], |
|||
keyschedule[row - 1][3] |
|||
]; |
|||
|
|||
if (row % keylength == 0) { |
|||
|
|||
// Rot word
|
|||
temp.push(temp.shift()); |
|||
|
|||
// Sub word
|
|||
temp[0] = SBOX[temp[0]]; |
|||
temp[1] = SBOX[temp[1]]; |
|||
temp[2] = SBOX[temp[2]]; |
|||
temp[3] = SBOX[temp[3]]; |
|||
|
|||
temp[0] ^= RCON[row / keylength]; |
|||
|
|||
} else if (keylength > 6 && row % keylength == 4) { |
|||
|
|||
// Sub word
|
|||
temp[0] = SBOX[temp[0]]; |
|||
temp[1] = SBOX[temp[1]]; |
|||
temp[2] = SBOX[temp[2]]; |
|||
temp[3] = SBOX[temp[3]]; |
|||
|
|||
} |
|||
|
|||
keyschedule[row] = [ |
|||
keyschedule[row - keylength][0] ^ temp[0], |
|||
keyschedule[row - keylength][1] ^ temp[1], |
|||
keyschedule[row - keylength][2] ^ temp[2], |
|||
keyschedule[row - keylength][3] ^ temp[3] |
|||
]; |
|||
|
|||
} |
|||
|
|||
} |
|||
|
|||
}; |
|||
|
|||
})(); |
|||
@ -0,0 +1,410 @@ |
|||
/*! |
|||
* Crypto-JS 2.5.4 BlockModes.js |
|||
* contribution from Simon Greatrix |
|||
*/ |
|||
|
|||
(function (C) { |
|||
|
|||
// Create pad namespace
|
|||
var C_pad = C.pad = {}; |
|||
|
|||
// Calculate the number of padding bytes required.
|
|||
function _requiredPadding(cipher, message) { |
|||
var blockSizeInBytes = cipher._blocksize * 4; |
|||
var reqd = blockSizeInBytes - message.length % blockSizeInBytes; |
|||
return reqd; |
|||
} |
|||
|
|||
// Remove padding when the final byte gives the number of padding bytes.
|
|||
var _unpadLength = function (cipher, message, alg, padding) { |
|||
var pad = message.pop(); |
|||
if (pad == 0) { |
|||
throw new Error("Invalid zero-length padding specified for " + alg |
|||
+ ". Wrong cipher specification or key used?"); |
|||
} |
|||
var maxPad = cipher._blocksize * 4; |
|||
if (pad > maxPad) { |
|||
throw new Error("Invalid padding length of " + pad |
|||
+ " specified for " + alg |
|||
+ ". Wrong cipher specification or key used?"); |
|||
} |
|||
for (var i = 1; i < pad; i++) { |
|||
var b = message.pop(); |
|||
if (padding != undefined && padding != b) { |
|||
throw new Error("Invalid padding byte of 0x" + b.toString(16) |
|||
+ " specified for " + alg |
|||
+ ". Wrong cipher specification or key used?"); |
|||
} |
|||
} |
|||
}; |
|||
|
|||
// No-operation padding, used for stream ciphers
|
|||
C_pad.NoPadding = { |
|||
pad: function (cipher, message) { }, |
|||
unpad: function (cipher, message) { } |
|||
}; |
|||
|
|||
// Zero Padding.
|
|||
//
|
|||
// If the message is not an exact number of blocks, the final block is
|
|||
// completed with 0x00 bytes. There is no unpadding.
|
|||
C_pad.ZeroPadding = { |
|||
pad: function (cipher, message) { |
|||
var blockSizeInBytes = cipher._blocksize * 4; |
|||
var reqd = message.length % blockSizeInBytes; |
|||
if (reqd != 0) { |
|||
for (reqd = blockSizeInBytes - reqd; reqd > 0; reqd--) { |
|||
message.push(0x00); |
|||
} |
|||
} |
|||
}, |
|||
|
|||
unpad: function (cipher, message) { |
|||
while (message[message.length - 1] == 0) { |
|||
message.pop(); |
|||
} |
|||
} |
|||
}; |
|||
|
|||
// ISO/IEC 7816-4 padding.
|
|||
//
|
|||
// Pads the plain text with an 0x80 byte followed by as many 0x00
|
|||
// bytes are required to complete the block.
|
|||
C_pad.iso7816 = { |
|||
pad: function (cipher, message) { |
|||
var reqd = _requiredPadding(cipher, message); |
|||
message.push(0x80); |
|||
for (; reqd > 1; reqd--) { |
|||
message.push(0x00); |
|||
} |
|||
}, |
|||
|
|||
unpad: function (cipher, message) { |
|||
var padLength; |
|||
for (padLength = cipher._blocksize * 4; padLength > 0; padLength--) { |
|||
var b = message.pop(); |
|||
if (b == 0x80) return; |
|||
if (b != 0x00) { |
|||
throw new Error("ISO-7816 padding byte must be 0, not 0x" + b.toString(16) + ". Wrong cipher specification or key used?"); |
|||
} |
|||
} |
|||
throw new Error("ISO-7816 padded beyond cipher block size. Wrong cipher specification or key used?"); |
|||
} |
|||
}; |
|||
|
|||
// ANSI X.923 padding
|
|||
//
|
|||
// The final block is padded with zeros except for the last byte of the
|
|||
// last block which contains the number of padding bytes.
|
|||
C_pad.ansix923 = { |
|||
pad: function (cipher, message) { |
|||
var reqd = _requiredPadding(cipher, message); |
|||
for (var i = 1; i < reqd; i++) { |
|||
message.push(0x00); |
|||
} |
|||
message.push(reqd); |
|||
}, |
|||
|
|||
unpad: function (cipher, message) { |
|||
_unpadLength(cipher, message, "ANSI X.923", 0); |
|||
} |
|||
}; |
|||
|
|||
// ISO 10126
|
|||
//
|
|||
// The final block is padded with random bytes except for the last
|
|||
// byte of the last block which contains the number of padding bytes.
|
|||
C_pad.iso10126 = { |
|||
pad: function (cipher, message) { |
|||
var reqd = _requiredPadding(cipher, message); |
|||
for (var i = 1; i < reqd; i++) { |
|||
message.push(Math.floor(Math.random() * 256)); |
|||
} |
|||
message.push(reqd); |
|||
}, |
|||
|
|||
unpad: function (cipher, message) { |
|||
_unpadLength(cipher, message, "ISO 10126", undefined); |
|||
} |
|||
}; |
|||
|
|||
// PKCS7 padding
|
|||
//
|
|||
// PKCS7 is described in RFC 5652. Padding is in whole bytes. The
|
|||
// value of each added byte is the number of bytes that are added,
|
|||
// i.e. N bytes, each of value N are added.
|
|||
C_pad.pkcs7 = { |
|||
pad: function (cipher, message) { |
|||
var reqd = _requiredPadding(cipher, message); |
|||
for (var i = 0; i < reqd; i++) { |
|||
message.push(reqd); |
|||
} |
|||
}, |
|||
|
|||
unpad: function (cipher, message) { |
|||
_unpadLength(cipher, message, "PKCS 7", message[message.length - 1]); |
|||
} |
|||
}; |
|||
|
|||
// Create mode namespace
|
|||
var C_mode = C.mode = {}; |
|||
|
|||
/** |
|||
* Mode base "class". |
|||
*/ |
|||
var Mode = C_mode.Mode = function (padding) { |
|||
if (padding) { |
|||
this._padding = padding; |
|||
} |
|||
}; |
|||
|
|||
Mode.prototype = { |
|||
encrypt: function (cipher, m, iv) { |
|||
this._padding.pad(cipher, m); |
|||
this._doEncrypt(cipher, m, iv); |
|||
}, |
|||
|
|||
decrypt: function (cipher, m, iv) { |
|||
this._doDecrypt(cipher, m, iv); |
|||
this._padding.unpad(cipher, m); |
|||
}, |
|||
|
|||
// Default padding
|
|||
_padding: C_pad.iso7816 |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* Electronic Code Book mode. |
|||
* |
|||
* ECB applies the cipher directly against each block of the input. |
|||
* |
|||
* ECB does not require an initialization vector. |
|||
*/ |
|||
var ECB = C_mode.ECB = function () { |
|||
// Call parent constructor
|
|||
Mode.apply(this, arguments); |
|||
}; |
|||
|
|||
// Inherit from Mode
|
|||
var ECB_prototype = ECB.prototype = new Mode; |
|||
|
|||
// Concrete steps for Mode template
|
|||
ECB_prototype._doEncrypt = function (cipher, m, iv) { |
|||
var blockSizeInBytes = cipher._blocksize * 4; |
|||
// Encrypt each block
|
|||
for (var offset = 0; offset < m.length; offset += blockSizeInBytes) { |
|||
cipher._encryptblock(m, offset); |
|||
} |
|||
}; |
|||
ECB_prototype._doDecrypt = function (cipher, c, iv) { |
|||
var blockSizeInBytes = cipher._blocksize * 4; |
|||
// Decrypt each block
|
|||
for (var offset = 0; offset < c.length; offset += blockSizeInBytes) { |
|||
cipher._decryptblock(c, offset); |
|||
} |
|||
}; |
|||
|
|||
// ECB never uses an IV
|
|||
ECB_prototype.fixOptions = function (options) { |
|||
options.iv = []; |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* Cipher block chaining |
|||
* |
|||
* The first block is XORed with the IV. Subsequent blocks are XOR with the |
|||
* previous cipher output. |
|||
*/ |
|||
var CBC = C_mode.CBC = function () { |
|||
// Call parent constructor
|
|||
Mode.apply(this, arguments); |
|||
}; |
|||
|
|||
// Inherit from Mode
|
|||
var CBC_prototype = CBC.prototype = new Mode; |
|||
|
|||
// Concrete steps for Mode template
|
|||
CBC_prototype._doEncrypt = function (cipher, m, iv) { |
|||
var blockSizeInBytes = cipher._blocksize * 4; |
|||
|
|||
// Encrypt each block
|
|||
for (var offset = 0; offset < m.length; offset += blockSizeInBytes) { |
|||
if (offset == 0) { |
|||
// XOR first block using IV
|
|||
for (var i = 0; i < blockSizeInBytes; i++) |
|||
m[i] ^= iv[i]; |
|||
} else { |
|||
// XOR this block using previous crypted block
|
|||
for (var i = 0; i < blockSizeInBytes; i++) |
|||
m[offset + i] ^= m[offset + i - blockSizeInBytes]; |
|||
} |
|||
// Encrypt block
|
|||
cipher._encryptblock(m, offset); |
|||
} |
|||
}; |
|||
CBC_prototype._doDecrypt = function (cipher, c, iv) { |
|||
var blockSizeInBytes = cipher._blocksize * 4; |
|||
|
|||
// At the start, the previously crypted block is the IV
|
|||
var prevCryptedBlock = iv; |
|||
|
|||
// Decrypt each block
|
|||
for (var offset = 0; offset < c.length; offset += blockSizeInBytes) { |
|||
// Save this crypted block
|
|||
var thisCryptedBlock = c.slice(offset, offset + blockSizeInBytes); |
|||
// Decrypt block
|
|||
cipher._decryptblock(c, offset); |
|||
// XOR decrypted block using previous crypted block
|
|||
for (var i = 0; i < blockSizeInBytes; i++) { |
|||
c[offset + i] ^= prevCryptedBlock[i]; |
|||
} |
|||
prevCryptedBlock = thisCryptedBlock; |
|||
} |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* Cipher feed back |
|||
* |
|||
* The cipher output is XORed with the plain text to produce the cipher output, |
|||
* which is then fed back into the cipher to produce a bit pattern to XOR the |
|||
* next block with. |
|||
* |
|||
* This is a stream cipher mode and does not require padding. |
|||
*/ |
|||
var CFB = C_mode.CFB = function () { |
|||
// Call parent constructor
|
|||
Mode.apply(this, arguments); |
|||
}; |
|||
|
|||
// Inherit from Mode
|
|||
var CFB_prototype = CFB.prototype = new Mode; |
|||
|
|||
// Override padding
|
|||
CFB_prototype._padding = C_pad.NoPadding; |
|||
|
|||
// Concrete steps for Mode template
|
|||
CFB_prototype._doEncrypt = function (cipher, m, iv) { |
|||
var blockSizeInBytes = cipher._blocksize * 4, |
|||
keystream = iv.slice(0); |
|||
|
|||
// Encrypt each byte
|
|||
for (var i = 0; i < m.length; i++) { |
|||
|
|||
var j = i % blockSizeInBytes; |
|||
if (j == 0) cipher._encryptblock(keystream, 0); |
|||
|
|||
m[i] ^= keystream[j]; |
|||
keystream[j] = m[i]; |
|||
} |
|||
}; |
|||
CFB_prototype._doDecrypt = function (cipher, c, iv) { |
|||
var blockSizeInBytes = cipher._blocksize * 4, |
|||
keystream = iv.slice(0); |
|||
|
|||
// Encrypt each byte
|
|||
for (var i = 0; i < c.length; i++) { |
|||
|
|||
var j = i % blockSizeInBytes; |
|||
if (j == 0) cipher._encryptblock(keystream, 0); |
|||
|
|||
var b = c[i]; |
|||
c[i] ^= keystream[j]; |
|||
keystream[j] = b; |
|||
} |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* Output feed back |
|||
* |
|||
* The cipher repeatedly encrypts its own output. The output is XORed with the |
|||
* plain text to produce the cipher text. |
|||
* |
|||
* This is a stream cipher mode and does not require padding. |
|||
*/ |
|||
var OFB = C_mode.OFB = function () { |
|||
// Call parent constructor
|
|||
Mode.apply(this, arguments); |
|||
}; |
|||
|
|||
// Inherit from Mode
|
|||
var OFB_prototype = OFB.prototype = new Mode; |
|||
|
|||
// Override padding
|
|||
OFB_prototype._padding = C_pad.NoPadding; |
|||
|
|||
// Concrete steps for Mode template
|
|||
OFB_prototype._doEncrypt = function (cipher, m, iv) { |
|||
|
|||
var blockSizeInBytes = cipher._blocksize * 4, |
|||
keystream = iv.slice(0); |
|||
|
|||
// Encrypt each byte
|
|||
for (var i = 0; i < m.length; i++) { |
|||
|
|||
// Generate keystream
|
|||
if (i % blockSizeInBytes == 0) |
|||
cipher._encryptblock(keystream, 0); |
|||
|
|||
// Encrypt byte
|
|||
m[i] ^= keystream[i % blockSizeInBytes]; |
|||
|
|||
} |
|||
}; |
|||
OFB_prototype._doDecrypt = OFB_prototype._doEncrypt; |
|||
|
|||
/** |
|||
* Counter |
|||
* @author Gergely Risko |
|||
* |
|||
* After every block the last 4 bytes of the IV is increased by one |
|||
* with carry and that IV is used for the next block. |
|||
* |
|||
* This is a stream cipher mode and does not require padding. |
|||
*/ |
|||
var CTR = C_mode.CTR = function () { |
|||
// Call parent constructor
|
|||
Mode.apply(this, arguments); |
|||
}; |
|||
|
|||
// Inherit from Mode
|
|||
var CTR_prototype = CTR.prototype = new Mode; |
|||
|
|||
// Override padding
|
|||
CTR_prototype._padding = C_pad.NoPadding; |
|||
|
|||
CTR_prototype._doEncrypt = function (cipher, m, iv) { |
|||
var blockSizeInBytes = cipher._blocksize * 4; |
|||
var counter = iv.slice(0); |
|||
|
|||
for (var i = 0; i < m.length; ) { |
|||
// do not lose iv
|
|||
var keystream = counter.slice(0); |
|||
|
|||
// Generate keystream for next block
|
|||
cipher._encryptblock(keystream, 0); |
|||
|
|||
// XOR keystream with block
|
|||
for (var j = 0; i < m.length && j < blockSizeInBytes; j++, i++) { |
|||
m[i] ^= keystream[j]; |
|||
} |
|||
|
|||
// Increase counter
|
|||
if (++(counter[blockSizeInBytes - 1]) == 256) { |
|||
counter[blockSizeInBytes - 1] = 0; |
|||
if (++(counter[blockSizeInBytes - 2]) == 256) { |
|||
counter[blockSizeInBytes - 2] = 0; |
|||
if (++(counter[blockSizeInBytes - 3]) == 256) { |
|||
counter[blockSizeInBytes - 3] = 0; |
|||
++(counter[blockSizeInBytes - 4]); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}; |
|||
CTR_prototype._doDecrypt = CTR_prototype._doEncrypt; |
|||
|
|||
})(Crypto); |
|||
@ -0,0 +1,43 @@ |
|||
/*! |
|||
* Crypto-JS v2.5.4 HMAC.js |
|||
* http://code.google.com/p/crypto-js/
|
|||
* Copyright (c) 2009-2013, Jeff Mott. All rights reserved. |
|||
* http://code.google.com/p/crypto-js/wiki/License
|
|||
*/ |
|||
(function () { |
|||
|
|||
// Shortcuts
|
|||
var C = Crypto, |
|||
util = C.util, |
|||
charenc = C.charenc, |
|||
UTF8 = charenc.UTF8, |
|||
Binary = charenc.Binary; |
|||
|
|||
C.HMAC = function (hasher, message, key, options) { |
|||
|
|||
// Convert to byte arrays
|
|||
if (message.constructor == String) message = UTF8.stringToBytes(message); |
|||
if (key.constructor == String) key = UTF8.stringToBytes(key); |
|||
/* else, assume byte arrays already */ |
|||
|
|||
// Allow arbitrary length keys
|
|||
if (key.length > hasher._blocksize * 4) |
|||
key = hasher(key, { asBytes: true }); |
|||
|
|||
// XOR keys with pad constants
|
|||
var okey = key.slice(0), |
|||
ikey = key.slice(0); |
|||
for (var i = 0; i < hasher._blocksize * 4; i++) { |
|||
okey[i] ^= 0x5C; |
|||
ikey[i] ^= 0x36; |
|||
} |
|||
|
|||
var hmacbytes = hasher(okey.concat(hasher(ikey.concat(message), { asBytes: true })), { asBytes: true }); |
|||
|
|||
return options && options.asBytes ? hmacbytes : |
|||
options && options.asString ? Binary.bytesToString(hmacbytes) : |
|||
util.bytesToHex(hmacbytes); |
|||
|
|||
}; |
|||
|
|||
})(); |
|||
@ -0,0 +1,149 @@ |
|||
/*! |
|||
* Crypto-JS v2.5.4 Crypto.js |
|||
* http://code.google.com/p/crypto-js/
|
|||
* Copyright (c) 2009-2013, Jeff Mott. All rights reserved. |
|||
* http://code.google.com/p/crypto-js/wiki/License
|
|||
*/ |
|||
if (typeof Crypto == "undefined" || !Crypto.util) { |
|||
(function () { |
|||
|
|||
var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
|||
|
|||
// Global Crypto object
|
|||
var Crypto = window.Crypto = {}; |
|||
|
|||
// Crypto utilities
|
|||
var util = Crypto.util = { |
|||
|
|||
// Bit-wise rotate left
|
|||
rotl: function (n, b) { |
|||
return (n << b) | (n >>> (32 - b)); |
|||
}, |
|||
|
|||
// Bit-wise rotate right
|
|||
rotr: function (n, b) { |
|||
return (n << (32 - b)) | (n >>> b); |
|||
}, |
|||
|
|||
// Swap big-endian to little-endian and vice versa
|
|||
endian: function (n) { |
|||
|
|||
// If number given, swap endian
|
|||
if (n.constructor == Number) { |
|||
return util.rotl(n, 8) & 0x00FF00FF | |
|||
util.rotl(n, 24) & 0xFF00FF00; |
|||
} |
|||
|
|||
// Else, assume array and swap all items
|
|||
for (var i = 0; i < n.length; i++) |
|||
n[i] = util.endian(n[i]); |
|||
return n; |
|||
|
|||
}, |
|||
|
|||
// Generate an array of any length of random bytes
|
|||
randomBytes: function (n) { |
|||
for (var bytes = []; n > 0; n--) |
|||
bytes.push(Math.floor(Math.random() * 256)); |
|||
return bytes; |
|||
}, |
|||
|
|||
// Convert a byte array to big-endian 32-bit words
|
|||
bytesToWords: function (bytes) { |
|||
for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8) |
|||
words[b >>> 5] |= (bytes[i] & 0xFF) << (24 - b % 32); |
|||
return words; |
|||
}, |
|||
|
|||
// Convert big-endian 32-bit words to a byte array
|
|||
wordsToBytes: function (words) { |
|||
for (var bytes = [], b = 0; b < words.length * 32; b += 8) |
|||
bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF); |
|||
return bytes; |
|||
}, |
|||
|
|||
// Convert a byte array to a hex string
|
|||
bytesToHex: function (bytes) { |
|||
for (var hex = [], i = 0; i < bytes.length; i++) { |
|||
hex.push((bytes[i] >>> 4).toString(16)); |
|||
hex.push((bytes[i] & 0xF).toString(16)); |
|||
} |
|||
return hex.join(""); |
|||
}, |
|||
|
|||
// Convert a hex string to a byte array
|
|||
hexToBytes: function (hex) { |
|||
for (var bytes = [], c = 0; c < hex.length; c += 2) |
|||
bytes.push(parseInt(hex.substr(c, 2), 16)); |
|||
return bytes; |
|||
}, |
|||
|
|||
// Convert a byte array to a base-64 string
|
|||
bytesToBase64: function (bytes) { |
|||
for (var base64 = [], i = 0; i < bytes.length; i += 3) { |
|||
var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]; |
|||
for (var j = 0; j < 4; j++) { |
|||
if (i * 8 + j * 6 <= bytes.length * 8) |
|||
base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F)); |
|||
else base64.push("="); |
|||
} |
|||
} |
|||
|
|||
return base64.join(""); |
|||
}, |
|||
|
|||
// Convert a base-64 string to a byte array
|
|||
base64ToBytes: function (base64) { |
|||
// Remove non-base-64 characters
|
|||
base64 = base64.replace(/[^A-Z0-9+\/]/ig, ""); |
|||
|
|||
for (var bytes = [], i = 0, imod4 = 0; i < base64.length; imod4 = ++i % 4) { |
|||
if (imod4 == 0) continue; |
|||
bytes.push(((base64map.indexOf(base64.charAt(i - 1)) & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2)) | |
|||
(base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2))); |
|||
} |
|||
|
|||
return bytes; |
|||
} |
|||
|
|||
}; |
|||
|
|||
// Crypto character encodings
|
|||
var charenc = Crypto.charenc = {}; |
|||
|
|||
// UTF-8 encoding
|
|||
var UTF8 = charenc.UTF8 = { |
|||
|
|||
// Convert a string to a byte array
|
|||
stringToBytes: function (str) { |
|||
return Binary.stringToBytes(unescape(encodeURIComponent(str))); |
|||
}, |
|||
|
|||
// Convert a byte array to a string
|
|||
bytesToString: function (bytes) { |
|||
return decodeURIComponent(escape(Binary.bytesToString(bytes))); |
|||
} |
|||
|
|||
}; |
|||
|
|||
// Binary encoding
|
|||
var Binary = charenc.Binary = { |
|||
|
|||
// Convert a string to a byte array
|
|||
stringToBytes: function (str) { |
|||
for (var bytes = [], i = 0; i < str.length; i++) |
|||
bytes.push(str.charCodeAt(i) & 0xFF); |
|||
return bytes; |
|||
}, |
|||
|
|||
// Convert a byte array to a string
|
|||
bytesToString: function (bytes) { |
|||
for (var str = [], i = 0; i < bytes.length; i++) |
|||
str.push(String.fromCharCode(bytes[i])); |
|||
return str.join(""); |
|||
} |
|||
|
|||
}; |
|||
|
|||
})(); |
|||
} |
|||
@ -0,0 +1,54 @@ |
|||
/*! |
|||
* Crypto-JS v2.5.4 PBKDF2.js |
|||
* http://code.google.com/p/crypto-js/
|
|||
* Copyright (c) 2009-2013, Jeff Mott. All rights reserved. |
|||
* http://code.google.com/p/crypto-js/wiki/License
|
|||
*/ |
|||
(function () { |
|||
|
|||
// Shortcuts
|
|||
var C = Crypto, |
|||
util = C.util, |
|||
charenc = C.charenc, |
|||
UTF8 = charenc.UTF8, |
|||
Binary = charenc.Binary; |
|||
|
|||
C.PBKDF2 = function (password, salt, keylen, options) { |
|||
|
|||
// Convert to byte arrays
|
|||
if (password.constructor == String) password = UTF8.stringToBytes(password); |
|||
if (salt.constructor == String) salt = UTF8.stringToBytes(salt); |
|||
/* else, assume byte arrays already */ |
|||
|
|||
// Defaults
|
|||
var hasher = options && options.hasher || C.SHA1, |
|||
iterations = options && options.iterations || 1; |
|||
|
|||
// Pseudo-random function
|
|||
function PRF(password, salt) { |
|||
return C.HMAC(hasher, salt, password, { asBytes: true }); |
|||
} |
|||
|
|||
// Generate key
|
|||
var derivedKeyBytes = [], |
|||
blockindex = 1; |
|||
while (derivedKeyBytes.length < keylen) { |
|||
var block = PRF(password, salt.concat(util.wordsToBytes([blockindex]))); |
|||
for (var u = block, i = 1; i < iterations; i++) { |
|||
u = PRF(password, u); |
|||
for (var j = 0; j < block.length; j++) block[j] ^= u[j]; |
|||
} |
|||
derivedKeyBytes = derivedKeyBytes.concat(block); |
|||
blockindex++; |
|||
} |
|||
|
|||
// Truncate excess bytes
|
|||
derivedKeyBytes.length = keylen; |
|||
|
|||
return options && options.asBytes ? derivedKeyBytes : |
|||
options && options.asString ? Binary.bytesToString(derivedKeyBytes) : |
|||
util.bytesToHex(derivedKeyBytes); |
|||
|
|||
}; |
|||
|
|||
})(); |
|||
@ -0,0 +1,164 @@ |
|||
/*! |
|||
* Crypto-JS v2.0.0 RIPEMD-160 |
|||
* http://code.google.com/p/crypto-js/
|
|||
* Copyright (c) 2009, Jeff Mott. All rights reserved. |
|||
* http://code.google.com/p/crypto-js/wiki/License
|
|||
* |
|||
* A JavaScript implementation of the RIPEMD-160 Algorithm |
|||
* Version 2.2 Copyright Jeremy Lin, Paul Johnston 2000 - 2009. |
|||
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet |
|||
* Distributed under the BSD License |
|||
* See http://pajhome.org.uk/crypt/md5 for details.
|
|||
* Also http://www.ocf.berkeley.edu/~jjlin/jsotp/
|
|||
* Ported to Crypto-JS by Stefan Thomas. |
|||
*/ |
|||
|
|||
(function () { |
|||
// Shortcuts
|
|||
var C = Crypto, |
|||
util = C.util, |
|||
charenc = C.charenc, |
|||
UTF8 = charenc.UTF8, |
|||
Binary = charenc.Binary; |
|||
|
|||
// Convert a byte array to little-endian 32-bit words
|
|||
util.bytesToLWords = function (bytes) { |
|||
|
|||
var output = Array(bytes.length >> 2); |
|||
for (var i = 0; i < output.length; i++) |
|||
output[i] = 0; |
|||
for (var i = 0; i < bytes.length * 8; i += 8) |
|||
output[i >> 5] |= (bytes[i / 8] & 0xFF) << (i % 32); |
|||
return output; |
|||
}; |
|||
|
|||
// Convert little-endian 32-bit words to a byte array
|
|||
util.lWordsToBytes = function (words) { |
|||
var output = []; |
|||
for (var i = 0; i < words.length * 32; i += 8) |
|||
output.push((words[i >> 5] >>> (i % 32)) & 0xff); |
|||
return output; |
|||
}; |
|||
|
|||
// Public API
|
|||
var RIPEMD160 = C.RIPEMD160 = function (message, options) { |
|||
var digestbytes = util.lWordsToBytes(RIPEMD160._rmd160(message)); |
|||
return options && options.asBytes ? digestbytes : |
|||
options && options.asString ? Binary.bytesToString(digestbytes) : |
|||
util.bytesToHex(digestbytes); |
|||
}; |
|||
|
|||
// The core
|
|||
RIPEMD160._rmd160 = function (message) { |
|||
// Convert to byte array
|
|||
if (message.constructor == String) message = UTF8.stringToBytes(message); |
|||
|
|||
var x = util.bytesToLWords(message), |
|||
len = message.length * 8; |
|||
|
|||
/* append padding */ |
|||
x[len >> 5] |= 0x80 << (len % 32); |
|||
x[(((len + 64) >>> 9) << 4) + 14] = len; |
|||
|
|||
var h0 = 0x67452301; |
|||
var h1 = 0xefcdab89; |
|||
var h2 = 0x98badcfe; |
|||
var h3 = 0x10325476; |
|||
var h4 = 0xc3d2e1f0; |
|||
|
|||
for (var i = 0; i < x.length; i += 16) { |
|||
var T; |
|||
var A1 = h0, B1 = h1, C1 = h2, D1 = h3, E1 = h4; |
|||
var A2 = h0, B2 = h1, C2 = h2, D2 = h3, E2 = h4; |
|||
for (var j = 0; j <= 79; ++j) { |
|||
T = safe_add(A1, rmd160_f(j, B1, C1, D1)); |
|||
T = safe_add(T, x[i + rmd160_r1[j]]); |
|||
T = safe_add(T, rmd160_K1(j)); |
|||
T = safe_add(bit_rol(T, rmd160_s1[j]), E1); |
|||
A1 = E1; E1 = D1; D1 = bit_rol(C1, 10); C1 = B1; B1 = T; |
|||
T = safe_add(A2, rmd160_f(79 - j, B2, C2, D2)); |
|||
T = safe_add(T, x[i + rmd160_r2[j]]); |
|||
T = safe_add(T, rmd160_K2(j)); |
|||
T = safe_add(bit_rol(T, rmd160_s2[j]), E2); |
|||
A2 = E2; E2 = D2; D2 = bit_rol(C2, 10); C2 = B2; B2 = T; |
|||
} |
|||
T = safe_add(h1, safe_add(C1, D2)); |
|||
h1 = safe_add(h2, safe_add(D1, E2)); |
|||
h2 = safe_add(h3, safe_add(E1, A2)); |
|||
h3 = safe_add(h4, safe_add(A1, B2)); |
|||
h4 = safe_add(h0, safe_add(B1, C2)); |
|||
h0 = T; |
|||
} |
|||
return [h0, h1, h2, h3, h4]; |
|||
} |
|||
|
|||
function rmd160_f(j, x, y, z) { |
|||
return (0 <= j && j <= 15) ? (x ^ y ^ z) : |
|||
(16 <= j && j <= 31) ? (x & y) | (~x & z) : |
|||
(32 <= j && j <= 47) ? (x | ~y) ^ z : |
|||
(48 <= j && j <= 63) ? (x & z) | (y & ~z) : |
|||
(64 <= j && j <= 79) ? x ^ (y | ~z) : |
|||
"rmd160_f: j out of range"; |
|||
} |
|||
function rmd160_K1(j) { |
|||
return (0 <= j && j <= 15) ? 0x00000000 : |
|||
(16 <= j && j <= 31) ? 0x5a827999 : |
|||
(32 <= j && j <= 47) ? 0x6ed9eba1 : |
|||
(48 <= j && j <= 63) ? 0x8f1bbcdc : |
|||
(64 <= j && j <= 79) ? 0xa953fd4e : |
|||
"rmd160_K1: j out of range"; |
|||
} |
|||
function rmd160_K2(j) { |
|||
return (0 <= j && j <= 15) ? 0x50a28be6 : |
|||
(16 <= j && j <= 31) ? 0x5c4dd124 : |
|||
(32 <= j && j <= 47) ? 0x6d703ef3 : |
|||
(48 <= j && j <= 63) ? 0x7a6d76e9 : |
|||
(64 <= j && j <= 79) ? 0x00000000 : |
|||
"rmd160_K2: j out of range"; |
|||
} |
|||
var rmd160_r1 = [ |
|||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, |
|||
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, |
|||
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, |
|||
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, |
|||
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 |
|||
]; |
|||
var rmd160_r2 = [ |
|||
5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, |
|||
6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, |
|||
15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, |
|||
8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, |
|||
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 |
|||
]; |
|||
var rmd160_s1 = [ |
|||
11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, |
|||
7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, |
|||
11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, |
|||
11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, |
|||
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 |
|||
]; |
|||
var rmd160_s2 = [ |
|||
8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, |
|||
9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, |
|||
9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, |
|||
15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, |
|||
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 |
|||
]; |
|||
|
|||
/* |
|||
* Add integers, wrapping at 2^32. This uses 16-bit operations internally |
|||
* to work around bugs in some JS interpreters. |
|||
*/ |
|||
function safe_add(x, y) { |
|||
var lsw = (x & 0xFFFF) + (y & 0xFFFF); |
|||
var msw = (x >> 16) + (y >> 16) + (lsw >> 16); |
|||
return (msw << 16) | (lsw & 0xFFFF); |
|||
} |
|||
|
|||
/* |
|||
* Bitwise rotate a 32-bit number to the left. |
|||
*/ |
|||
function bit_rol(num, cnt) { |
|||
return (num << cnt) | (num >>> (32 - cnt)); |
|||
} |
|||
})(); |
|||
@ -0,0 +1,135 @@ |
|||
/*! |
|||
* Crypto-JS v2.5.4 SHA256.js |
|||
* http://code.google.com/p/crypto-js/
|
|||
* Copyright (c) 2009-2013, Jeff Mott. All rights reserved. |
|||
* http://code.google.com/p/crypto-js/wiki/License
|
|||
*/ |
|||
(function () { |
|||
|
|||
// Shortcuts
|
|||
var C = Crypto, |
|||
util = C.util, |
|||
charenc = C.charenc, |
|||
UTF8 = charenc.UTF8, |
|||
Binary = charenc.Binary; |
|||
|
|||
// Constants
|
|||
var K = [0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, |
|||
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, |
|||
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, |
|||
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, |
|||
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, |
|||
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, |
|||
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, |
|||
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, |
|||
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, |
|||
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, |
|||
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, |
|||
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, |
|||
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, |
|||
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, |
|||
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, |
|||
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2]; |
|||
|
|||
// Public API
|
|||
var SHA256 = C.SHA256 = function (message, options) { |
|||
var digestbytes = util.wordsToBytes(SHA256._sha256(message)); |
|||
return options && options.asBytes ? digestbytes : |
|||
options && options.asString ? Binary.bytesToString(digestbytes) : |
|||
util.bytesToHex(digestbytes); |
|||
}; |
|||
|
|||
// The core
|
|||
SHA256._sha256 = function (message) { |
|||
|
|||
// Convert to byte array
|
|||
if (message.constructor == String) message = UTF8.stringToBytes(message); |
|||
/* else, assume byte array already */ |
|||
|
|||
var m = util.bytesToWords(message), |
|||
l = message.length * 8, |
|||
H = [0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, |
|||
0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19], |
|||
w = [], |
|||
a, b, c, d, e, f, g, h, i, j, |
|||
t1, t2; |
|||
|
|||
// Padding
|
|||
m[l >> 5] |= 0x80 << (24 - l % 32); |
|||
m[((l + 64 >> 9) << 4) + 15] = l; |
|||
|
|||
for (var i = 0; i < m.length; i += 16) { |
|||
|
|||
a = H[0]; |
|||
b = H[1]; |
|||
c = H[2]; |
|||
d = H[3]; |
|||
e = H[4]; |
|||
f = H[5]; |
|||
g = H[6]; |
|||
h = H[7]; |
|||
|
|||
for (var j = 0; j < 64; j++) { |
|||
|
|||
if (j < 16) w[j] = m[j + i]; |
|||
else { |
|||
|
|||
var gamma0x = w[j - 15], |
|||
gamma1x = w[j - 2], |
|||
gamma0 = ((gamma0x << 25) | (gamma0x >>> 7)) ^ |
|||
((gamma0x << 14) | (gamma0x >>> 18)) ^ |
|||
(gamma0x >>> 3), |
|||
gamma1 = ((gamma1x << 15) | (gamma1x >>> 17)) ^ |
|||
((gamma1x << 13) | (gamma1x >>> 19)) ^ |
|||
(gamma1x >>> 10); |
|||
|
|||
w[j] = gamma0 + (w[j - 7] >>> 0) + |
|||
gamma1 + (w[j - 16] >>> 0); |
|||
|
|||
} |
|||
|
|||
var ch = e & f ^ ~e & g, |
|||
maj = a & b ^ a & c ^ b & c, |
|||
sigma0 = ((a << 30) | (a >>> 2)) ^ |
|||
((a << 19) | (a >>> 13)) ^ |
|||
((a << 10) | (a >>> 22)), |
|||
sigma1 = ((e << 26) | (e >>> 6)) ^ |
|||
((e << 21) | (e >>> 11)) ^ |
|||
((e << 7) | (e >>> 25)); |
|||
|
|||
|
|||
t1 = (h >>> 0) + sigma1 + ch + (K[j]) + (w[j] >>> 0); |
|||
t2 = sigma0 + maj; |
|||
|
|||
h = g; |
|||
g = f; |
|||
f = e; |
|||
e = (d + t1) >>> 0; |
|||
d = c; |
|||
c = b; |
|||
b = a; |
|||
a = (t1 + t2) >>> 0; |
|||
|
|||
} |
|||
|
|||
H[0] += a; |
|||
H[1] += b; |
|||
H[2] += c; |
|||
H[3] += d; |
|||
H[4] += e; |
|||
H[5] += f; |
|||
H[6] += g; |
|||
H[7] += h; |
|||
|
|||
} |
|||
|
|||
return H; |
|||
|
|||
}; |
|||
|
|||
// Package private blocksize
|
|||
SHA256._blocksize = 16; |
|||
|
|||
SHA256._digestsize = 32; |
|||
|
|||
})(); |
|||
@ -0,0 +1,669 @@ |
|||
//https://raw.github.com/bitcoinjs/bitcoinjs-lib/faa10f0f6a1fff0b9a99fffb9bc30cee33b17212/src/ecdsa.js
|
|||
/*! |
|||
* Basic Javascript Elliptic Curve implementation |
|||
* Ported loosely from BouncyCastle's Java EC code |
|||
* Only Fp curves implemented for now |
|||
* |
|||
* Copyright Tom Wu, bitaddress.org BSD License. |
|||
* http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
|
|||
*/ |
|||
(function () { |
|||
|
|||
// Constructor function of Global EllipticCurve object
|
|||
var ec = window.EllipticCurve = function () { }; |
|||
|
|||
|
|||
// ----------------
|
|||
// ECFieldElementFp constructor
|
|||
// q instanceof BigInteger
|
|||
// x instanceof BigInteger
|
|||
ec.FieldElementFp = function (q, x) { |
|||
this.x = x; |
|||
// TODO if(x.compareTo(q) >= 0) error
|
|||
this.q = q; |
|||
}; |
|||
|
|||
ec.FieldElementFp.prototype.equals = function (other) { |
|||
if (other == this) return true; |
|||
return (this.q.equals(other.q) && this.x.equals(other.x)); |
|||
}; |
|||
|
|||
ec.FieldElementFp.prototype.toBigInteger = function () { |
|||
return this.x; |
|||
}; |
|||
|
|||
ec.FieldElementFp.prototype.negate = function () { |
|||
return new ec.FieldElementFp(this.q, this.x.negate().mod(this.q)); |
|||
}; |
|||
|
|||
ec.FieldElementFp.prototype.add = function (b) { |
|||
return new ec.FieldElementFp(this.q, this.x.add(b.toBigInteger()).mod(this.q)); |
|||
}; |
|||
|
|||
ec.FieldElementFp.prototype.subtract = function (b) { |
|||
return new ec.FieldElementFp(this.q, this.x.subtract(b.toBigInteger()).mod(this.q)); |
|||
}; |
|||
|
|||
ec.FieldElementFp.prototype.multiply = function (b) { |
|||
return new ec.FieldElementFp(this.q, this.x.multiply(b.toBigInteger()).mod(this.q)); |
|||
}; |
|||
|
|||
ec.FieldElementFp.prototype.square = function () { |
|||
return new ec.FieldElementFp(this.q, this.x.square().mod(this.q)); |
|||
}; |
|||
|
|||
ec.FieldElementFp.prototype.divide = function (b) { |
|||
return new ec.FieldElementFp(this.q, this.x.multiply(b.toBigInteger().modInverse(this.q)).mod(this.q)); |
|||
}; |
|||
|
|||
ec.FieldElementFp.prototype.getByteLength = function () { |
|||
return Math.floor((this.toBigInteger().bitLength() + 7) / 8); |
|||
}; |
|||
|
|||
// D.1.4 91
|
|||
/** |
|||
* return a sqrt root - the routine verifies that the calculation |
|||
* returns the right value - if none exists it returns null. |
|||
* |
|||
* Copyright (c) 2000 - 2011 The Legion Of The Bouncy Castle (http://www.bouncycastle.org)
|
|||
* Ported to JavaScript by bitaddress.org |
|||
*/ |
|||
ec.FieldElementFp.prototype.sqrt = function () { |
|||
if (!this.q.testBit(0)) throw new Error("even value of q"); |
|||
|
|||
// p mod 4 == 3
|
|||
if (this.q.testBit(1)) { |
|||
// z = g^(u+1) + p, p = 4u + 3
|
|||
var z = new ec.FieldElementFp(this.q, this.x.modPow(this.q.shiftRight(2).add(BigInteger.ONE), this.q)); |
|||
return z.square().equals(this) ? z : null; |
|||
} |
|||
|
|||
// p mod 4 == 1
|
|||
var qMinusOne = this.q.subtract(BigInteger.ONE); |
|||
var legendreExponent = qMinusOne.shiftRight(1); |
|||
if (!(this.x.modPow(legendreExponent, this.q).equals(BigInteger.ONE))) return null; |
|||
var u = qMinusOne.shiftRight(2); |
|||
var k = u.shiftLeft(1).add(BigInteger.ONE); |
|||
var Q = this.x; |
|||
var fourQ = Q.shiftLeft(2).mod(this.q); |
|||
var U, V; |
|||
|
|||
do { |
|||
var rand = new SecureRandom(); |
|||
var P; |
|||
do { |
|||
P = new BigInteger(this.q.bitLength(), rand); |
|||
} |
|||
while (P.compareTo(this.q) >= 0 || !(P.multiply(P).subtract(fourQ).modPow(legendreExponent, this.q).equals(qMinusOne))); |
|||
|
|||
var result = ec.FieldElementFp.fastLucasSequence(this.q, P, Q, k); |
|||
|
|||
U = result[0]; |
|||
V = result[1]; |
|||
if (V.multiply(V).mod(this.q).equals(fourQ)) { |
|||
// Integer division by 2, mod q
|
|||
if (V.testBit(0)) { |
|||
V = V.add(this.q); |
|||
} |
|||
V = V.shiftRight(1); |
|||
return new ec.FieldElementFp(this.q, V); |
|||
} |
|||
} |
|||
while (U.equals(BigInteger.ONE) || U.equals(qMinusOne)); |
|||
|
|||
return null; |
|||
}; |
|||
|
|||
/* |
|||
* Copyright (c) 2000 - 2011 The Legion Of The Bouncy Castle (http://www.bouncycastle.org)
|
|||
* Ported to JavaScript by bitaddress.org |
|||
*/ |
|||
ec.FieldElementFp.fastLucasSequence = function (p, P, Q, k) { |
|||
// TODO Research and apply "common-multiplicand multiplication here"
|
|||
|
|||
var n = k.bitLength(); |
|||
var s = k.getLowestSetBit(); |
|||
var Uh = BigInteger.ONE; |
|||
var Vl = BigInteger.TWO; |
|||
var Vh = P; |
|||
var Ql = BigInteger.ONE; |
|||
var Qh = BigInteger.ONE; |
|||
|
|||
for (var j = n - 1; j >= s + 1; --j) { |
|||
Ql = Ql.multiply(Qh).mod(p); |
|||
if (k.testBit(j)) { |
|||
Qh = Ql.multiply(Q).mod(p); |
|||
Uh = Uh.multiply(Vh).mod(p); |
|||
Vl = Vh.multiply(Vl).subtract(P.multiply(Ql)).mod(p); |
|||
Vh = Vh.multiply(Vh).subtract(Qh.shiftLeft(1)).mod(p); |
|||
} |
|||
else { |
|||
Qh = Ql; |
|||
Uh = Uh.multiply(Vl).subtract(Ql).mod(p); |
|||
Vh = Vh.multiply(Vl).subtract(P.multiply(Ql)).mod(p); |
|||
Vl = Vl.multiply(Vl).subtract(Ql.shiftLeft(1)).mod(p); |
|||
} |
|||
} |
|||
|
|||
Ql = Ql.multiply(Qh).mod(p); |
|||
Qh = Ql.multiply(Q).mod(p); |
|||
Uh = Uh.multiply(Vl).subtract(Ql).mod(p); |
|||
Vl = Vh.multiply(Vl).subtract(P.multiply(Ql)).mod(p); |
|||
Ql = Ql.multiply(Qh).mod(p); |
|||
|
|||
for (var j = 1; j <= s; ++j) { |
|||
Uh = Uh.multiply(Vl).mod(p); |
|||
Vl = Vl.multiply(Vl).subtract(Ql.shiftLeft(1)).mod(p); |
|||
Ql = Ql.multiply(Ql).mod(p); |
|||
} |
|||
|
|||
return [Uh, Vl]; |
|||
}; |
|||
|
|||
// ----------------
|
|||
// ECPointFp constructor
|
|||
ec.PointFp = function (curve, x, y, z, compressed) { |
|||
this.curve = curve; |
|||
this.x = x; |
|||
this.y = y; |
|||
// Projective coordinates: either zinv == null or z * zinv == 1
|
|||
// z and zinv are just BigIntegers, not fieldElements
|
|||
if (z == null) { |
|||
this.z = BigInteger.ONE; |
|||
} |
|||
else { |
|||
this.z = z; |
|||
} |
|||
this.zinv = null; |
|||
// compression flag
|
|||
this.compressed = !!compressed; |
|||
}; |
|||
|
|||
ec.PointFp.prototype.getX = function () { |
|||
if (this.zinv == null) { |
|||
this.zinv = this.z.modInverse(this.curve.q); |
|||
} |
|||
var r = this.x.toBigInteger().multiply(this.zinv); |
|||
this.curve.reduce(r); |
|||
return this.curve.fromBigInteger(r); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.getY = function () { |
|||
if (this.zinv == null) { |
|||
this.zinv = this.z.modInverse(this.curve.q); |
|||
} |
|||
var r = this.y.toBigInteger().multiply(this.zinv); |
|||
this.curve.reduce(r); |
|||
return this.curve.fromBigInteger(r); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.equals = function (other) { |
|||
if (other == this) return true; |
|||
if (this.isInfinity()) return other.isInfinity(); |
|||
if (other.isInfinity()) return this.isInfinity(); |
|||
var u, v; |
|||
// u = Y2 * Z1 - Y1 * Z2
|
|||
u = other.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(other.z)).mod(this.curve.q); |
|||
if (!u.equals(BigInteger.ZERO)) return false; |
|||
// v = X2 * Z1 - X1 * Z2
|
|||
v = other.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(other.z)).mod(this.curve.q); |
|||
return v.equals(BigInteger.ZERO); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.isInfinity = function () { |
|||
if ((this.x == null) && (this.y == null)) return true; |
|||
return this.z.equals(BigInteger.ZERO) && !this.y.toBigInteger().equals(BigInteger.ZERO); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.negate = function () { |
|||
return new ec.PointFp(this.curve, this.x, this.y.negate(), this.z); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.add = function (b) { |
|||
if (this.isInfinity()) return b; |
|||
if (b.isInfinity()) return this; |
|||
|
|||
// u = Y2 * Z1 - Y1 * Z2
|
|||
var u = b.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(b.z)).mod(this.curve.q); |
|||
// v = X2 * Z1 - X1 * Z2
|
|||
var v = b.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(b.z)).mod(this.curve.q); |
|||
|
|||
|
|||
if (BigInteger.ZERO.equals(v)) { |
|||
if (BigInteger.ZERO.equals(u)) { |
|||
return this.twice(); // this == b, so double
|
|||
} |
|||
return this.curve.getInfinity(); // this = -b, so infinity
|
|||
} |
|||
|
|||
var THREE = new BigInteger("3"); |
|||
var x1 = this.x.toBigInteger(); |
|||
var y1 = this.y.toBigInteger(); |
|||
var x2 = b.x.toBigInteger(); |
|||
var y2 = b.y.toBigInteger(); |
|||
|
|||
var v2 = v.square(); |
|||
var v3 = v2.multiply(v); |
|||
var x1v2 = x1.multiply(v2); |
|||
var zu2 = u.square().multiply(this.z); |
|||
|
|||
// x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)
|
|||
var x3 = zu2.subtract(x1v2.shiftLeft(1)).multiply(b.z).subtract(v3).multiply(v).mod(this.curve.q); |
|||
// y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3
|
|||
var y3 = x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)).multiply(b.z).add(u.multiply(v3)).mod(this.curve.q); |
|||
// z3 = v^3 * z1 * z2
|
|||
var z3 = v3.multiply(this.z).multiply(b.z).mod(this.curve.q); |
|||
|
|||
return new ec.PointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.twice = function () { |
|||
if (this.isInfinity()) return this; |
|||
if (this.y.toBigInteger().signum() == 0) return this.curve.getInfinity(); |
|||
|
|||
// TODO: optimized handling of constants
|
|||
var THREE = new BigInteger("3"); |
|||
var x1 = this.x.toBigInteger(); |
|||
var y1 = this.y.toBigInteger(); |
|||
|
|||
var y1z1 = y1.multiply(this.z); |
|||
var y1sqz1 = y1z1.multiply(y1).mod(this.curve.q); |
|||
var a = this.curve.a.toBigInteger(); |
|||
|
|||
// w = 3 * x1^2 + a * z1^2
|
|||
var w = x1.square().multiply(THREE); |
|||
if (!BigInteger.ZERO.equals(a)) { |
|||
w = w.add(this.z.square().multiply(a)); |
|||
} |
|||
w = w.mod(this.curve.q); |
|||
//this.curve.reduce(w);
|
|||
// x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)
|
|||
var x3 = w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).mod(this.curve.q); |
|||
// y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3
|
|||
var y3 = w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1).subtract(w.square().multiply(w)).mod(this.curve.q); |
|||
// z3 = 8 * (y1 * z1)^3
|
|||
var z3 = y1z1.square().multiply(y1z1).shiftLeft(3).mod(this.curve.q); |
|||
|
|||
return new ec.PointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3); |
|||
}; |
|||
|
|||
// Simple NAF (Non-Adjacent Form) multiplication algorithm
|
|||
// TODO: modularize the multiplication algorithm
|
|||
ec.PointFp.prototype.multiply = function (k) { |
|||
if (this.isInfinity()) return this; |
|||
if (k.signum() == 0) return this.curve.getInfinity(); |
|||
|
|||
var e = k; |
|||
var h = e.multiply(new BigInteger("3")); |
|||
|
|||
var neg = this.negate(); |
|||
var R = this; |
|||
|
|||
var i; |
|||
for (i = h.bitLength() - 2; i > 0; --i) { |
|||
R = R.twice(); |
|||
|
|||
var hBit = h.testBit(i); |
|||
var eBit = e.testBit(i); |
|||
|
|||
if (hBit != eBit) { |
|||
R = R.add(hBit ? this : neg); |
|||
} |
|||
} |
|||
|
|||
return R; |
|||
}; |
|||
|
|||
// Compute this*j + x*k (simultaneous multiplication)
|
|||
ec.PointFp.prototype.multiplyTwo = function (j, x, k) { |
|||
var i; |
|||
if (j.bitLength() > k.bitLength()) |
|||
i = j.bitLength() - 1; |
|||
else |
|||
i = k.bitLength() - 1; |
|||
|
|||
var R = this.curve.getInfinity(); |
|||
var both = this.add(x); |
|||
while (i >= 0) { |
|||
R = R.twice(); |
|||
if (j.testBit(i)) { |
|||
if (k.testBit(i)) { |
|||
R = R.add(both); |
|||
} |
|||
else { |
|||
R = R.add(this); |
|||
} |
|||
} |
|||
else { |
|||
if (k.testBit(i)) { |
|||
R = R.add(x); |
|||
} |
|||
} |
|||
--i; |
|||
} |
|||
|
|||
return R; |
|||
}; |
|||
|
|||
// patched by bitaddress.org and Casascius for use with Bitcoin.ECKey
|
|||
// patched by coretechs to support compressed public keys
|
|||
ec.PointFp.prototype.getEncoded = function (compressed) { |
|||
var x = this.getX().toBigInteger(); |
|||
var y = this.getY().toBigInteger(); |
|||
var len = 32; // integerToBytes will zero pad if integer is less than 32 bytes. 32 bytes length is required by the Bitcoin protocol.
|
|||
var enc = ec.integerToBytes(x, len); |
|||
|
|||
// when compressed prepend byte depending if y point is even or odd
|
|||
if (compressed) { |
|||
if (y.isEven()) { |
|||
enc.unshift(0x02); |
|||
} |
|||
else { |
|||
enc.unshift(0x03); |
|||
} |
|||
} |
|||
else { |
|||
enc.unshift(0x04); |
|||
enc = enc.concat(ec.integerToBytes(y, len)); // uncompressed public key appends the bytes of the y point
|
|||
} |
|||
return enc; |
|||
}; |
|||
|
|||
ec.PointFp.decodeFrom = function (curve, enc) { |
|||
var type = enc[0]; |
|||
var dataLen = enc.length - 1; |
|||
|
|||
// Extract x and y as byte arrays
|
|||
var xBa = enc.slice(1, 1 + dataLen / 2); |
|||
var yBa = enc.slice(1 + dataLen / 2, 1 + dataLen); |
|||
|
|||
// Prepend zero byte to prevent interpretation as negative integer
|
|||
xBa.unshift(0); |
|||
yBa.unshift(0); |
|||
|
|||
// Convert to BigIntegers
|
|||
var x = new BigInteger(xBa); |
|||
var y = new BigInteger(yBa); |
|||
|
|||
// Return point
|
|||
return new ec.PointFp(curve, curve.fromBigInteger(x), curve.fromBigInteger(y)); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.add2D = function (b) { |
|||
if (this.isInfinity()) return b; |
|||
if (b.isInfinity()) return this; |
|||
|
|||
if (this.x.equals(b.x)) { |
|||
if (this.y.equals(b.y)) { |
|||
// this = b, i.e. this must be doubled
|
|||
return this.twice(); |
|||
} |
|||
// this = -b, i.e. the result is the point at infinity
|
|||
return this.curve.getInfinity(); |
|||
} |
|||
|
|||
var x_x = b.x.subtract(this.x); |
|||
var y_y = b.y.subtract(this.y); |
|||
var gamma = y_y.divide(x_x); |
|||
|
|||
var x3 = gamma.square().subtract(this.x).subtract(b.x); |
|||
var y3 = gamma.multiply(this.x.subtract(x3)).subtract(this.y); |
|||
|
|||
return new ec.PointFp(this.curve, x3, y3); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.twice2D = function () { |
|||
if (this.isInfinity()) return this; |
|||
if (this.y.toBigInteger().signum() == 0) { |
|||
// if y1 == 0, then (x1, y1) == (x1, -y1)
|
|||
// and hence this = -this and thus 2(x1, y1) == infinity
|
|||
return this.curve.getInfinity(); |
|||
} |
|||
|
|||
var TWO = this.curve.fromBigInteger(BigInteger.valueOf(2)); |
|||
var THREE = this.curve.fromBigInteger(BigInteger.valueOf(3)); |
|||
var gamma = this.x.square().multiply(THREE).add(this.curve.a).divide(this.y.multiply(TWO)); |
|||
|
|||
var x3 = gamma.square().subtract(this.x.multiply(TWO)); |
|||
var y3 = gamma.multiply(this.x.subtract(x3)).subtract(this.y); |
|||
|
|||
return new ec.PointFp(this.curve, x3, y3); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.multiply2D = function (k) { |
|||
if (this.isInfinity()) return this; |
|||
if (k.signum() == 0) return this.curve.getInfinity(); |
|||
|
|||
var e = k; |
|||
var h = e.multiply(new BigInteger("3")); |
|||
|
|||
var neg = this.negate(); |
|||
var R = this; |
|||
|
|||
var i; |
|||
for (i = h.bitLength() - 2; i > 0; --i) { |
|||
R = R.twice(); |
|||
|
|||
var hBit = h.testBit(i); |
|||
var eBit = e.testBit(i); |
|||
|
|||
if (hBit != eBit) { |
|||
R = R.add2D(hBit ? this : neg); |
|||
} |
|||
} |
|||
|
|||
return R; |
|||
}; |
|||
|
|||
ec.PointFp.prototype.isOnCurve = function () { |
|||
var x = this.getX().toBigInteger(); |
|||
var y = this.getY().toBigInteger(); |
|||
var a = this.curve.getA().toBigInteger(); |
|||
var b = this.curve.getB().toBigInteger(); |
|||
var n = this.curve.getQ(); |
|||
var lhs = y.multiply(y).mod(n); |
|||
var rhs = x.multiply(x).multiply(x).add(a.multiply(x)).add(b).mod(n); |
|||
return lhs.equals(rhs); |
|||
}; |
|||
|
|||
ec.PointFp.prototype.toString = function () { |
|||
return '(' + this.getX().toBigInteger().toString() + ',' + this.getY().toBigInteger().toString() + ')'; |
|||
}; |
|||
|
|||
/** |
|||
* Validate an elliptic curve point. |
|||
* |
|||
* See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive |
|||
*/ |
|||
ec.PointFp.prototype.validate = function () { |
|||
var n = this.curve.getQ(); |
|||
|
|||
// Check Q != O
|
|||
if (this.isInfinity()) { |
|||
throw new Error("Point is at infinity."); |
|||
} |
|||
|
|||
// Check coordinate bounds
|
|||
var x = this.getX().toBigInteger(); |
|||
var y = this.getY().toBigInteger(); |
|||
if (x.compareTo(BigInteger.ONE) < 0 || x.compareTo(n.subtract(BigInteger.ONE)) > 0) { |
|||
throw new Error('x coordinate out of bounds'); |
|||
} |
|||
if (y.compareTo(BigInteger.ONE) < 0 || y.compareTo(n.subtract(BigInteger.ONE)) > 0) { |
|||
throw new Error('y coordinate out of bounds'); |
|||
} |
|||
|
|||
// Check y^2 = x^3 + ax + b (mod n)
|
|||
if (!this.isOnCurve()) { |
|||
throw new Error("Point is not on the curve."); |
|||
} |
|||
|
|||
// Check nQ = 0 (Q is a scalar multiple of G)
|
|||
if (this.multiply(n).isInfinity()) { |
|||
// TODO: This check doesn't work - fix.
|
|||
throw new Error("Point is not a scalar multiple of G."); |
|||
} |
|||
|
|||
return true; |
|||
}; |
|||
|
|||
|
|||
|
|||
|
|||
// ----------------
|
|||
// ECCurveFp constructor
|
|||
ec.CurveFp = function (q, a, b) { |
|||
this.q = q; |
|||
this.a = this.fromBigInteger(a); |
|||
this.b = this.fromBigInteger(b); |
|||
this.infinity = new ec.PointFp(this, null, null); |
|||
this.reducer = new Barrett(this.q); |
|||
} |
|||
|
|||
ec.CurveFp.prototype.getQ = function () { |
|||
return this.q; |
|||
}; |
|||
|
|||
ec.CurveFp.prototype.getA = function () { |
|||
return this.a; |
|||
}; |
|||
|
|||
ec.CurveFp.prototype.getB = function () { |
|||
return this.b; |
|||
}; |
|||
|
|||
ec.CurveFp.prototype.equals = function (other) { |
|||
if (other == this) return true; |
|||
return (this.q.equals(other.q) && this.a.equals(other.a) && this.b.equals(other.b)); |
|||
}; |
|||
|
|||
ec.CurveFp.prototype.getInfinity = function () { |
|||
return this.infinity; |
|||
}; |
|||
|
|||
ec.CurveFp.prototype.fromBigInteger = function (x) { |
|||
return new ec.FieldElementFp(this.q, x); |
|||
}; |
|||
|
|||
ec.CurveFp.prototype.reduce = function (x) { |
|||
this.reducer.reduce(x); |
|||
}; |
|||
|
|||
// for now, work with hex strings because they're easier in JS
|
|||
// compressed support added by bitaddress.org
|
|||
ec.CurveFp.prototype.decodePointHex = function (s) { |
|||
var firstByte = parseInt(s.substr(0, 2), 16); |
|||
switch (firstByte) { // first byte
|
|||
case 0: |
|||
return this.infinity; |
|||
case 2: // compressed
|
|||
case 3: // compressed
|
|||
var yTilde = firstByte & 1; |
|||
var xHex = s.substr(2, s.length - 2); |
|||
var X1 = new BigInteger(xHex, 16); |
|||
return this.decompressPoint(yTilde, X1); |
|||
case 4: // uncompressed
|
|||
case 6: // hybrid
|
|||
case 7: // hybrid
|
|||
var len = (s.length - 2) / 2; |
|||
var xHex = s.substr(2, len); |
|||
var yHex = s.substr(len + 2, len); |
|||
|
|||
return new ec.PointFp(this, |
|||
this.fromBigInteger(new BigInteger(xHex, 16)), |
|||
this.fromBigInteger(new BigInteger(yHex, 16))); |
|||
|
|||
default: // unsupported
|
|||
return null; |
|||
} |
|||
}; |
|||
|
|||
ec.CurveFp.prototype.encodePointHex = function (p) { |
|||
if (p.isInfinity()) return "00"; |
|||
var xHex = p.getX().toBigInteger().toString(16); |
|||
var yHex = p.getY().toBigInteger().toString(16); |
|||
var oLen = this.getQ().toString(16).length; |
|||
if ((oLen % 2) != 0) oLen++; |
|||
while (xHex.length < oLen) { |
|||
xHex = "0" + xHex; |
|||
} |
|||
while (yHex.length < oLen) { |
|||
yHex = "0" + yHex; |
|||
} |
|||
return "04" + xHex + yHex; |
|||
}; |
|||
|
|||
/* |
|||
* Copyright (c) 2000 - 2011 The Legion Of The Bouncy Castle (http://www.bouncycastle.org)
|
|||
* Ported to JavaScript by bitaddress.org |
|||
* |
|||
* Number yTilde |
|||
* BigInteger X1 |
|||
*/ |
|||
ec.CurveFp.prototype.decompressPoint = function (yTilde, X1) { |
|||
var x = this.fromBigInteger(X1); |
|||
var alpha = x.multiply(x.square().add(this.getA())).add(this.getB()); |
|||
var beta = alpha.sqrt(); |
|||
// if we can't find a sqrt we haven't got a point on the curve - run!
|
|||
if (beta == null) throw new Error("Invalid point compression"); |
|||
var betaValue = beta.toBigInteger(); |
|||
var bit0 = betaValue.testBit(0) ? 1 : 0; |
|||
if (bit0 != yTilde) { |
|||
// Use the other root
|
|||
beta = this.fromBigInteger(this.getQ().subtract(betaValue)); |
|||
} |
|||
return new ec.PointFp(this, x, beta, null, true); |
|||
}; |
|||
|
|||
|
|||
ec.fromHex = function (s) { return new BigInteger(s, 16); }; |
|||
|
|||
ec.integerToBytes = function (i, len) { |
|||
var bytes = i.toByteArrayUnsigned(); |
|||
if (len < bytes.length) { |
|||
bytes = bytes.slice(bytes.length - len); |
|||
} else while (len > bytes.length) { |
|||
bytes.unshift(0); |
|||
} |
|||
return bytes; |
|||
}; |
|||
|
|||
|
|||
// Named EC curves
|
|||
// ----------------
|
|||
// X9ECParameters constructor
|
|||
ec.X9Parameters = function (curve, g, n, h) { |
|||
this.curve = curve; |
|||
this.g = g; |
|||
this.n = n; |
|||
this.h = h; |
|||
} |
|||
ec.X9Parameters.prototype.getCurve = function () { return this.curve; }; |
|||
ec.X9Parameters.prototype.getG = function () { return this.g; }; |
|||
ec.X9Parameters.prototype.getN = function () { return this.n; }; |
|||
ec.X9Parameters.prototype.getH = function () { return this.h; }; |
|||
|
|||
// secp256k1 is the Curve used by Bitcoin
|
|||
ec.secNamedCurves = { |
|||
// used by Bitcoin
|
|||
"secp256k1": function () { |
|||
// p = 2^256 - 2^32 - 2^9 - 2^8 - 2^7 - 2^6 - 2^4 - 1
|
|||
var p = ec.fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F"); |
|||
var a = BigInteger.ZERO; |
|||
var b = ec.fromHex("7"); |
|||
var n = ec.fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"); |
|||
var h = BigInteger.ONE; |
|||
var curve = new ec.CurveFp(p, a, b); |
|||
var G = curve.decodePointHex("04" |
|||
+ "79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798" |
|||
+ "483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8"); |
|||
return new ec.X9Parameters(curve, G, n, h); |
|||
} |
|||
}; |
|||
|
|||
// secp256k1 called by Bitcoin's ECKEY
|
|||
ec.getSECCurveByName = function (name) { |
|||
if (ec.secNamedCurves[name] == undefined) return null; |
|||
return ec.secNamedCurves[name](); |
|||
} |
|||
})(); |
|||
@ -0,0 +1,187 @@ |
|||
/*! |
|||
* Random number generator with ArcFour PRNG |
|||
* |
|||
* NOTE: For best results, put code like |
|||
* <body onclick='SecureRandom.seedTime();' onkeypress='SecureRandom.seedTime();'> |
|||
* in your main HTML document. |
|||
* |
|||
* Copyright Tom Wu, bitaddress.org BSD License. |
|||
* http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
|
|||
*/ |
|||
(function () { |
|||
|
|||
// Constructor function of Global SecureRandom object
|
|||
var sr = window.SecureRandom = function () { }; |
|||
|
|||
// Properties
|
|||
sr.state; |
|||
sr.pool; |
|||
sr.pptr; |
|||
|
|||
// Pool size must be a multiple of 4 and greater than 32.
|
|||
// An array of bytes the size of the pool will be passed to init()
|
|||
sr.poolSize = 256; |
|||
|
|||
// --- object methods ---
|
|||
|
|||
// public method
|
|||
// ba: byte array
|
|||
sr.prototype.nextBytes = function (ba) { |
|||
var i; |
|||
if (window.crypto && window.crypto.getRandomValues && window.Uint8Array) { |
|||
try { |
|||
var rvBytes = new Uint8Array(ba.length); |
|||
window.crypto.getRandomValues(rvBytes); |
|||
for (i = 0; i < ba.length; ++i) |
|||
ba[i] = sr.getByte() ^ rvBytes[i]; |
|||
return; |
|||
} catch (e) { |
|||
alert(e); |
|||
} |
|||
} |
|||
for (i = 0; i < ba.length; ++i) ba[i] = sr.getByte(); |
|||
}; |
|||
|
|||
|
|||
// --- static methods ---
|
|||
|
|||
// Mix in the current time (w/milliseconds) into the pool
|
|||
// NOTE: this method should be called from body click/keypress event handlers to increase entropy
|
|||
sr.seedTime = function () { |
|||
sr.seedInt(new Date().getTime()); |
|||
} |
|||
|
|||
sr.getByte = function () { |
|||
/*if(!ninja.seeder.isDone()) { |
|||
alert("Premature initialisation of the random generator. Something is really wrong, do not generate wallets."); |
|||
return NaN; |
|||
}*/ |
|||
|
|||
if (sr.state == null) { |
|||
sr.seedTime(); |
|||
sr.state = sr.ArcFour(); // Plug in your RNG constructor here
|
|||
sr.state.init(sr.pool); |
|||
sr.pptr = 0; |
|||
} |
|||
// TODO: allow reseeding after first request
|
|||
return sr.state.next(); |
|||
} |
|||
|
|||
// Mix in a 32-bit integer into the pool
|
|||
sr.seedInt = function (x) { |
|||
sr.seedInt8(x); |
|||
sr.seedInt8((x >> 8)); |
|||
sr.seedInt8((x >> 16)); |
|||
sr.seedInt8((x >> 24)); |
|||
} |
|||
|
|||
// Mix in a 16-bit integer into the pool
|
|||
sr.seedInt16 = function (x) { |
|||
sr.seedInt8(x); |
|||
sr.seedInt8((x >> 8)); |
|||
} |
|||
|
|||
// Mix in a 8-bit integer into the pool
|
|||
sr.seedInt8 = function (x) { |
|||
sr.pool[sr.pptr++] ^= x & 255; |
|||
if (sr.pptr >= sr.poolSize) sr.pptr -= sr.poolSize; |
|||
} |
|||
|
|||
// Arcfour is a PRNG
|
|||
sr.ArcFour = function () { |
|||
function Arcfour() { |
|||
this.i = 0; |
|||
this.j = 0; |
|||
this.S = new Array(); |
|||
} |
|||
|
|||
// Initialize arcfour context from key, an array of ints, each from [0..255]
|
|||
function ARC4init(key) { |
|||
var i, j, t; |
|||
for (i = 0; i < 256; ++i) |
|||
this.S[i] = i; |
|||
j = 0; |
|||
for (i = 0; i < 256; ++i) { |
|||
j = (j + this.S[i] + key[i % key.length]) & 255; |
|||
t = this.S[i]; |
|||
this.S[i] = this.S[j]; |
|||
this.S[j] = t; |
|||
} |
|||
this.i = 0; |
|||
this.j = 0; |
|||
} |
|||
|
|||
function ARC4next() { |
|||
var t; |
|||
this.i = (this.i + 1) & 255; |
|||
this.j = (this.j + this.S[this.i]) & 255; |
|||
t = this.S[this.i]; |
|||
this.S[this.i] = this.S[this.j]; |
|||
this.S[this.j] = t; |
|||
return this.S[(t + this.S[this.i]) & 255]; |
|||
} |
|||
|
|||
Arcfour.prototype.init = ARC4init; |
|||
Arcfour.prototype.next = ARC4next; |
|||
|
|||
return new Arcfour(); |
|||
}; |
|||
|
|||
|
|||
// Initialize the pool with junk if needed.
|
|||
if (sr.pool == null) { |
|||
sr.pool = new Array(); |
|||
sr.pptr = 0; |
|||
var t; |
|||
if (window.crypto && window.crypto.getRandomValues && window.Uint8Array) { |
|||
try { |
|||
// Use webcrypto if available
|
|||
var ua = new Uint8Array(sr.poolSize); |
|||
window.crypto.getRandomValues(ua); |
|||
for (t = 0; t < sr.poolSize; ++t) |
|||
sr.pool[sr.pptr++] = ua[t]; |
|||
} catch (e) { alert(e); } |
|||
} |
|||
while (sr.pptr < sr.poolSize) { // extract some randomness from Math.random()
|
|||
t = Math.floor(65536 * Math.random()); |
|||
sr.pool[sr.pptr++] = t >>> 8; |
|||
sr.pool[sr.pptr++] = t & 255; |
|||
} |
|||
sr.pptr = Math.floor(sr.poolSize * Math.random()); |
|||
sr.seedTime(); |
|||
// entropy
|
|||
var entropyStr = ""; |
|||
// screen size and color depth: ~4.8 to ~5.4 bits
|
|||
entropyStr += (window.screen.height * window.screen.width * window.screen.colorDepth); |
|||
entropyStr += (window.screen.availHeight * window.screen.availWidth * window.screen.pixelDepth); |
|||
// time zone offset: ~4 bits
|
|||
var dateObj = new Date(); |
|||
var timeZoneOffset = dateObj.getTimezoneOffset(); |
|||
entropyStr += timeZoneOffset; |
|||
// user agent: ~8.3 to ~11.6 bits
|
|||
entropyStr += navigator.userAgent; |
|||
// browser plugin details: ~16.2 to ~21.8 bits
|
|||
var pluginsStr = ""; |
|||
for (var i = 0; i < navigator.plugins.length; i++) { |
|||
pluginsStr += navigator.plugins[i].name + " " + navigator.plugins[i].filename + " " + navigator.plugins[i].description + " " + navigator.plugins[i].version + ", "; |
|||
} |
|||
var mimeTypesStr = ""; |
|||
for (var i = 0; i < navigator.mimeTypes.length; i++) { |
|||
mimeTypesStr += navigator.mimeTypes[i].description + " " + navigator.mimeTypes[i].type + " " + navigator.mimeTypes[i].suffixes + ", "; |
|||
} |
|||
entropyStr += pluginsStr + mimeTypesStr; |
|||
// cookies and storage: 1 bit
|
|||
entropyStr += navigator.cookieEnabled + typeof (sessionStorage) + typeof (localStorage); |
|||
// language: ~7 bit
|
|||
entropyStr += navigator.language; |
|||
// history: ~2 bit
|
|||
entropyStr += window.history.length; |
|||
// location
|
|||
entropyStr += window.location; |
|||
|
|||
var entropyBytes = Crypto.SHA256(entropyStr, { asBytes: true }); |
|||
for (var i = 0 ; i < entropyBytes.length ; i++) { |
|||
sr.seedInt8(entropyBytes[i]); |
|||
} |
|||
} |
|||
})(); |
|||
Loading…
Reference in new issue