/*//////////////////////////////////////////////////////////////////////////
* THIS PROGRAM IS A DERIVATIVE OF AN EXISTING WORK :: 7 September 2010
* See: http://pajhome.org.uk/crypt/md5/scripts.html
*
* Significant but mostly superficial changes have been made to the structure of the
* source so that it conforms to the Joose3 object system for JavaScript
* See: http://joose.it/
/*//////////////////////////////////////////////////////////////////////////
Joose.Class('Hash.RIPEMD160', {
/*VERSION*/VERSION : 0.06,
my : {
has : {
rmd160_r1 : {
is : 'ro',
init : [
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
]
},
rmd160_r2 : {
is : 'ro',
init : [
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
]
},
rmd160_s1 : {
is : 'ro',
init : [
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
]
},
rmd160_s2 : {
is : 'ro',
init : [
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
]
},
},
methods : {
/*
* These are the functions you'll usually want to call
* They take string arguments and return either hex or base-64 encoded strings
*/
hex_rmd160 : function (s) { return Encode.rstr2hex(this.rstr_rmd160(Encode.str2rstr_utf8(s))) },
b64_rmd160 : function (s) { return Encode.rstr2b64(this.rstr_rmd160(Encode.str2rstr_utf8(s))) },
any_rmd160 : function (s, e) { return Encode.rstr2any(this.rstr_rmd160(Encode.str2rstr_utf8(s)), e) },
hex_hmac_rmd160 : function (k, d) { return Encode.rstr2hex(this.rstr_hmac_rmd160(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d))) },
b64_hmac_rmd160 : function (k, d) { return Encode.rstr2b64(this.rstr_hmac_rmd160(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d))) },
any_hmac_rmd160 : function (k, d, e) { return Encode.rstr2any(this.rstr_hmac_rmd160(Encode.str2rstr_utf8(k), Encode.str2rstr_utf8(d)), e) },
/*
* Perform a simple self-test to see if the VM is working
*/
rmd160_vm_test : function () {
return this.hex_rmd160('abc').toLowerCase() == '8eb208f7e05d987a9b044a8e98c6b087f15a0bfc'
},
/*
* Calculate the rmd160 of a raw string
*/
rstr_rmd160 : function (s) {
return Encode.binl2rstr(this.binl_rmd160(Encode.rstr2binl(s), s.length * 8))
},
/*
* Calculate the HMAC-rmd160 of a key and some data (raw strings)
*/
rstr_hmac_rmd160 : function (key, data) {
var bkey = Encode.rstr2binl(key)
if(bkey.length > 16) bkey = this.binl_rmd160(bkey, key.length * 8)
var ipad = Array(16), opad = Array(16)
for(var i = 0; i < 16; i++) {
ipad[i] = bkey[i] ^ 0x36363636
opad[i] = bkey[i] ^ 0x5C5C5C5C
}
var hash = this.binl_rmd160(ipad.concat(rstr2binl(data)), 512 + data.length * 8)
return Encode.binl2rstr(this.binl_rmd160(opad.concat(hash), 512 + 160))
},
/*
* Calculate the RIPE-MD160 of an array of little-endian words, and a bit length.
*/
binl_rmd160 : function (x, len) {
/* 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 = this.safe_add(A1, this.rmd160_f(j, B1, C1, D1))
T = this.safe_add(T, x[i + this.getRmd160_r1()[j]])
T = this.safe_add(T, this.rmd160_K1(j))
T = this.safe_add(this.bit_rol(T, this.getRmd160_s1()[j]), E1)
A1 = E1
E1 = D1
D1 = this.bit_rol(C1, 10)
C1 = B1
B1 = T
T = this.safe_add(A2, this.rmd160_f(79-j, B2, C2, D2))
T = this.safe_add(T, x[i + this.getRmd160_r2()[j]])
T = this.safe_add(T, this.rmd160_K2(j))
T = this.safe_add(this.bit_rol(T, this.getRmd160_s2()[j]), E2)
A2 = E2
E2 = D2
D2 = this.bit_rol(C2, 10)
C2 = B2
B2 = T
}
T = this.safe_add(h1, this.safe_add(C1, D2))
h1 = this.safe_add(h2, this.safe_add(D1, E2))
h2 = this.safe_add(h3, this.safe_add(E1, A2))
h3 = this.safe_add(h4, this.safe_add(A1, B2))
h4 = this.safe_add(h0, this.safe_add(B1, C2))
h0 = T
}
return [h0, h1, h2, h3, h4]
},
rmd160_f : function (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'
},
rmd160_K1 : function (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'
},
rmd160_K2 : function (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'
},
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
safe_add : function (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.
*/
bit_rol : function (num, cnt) {
return (num << cnt) | (num >>> (32 - cnt))
}
}
}
})
/*///////////////////// ORIGINAL LICENSE BELOW ////////////////////////////////
* 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
* All rights reserved.
*
* See http://pajhome.org.uk/crypt/md5 for details.
* Also http://www.ocf.berkeley.edu/~jjlin/jsotp/
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the <ORGANIZATION> nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
/*///////////////////////////////////////////////////////////////////////////