mirror of https://github.com/moparisthebest/mail
324 lines
8.4 KiB
JavaScript
324 lines
8.4 KiB
JavaScript
/**
|
|
* Secure Hash Algorithm with 160-bit digest (SHA-1) implementation.
|
|
*
|
|
* This implementation is currently limited to message lengths (in bytes) that
|
|
* are up to 32-bits in size.
|
|
*
|
|
* @author Dave Longley
|
|
*
|
|
* Copyright (c) 2010-2012 Digital Bazaar, Inc.
|
|
*/
|
|
(function() {
|
|
/* ########## Begin module implementation ########## */
|
|
function initModule(forge) {
|
|
|
|
var sha1 = forge.sha1 = forge.sha1 || {};
|
|
forge.md = forge.md || {};
|
|
forge.md.algorithms = forge.md.algorithms || {};
|
|
forge.md.sha1 = forge.md.algorithms['sha1'] = sha1;
|
|
|
|
// sha-1 padding bytes not initialized yet
|
|
var _padding = null;
|
|
var _initialized = false;
|
|
|
|
/**
|
|
* Initializes the constant tables.
|
|
*/
|
|
var _init = function() {
|
|
// create padding
|
|
_padding = String.fromCharCode(128);
|
|
_padding += forge.util.fillString(String.fromCharCode(0x00), 64);
|
|
|
|
// now initialized
|
|
_initialized = true;
|
|
};
|
|
|
|
/**
|
|
* Updates a SHA-1 state with the given byte buffer.
|
|
*
|
|
* @param s the SHA-1 state to update.
|
|
* @param w the array to use to store words.
|
|
* @param bytes the byte buffer to update with.
|
|
*/
|
|
var _update = function(s, w, bytes) {
|
|
// consume 512 bit (64 byte) chunks
|
|
var t, a, b, c, d, e, f, i;
|
|
var len = bytes.length();
|
|
while(len >= 64) {
|
|
// the w array will be populated with sixteen 32-bit big-endian words
|
|
// and then extended into 80 32-bit words according to SHA-1 algorithm
|
|
// and for 32-79 using Max Locktyukhin's optimization
|
|
|
|
// initialize hash value for this chunk
|
|
a = s.h0;
|
|
b = s.h1;
|
|
c = s.h2;
|
|
d = s.h3;
|
|
e = s.h4;
|
|
|
|
// round 1
|
|
for(i = 0; i < 16; ++i) {
|
|
t = bytes.getInt32();
|
|
w[i] = t;
|
|
f = d ^ (b & (c ^ d));
|
|
t = ((a << 5) | (a >>> 27)) + f + e + 0x5A827999 + t;
|
|
e = d;
|
|
d = c;
|
|
c = (b << 30) | (b >>> 2);
|
|
b = a;
|
|
a = t;
|
|
}
|
|
for(; i < 20; ++i) {
|
|
t = (w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]);
|
|
t = (t << 1) | (t >>> 31);
|
|
w[i] = t;
|
|
f = d ^ (b & (c ^ d));
|
|
t = ((a << 5) | (a >>> 27)) + f + e + 0x5A827999 + t;
|
|
e = d;
|
|
d = c;
|
|
c = (b << 30) | (b >>> 2);
|
|
b = a;
|
|
a = t;
|
|
}
|
|
// round 2
|
|
for(; i < 32; ++i) {
|
|
t = (w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]);
|
|
t = (t << 1) | (t >>> 31);
|
|
w[i] = t;
|
|
f = b ^ c ^ d;
|
|
t = ((a << 5) | (a >>> 27)) + f + e + 0x6ED9EBA1 + t;
|
|
e = d;
|
|
d = c;
|
|
c = (b << 30) | (b >>> 2);
|
|
b = a;
|
|
a = t;
|
|
}
|
|
for(; i < 40; ++i) {
|
|
t = (w[i - 6] ^ w[i - 16] ^ w[i - 28] ^ w[i - 32]);
|
|
t = (t << 2) | (t >>> 30);
|
|
w[i] = t;
|
|
f = b ^ c ^ d;
|
|
t = ((a << 5) | (a >>> 27)) + f + e + 0x6ED9EBA1 + t;
|
|
e = d;
|
|
d = c;
|
|
c = (b << 30) | (b >>> 2);
|
|
b = a;
|
|
a = t;
|
|
}
|
|
// round 3
|
|
for(; i < 60; ++i) {
|
|
t = (w[i - 6] ^ w[i - 16] ^ w[i - 28] ^ w[i - 32]);
|
|
t = (t << 2) | (t >>> 30);
|
|
w[i] = t;
|
|
f = (b & c) | (d & (b ^ c));
|
|
t = ((a << 5) | (a >>> 27)) + f + e + 0x8F1BBCDC + t;
|
|
e = d;
|
|
d = c;
|
|
c = (b << 30) | (b >>> 2);
|
|
b = a;
|
|
a = t;
|
|
}
|
|
// round 4
|
|
for(; i < 80; ++i) {
|
|
t = (w[i - 6] ^ w[i - 16] ^ w[i - 28] ^ w[i - 32]);
|
|
t = (t << 2) | (t >>> 30);
|
|
w[i] = t;
|
|
f = b ^ c ^ d;
|
|
t = ((a << 5) | (a >>> 27)) + f + e + 0xCA62C1D6 + t;
|
|
e = d;
|
|
d = c;
|
|
c = (b << 30) | (b >>> 2);
|
|
b = a;
|
|
a = t;
|
|
}
|
|
|
|
// update hash state
|
|
s.h0 += a;
|
|
s.h1 += b;
|
|
s.h2 += c;
|
|
s.h3 += d;
|
|
s.h4 += e;
|
|
|
|
len -= 64;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Creates a SHA-1 message digest object.
|
|
*
|
|
* @return a message digest object.
|
|
*/
|
|
sha1.create = function() {
|
|
// do initialization as necessary
|
|
if(!_initialized) {
|
|
_init();
|
|
}
|
|
|
|
// SHA-1 state contains five 32-bit integers
|
|
var _state = null;
|
|
|
|
// input buffer
|
|
var _input = forge.util.createBuffer();
|
|
|
|
// used for word storage
|
|
var _w = new Array(80);
|
|
|
|
// message digest object
|
|
var md = {
|
|
algorithm: 'sha1',
|
|
blockLength: 64,
|
|
digestLength: 20,
|
|
// length of message so far (does not including padding)
|
|
messageLength: 0
|
|
};
|
|
|
|
/**
|
|
* Starts the digest.
|
|
*/
|
|
md.start = function() {
|
|
md.messageLength = 0;
|
|
_input = forge.util.createBuffer();
|
|
_state = {
|
|
h0: 0x67452301,
|
|
h1: 0xEFCDAB89,
|
|
h2: 0x98BADCFE,
|
|
h3: 0x10325476,
|
|
h4: 0xC3D2E1F0
|
|
};
|
|
};
|
|
// start digest automatically for first time
|
|
md.start();
|
|
|
|
/**
|
|
* Updates the digest with the given message input. The given input can
|
|
* treated as raw input (no encoding will be applied) or an encoding of
|
|
* 'utf8' maybe given to encode the input using UTF-8.
|
|
*
|
|
* @param msg the message input to update with.
|
|
* @param encoding the encoding to use (default: 'raw', other: 'utf8').
|
|
*/
|
|
md.update = function(msg, encoding) {
|
|
if(encoding === 'utf8') {
|
|
msg = forge.util.encodeUtf8(msg);
|
|
}
|
|
|
|
// update message length
|
|
md.messageLength += msg.length;
|
|
|
|
// add bytes to input buffer
|
|
_input.putBytes(msg);
|
|
|
|
// process bytes
|
|
_update(_state, _w, _input);
|
|
|
|
// compact input buffer every 2K or if empty
|
|
if(_input.read > 2048 || _input.length() === 0) {
|
|
_input.compact();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Produces the digest.
|
|
*
|
|
* @return a byte buffer containing the digest value.
|
|
*/
|
|
md.digest = function() {
|
|
/* Note: Here we copy the remaining bytes in the input buffer and
|
|
add the appropriate SHA-1 padding. Then we do the final update
|
|
on a copy of the state so that if the user wants to get
|
|
intermediate digests they can do so. */
|
|
|
|
/* Determine the number of bytes that must be added to the message
|
|
to ensure its length is congruent to 448 mod 512. In other words,
|
|
a 64-bit integer that gives the length of the message will be
|
|
appended to the message and whatever the length of the message is
|
|
plus 64 bits must be a multiple of 512. So the length of the
|
|
message must be congruent to 448 mod 512 because 512 - 64 = 448.
|
|
|
|
In order to fill up the message length it must be filled with
|
|
padding that begins with 1 bit followed by all 0 bits. Padding
|
|
must *always* be present, so if the message length is already
|
|
congruent to 448 mod 512, then 512 padding bits must be added. */
|
|
|
|
// 512 bits == 64 bytes, 448 bits == 56 bytes, 64 bits = 8 bytes
|
|
// _padding starts with 1 byte with first bit is set in it which
|
|
// is byte value 128, then there may be up to 63 other pad bytes
|
|
var len = md.messageLength;
|
|
var padBytes = forge.util.createBuffer();
|
|
padBytes.putBytes(_input.bytes());
|
|
padBytes.putBytes(_padding.substr(0, 64 - ((len + 8) % 64)));
|
|
|
|
/* Now append length of the message. The length is appended in bits
|
|
as a 64-bit number in big-endian order. Since we store the length
|
|
in bytes, we must multiply it by 8 (or left shift by 3). So here
|
|
store the high 3 bits in the low end of the first 32-bits of the
|
|
64-bit number and the lower 5 bits in the high end of the second
|
|
32-bits. */
|
|
padBytes.putInt32((len >>> 29) & 0xFF);
|
|
padBytes.putInt32((len << 3) & 0xFFFFFFFF);
|
|
var s2 = {
|
|
h0: _state.h0,
|
|
h1: _state.h1,
|
|
h2: _state.h2,
|
|
h3: _state.h3,
|
|
h4: _state.h4
|
|
};
|
|
_update(s2, _w, padBytes);
|
|
var rval = forge.util.createBuffer();
|
|
rval.putInt32(s2.h0);
|
|
rval.putInt32(s2.h1);
|
|
rval.putInt32(s2.h2);
|
|
rval.putInt32(s2.h3);
|
|
rval.putInt32(s2.h4);
|
|
return rval;
|
|
};
|
|
|
|
return md;
|
|
};
|
|
|
|
} // end module implementation
|
|
|
|
/* ########## Begin module wrapper ########## */
|
|
var name = 'sha1';
|
|
var deps = ['./util'];
|
|
var nodeDefine = null;
|
|
if(typeof define !== 'function') {
|
|
// NodeJS -> AMD
|
|
if(typeof module === 'object' && module.exports) {
|
|
nodeDefine = function(ids, factory) {
|
|
factory(require, module);
|
|
};
|
|
}
|
|
// <script>
|
|
else {
|
|
if(typeof forge === 'undefined') {
|
|
forge = {};
|
|
}
|
|
initModule(forge);
|
|
}
|
|
}
|
|
// AMD
|
|
if(nodeDefine || typeof define === 'function') {
|
|
// define module AMD style
|
|
(nodeDefine || define)(['require', 'module'].concat(deps),
|
|
function(require, module) {
|
|
module.exports = function(forge) {
|
|
var mods = deps.map(function(dep) {
|
|
return require(dep);
|
|
}).concat(initModule);
|
|
// handle circular dependencies
|
|
forge = forge || {};
|
|
forge.defined = forge.defined || {};
|
|
if(forge.defined[name]) {
|
|
return forge[name];
|
|
}
|
|
forge.defined[name] = true;
|
|
for(var i = 0; i < mods.length; ++i) {
|
|
mods[i](forge);
|
|
}
|
|
return forge[name];
|
|
};
|
|
});
|
|
}
|
|
})();
|