WebSVN – corrade-nucleus-nucleons – Blame – Rev 22 – /base/000_base/node

22

office

1

/**

2

* Message Digest Algorithm 5 with 128-bit digest (MD5) implementation.

3

*

4

* @author Dave Longley

*

*/

var forge = require('./forge');

require('./md');

require('./util');

var md5 = module.exports = forge.md5 = forge.md5 || {};

13

forge.md.md5 = forge.md.algorithms.md5 = md5;

14

15

/**

16

* Creates an MD5 message digest object.

17

*

18

* @return a message digest object.

19

*/

20

md5.create = function() {

21

// do initialization as necessary

22

if(!_initialized) {

_init();

}

// MD5 state contains four 32-bit integers

var _state = null;

// input buffer

var _input = forge.util.createBuffer();

31

32

// used for word storage

33

var _w = new Array(16);

34

35

// message digest object

var md = {

algorithm: 'md5',

blockLength: 64,

digestLength: 16,

// 56-bit length of message so far (does not including padding)

41

messageLength: 0,

42

// true message length

43

fullMessageLength: null,

44

// size of message length in bytes

45

messageLengthSize: 8

};

/**

* Starts the digest.

50

*

51

* @return this digest object.

52

*/

53

md.start = function() {

54

// up to 56-bit message length for convenience

55

md.messageLength = 0;

56

57

// full message length (set md.messageLength64 for backwards-compatibility)

58

md.fullMessageLength = md.messageLength64 = [];

59

var int32s = md.messageLengthSize / 4;

60

for(var i = 0; i < int32s; ++i) {

61

< int32s; ++i) { md.fullMessageLength.push(0);

62

< int32s; ++i) { }

63

< int32s; ++i) { _input = forge.util.createBuffer();

64

< int32s; ++i) { _state = {

65

< int32s; ++i) { h0: 0x67452301,

66

< int32s; ++i) { h1: 0xEFCDAB89,

67

< int32s; ++i) { h2: 0x98BADCFE,

68

< int32s; ++i) { h3: 0x10325476

69

< int32s; ++i) { };

70

< int32s; ++i) { return md;

71

< int32s; ++i) { };

72

< int32s; ++i) { // start digest automatically for first time

73

< int32s; ++i) { md.start();

74

75

< int32s; ++i) { /**

76

< int32s; ++i) { * Updates the digest with the given message input. The given input can

77

< int32s; ++i) { * treated as raw input (no encoding will be applied) or an encoding of

78

< int32s; ++i) { * 'utf8' maybe given to encode the input using UTF-8.

79

< int32s; ++i) { *

80

< int32s; ++i) { * @param msg the message input to update with.

81

< int32s; ++i) { * @param encoding the encoding to use (default: 'raw', other: 'utf8').

82

< int32s; ++i) { *

83

< int32s; ++i) { * @return this digest object.

84

< int32s; ++i) { */

85

< int32s; ++i) { md.update = function(msg, encoding) {

86

< int32s; ++i) { if(encoding === 'utf8') {

87

< int32s; ++i) { msg = forge.util.encodeUtf8(msg);

88

< int32s; ++i) { }

89

90

< int32s; ++i) { // update message length

91

< int32s; ++i) { var len = msg.length;

92

< int32s; ++i) { md.messageLength += len;

93

< int32s; ++i) { len = [(len / 0x100000000) >>> 0, len >>> 0];

94

< int32s; ++i) { for(var i = md.fullMessageLength.length - 1; i >= 0; --i) {

95

< int32s; ++i) { md.fullMessageLength[i] += len[1];

96

< int32s; ++i) { len[1] = len[0] + ((md.fullMessageLength[i] / 0x100000000) >>> 0);

97

< int32s; ++i) { md.fullMessageLength[i] = md.fullMessageLength[i] >>> 0;

98

< int32s; ++i) { len[0] = (len[1] / 0x100000000) >>> 0;

99

< int32s; ++i) { }

100

101

< int32s; ++i) { // add bytes to input buffer

102

< int32s; ++i) { _input.putBytes(msg);

103

104

< int32s; ++i) { // process bytes

105

< int32s; ++i) { _update(_state, _w, _input);

106

107

< int32s; ++i) { // compact input buffer every 2K or if empty

108

< int32s; ++i) { if(_input.read > 2048 || _input.length() === 0) {

109

< int32s; ++i) { _input.compact();

110

< int32s; ++i) { }

111

112

< int32s; ++i) { return md;

113

< int32s; ++i) { };

114

115

< int32s; ++i) { /**

116

< int32s; ++i) { * Produces the digest.

117

< int32s; ++i) { *

118

< int32s; ++i) { * @return a byte buffer containing the digest value.

119

< int32s; ++i) { */

120

< int32s; ++i) { md.digest = function() {

121

< int32s; ++i) { /* Note: Here we copy the remaining bytes in the input buffer and

122

< int32s; ++i) { add the appropriate MD5 padding. Then we do the final update

123

< int32s; ++i) { on a copy of the state so that if the user wants to get

124

< int32s; ++i) { intermediate digests they can do so. */

125

126

< int32s; ++i) { /* Determine the number of bytes that must be added to the message

127

< int32s; ++i) { to ensure its length is congruent to 448 mod 512. In other words,

128

< int32s; ++i) { the data to be digested must be a multiple of 512 bits (or 128 bytes).

129

< int32s; ++i) { This data includes the message, some padding, and the length of the

130

< int32s; ++i) { message. Since the length of the message will be encoded as 8 bytes (64

131

< int32s; ++i) { bits), that means that the last segment of the data must have 56 bytes

132

< int32s; ++i) { (448 bits) of message and padding. Therefore, the length of the message

133

< int32s; ++i) { plus the padding must be congruent to 448 mod 512 because

134

< int32s; ++i) { 512 - 128 = 448.

135

136

< int32s; ++i) { In order to fill up the message length it must be filled with

137

< int32s; ++i) { padding that begins with 1 bit followed by all 0 bits. Padding

138

< int32s; ++i) { must *always* be present, so if the message length is already

139

< int32s; ++i) { congruent to 448 mod 512, then 512 padding bits must be added. */

140

141

< int32s; ++i) { var finalBlock = forge.util.createBuffer();

142

< int32s; ++i) { finalBlock.putBytes(_input.bytes());

143

144

< int32s; ++i) { // compute remaining size to be digested (include message length size)

145

< int32s; ++i) { var remaining = (

146

< int32s; ++i) { md.fullMessageLength[md.fullMessageLength.length - 1] +

147

< int32s; ++i) { md.messageLengthSize);

148

149

< int32s; ++i) { // add padding for overflow blockSize - overflow

150

< int32s; ++i) { // _padding starts with 1 byte with first bit is set (byte value 128), then

151

< int32s; ++i) { // there may be up to (blockSize - 1) other pad bytes

152

< int32s; ++i) { var overflow = remaining & (md.blockLength - 1);

153

< int32s; ++i) { finalBlock.putBytes(_padding.substr(0, md.blockLength - overflow));

154

155

< int32s; ++i) { // serialize message length in bits in little-endian order; since length

156

< int32s; ++i) { // is stored in bytes we multiply by 8 and add carry

157

< int32s; ++i) { var bits, carry = 0;

158

< int32s; ++i) { for(var i = md.fullMessageLength.length - 1; i >= 0; --i) {

159

< int32s; ++i) { bits = md.fullMessageLength[i] * 8 + carry;

160

< int32s; ++i) { carry = (bits / 0x100000000) >>> 0;

161

< int32s; ++i) { finalBlock.putInt32Le(bits >>> 0);

162

< int32s; ++i) { }

163

164

< int32s; ++i) { var s2 = {

165

< int32s; ++i) { h0: _state.h0,

166

< int32s; ++i) { h1: _state.h1,

167

< int32s; ++i) { h2: _state.h2,

168

< int32s; ++i) { h3: _state.h3

169

< int32s; ++i) { };

170

< int32s; ++i) { _update(s2, _w, finalBlock);

171

< int32s; ++i) { var rval = forge.util.createBuffer();

172

< int32s; ++i) { rval.putInt32Le(s2.h0);

173

< int32s; ++i) { rval.putInt32Le(s2.h1);

174

< int32s; ++i) { rval.putInt32Le(s2.h2);

175

< int32s; ++i) { rval.putInt32Le(s2.h3);

176

< int32s; ++i) { return rval;

177

< int32s; ++i) { };

178

179

< int32s; ++i) { return md;

180

< int32s; ++i) {};

181

182

< int32s; ++i) {// padding, constant tables for calculating md5

183

< int32s; ++i) {var _padding = null;

184

< int32s; ++i) {var _g = null;

185

< int32s; ++i) {var _r = null;

186

< int32s; ++i) {var _k = null;

187

< int32s; ++i) {var _initialized = false;

188

189

< int32s; ++i) {/**

190

< int32s; ++i) { * Initializes the constant tables.

191

< int32s; ++i) { */

192

< int32s; ++i) {function _init() {

193

< int32s; ++i) { // create padding

194

< int32s; ++i) { _padding = String.fromCharCode(128);

195

< int32s; ++i) { _padding += forge.util.fillString(String.fromCharCode(0x00), 64);

196

197

< int32s; ++i) { // g values

198

< int32s; ++i) { _g = [

199

< int32s; ++i) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,

200

< int32s; ++i) { 1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12,

201

< int32s; ++i) { 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2,

202

< int32s; ++i) { 0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9];

203

204

< int32s; ++i) { // rounds table

205

< int32s; ++i) { _r = [

206

< int32s; ++i) { 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,

207

< int32s; ++i) { 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,

208

< int32s; ++i) { 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,

209

< int32s; ++i) { 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21];

210

211

< int32s; ++i) { // get the result of abs(sin(i + 1)) as a 32-bit integer

212

< int32s; ++i) { _k = new Array(64);

213

< int32s; ++i) { for(var i = 0; i < 64; ++i) {

214

< int32s; ++i) {< 64; ++i) { _k[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 0x100000000);

215

< int32s; ++i) {< 64; ++i) { }

216

217

< int32s; ++i) {< 64; ++i) { // now initialized

218

< int32s; ++i) {< 64; ++i) { _initialized = true;

219

< int32s; ++i) {< 64; ++i) {}

220

221

< int32s; ++i) {< 64; ++i) {/**

222

< int32s; ++i) {< 64; ++i) { * Updates an MD5 state with the given byte buffer.

223

< int32s; ++i) {< 64; ++i) { *

224

< int32s; ++i) {< 64; ++i) { * @param s the MD5 state to update.

225

< int32s; ++i) {< 64; ++i) { * @param w the array to use to store words.

226

< int32s; ++i) {< 64; ++i) { * @param bytes the byte buffer to update with.

227

< int32s; ++i) {< 64; ++i) { */

228

< int32s; ++i) {< 64; ++i) {function _update(s, w, bytes) {

229

< int32s; ++i) {< 64; ++i) { // consume 512 bit (64 byte) chunks

230

< int32s; ++i) {< 64; ++i) { var t, a, b, c, d, f, r, i;

231

< int32s; ++i) {< 64; ++i) { var len = bytes.length();

232

< int32s; ++i) {< 64; ++i) { while(len >= 64) {

233

< int32s; ++i) {< 64; ++i) { // initialize hash value for this chunk

234

< int32s; ++i) {< 64; ++i) { a = s.h0;

235

< int32s; ++i) {< 64; ++i) { b = s.h1;

236

< int32s; ++i) {< 64; ++i) { c = s.h2;

237

< int32s; ++i) {< 64; ++i) { d = s.h3;

238

239

< int32s; ++i) {< 64; ++i) { // round 1

240

< int32s; ++i) {< 64; ++i) { for(i = 0; i < 16; ++i) {

241

< int32s; ++i) {< 64; ++i) {< 16; ++i) { w[i] = bytes.getInt32Le();

242

< int32s; ++i) {< 64; ++i) {< 16; ++i) { f = d ^ (b & (c ^ d));

243

< int32s; ++i) {< 64; ++i) {< 16; ++i) { t = (a + f + _k[i] + w[i]);

244

< int32s; ++i) {< 64; ++i) {< 16; ++i) { r = _r[i];

245

< int32s; ++i) {< 64; ++i) {< 16; ++i) { a = d;

246

< int32s; ++i) {< 64; ++i) {< 16; ++i) { d = c;

247

< int32s; ++i) {< 64; ++i) {< 16; ++i) { c = b;

248

< int32s; ++i) {< 64; ++i) {< 16; ++i) { b += (t << r) | (t >>> (32 - r));

249

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t > }

250

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t > // round 2

251

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t > for(; i < 32; ++i) {

252

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) { f = c ^ (d & (b ^ c));

253

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) { t = (a + f + _k[i] + w[_g[i]]);

254

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) { r = _r[i];

255

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) { a = d;

256

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) { d = c;

257

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) { c = b;

258

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) { b += (t << r) | (t >>> (32 - r));

259

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t > }

260

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t > // round 3

261

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >    for(; i < 48; ++i) {

262

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {      f = b ^ c ^ d;

263

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {      t = (a + f + _k[i] + w[_g[i]]);

264

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {      r = _r[i];

265

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {      a = d;

266

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {      d = c;

267

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {      c = b;

268

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {      b += (t << r) | (t >>> (32 - r));

269

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >    }

270

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >    // round 4

271

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >    for(; i < 64; ++i) {

272

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {      f = c ^ (b | ~d);

273

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {      t = (a + f + _k[i] + w[_g[i]]);

274

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {      r = _r[i];

275

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {      a = d;

276

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {      d = c;

277

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {      c = b;

278

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {      b += (t << r) | (t >>> (32 - r));

279

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {<< r) | (t >< r) | (t >    }

280

281

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {<< r) | (t >< r) | (t >    // update hash state

282

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {<< r) | (t >< r) | (t >    s.h0 = (s.h0 + a) | 0;

283

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {<< r) | (t >< r) | (t >    s.h1 = (s.h1 + b) | 0;

284

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {<< r) | (t >< r) | (t >    s.h2 = (s.h2 + c) | 0;

285

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {<< r) | (t >< r) | (t >    s.h3 = (s.h3 + d) | 0;

286

287

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {<< r) | (t >< r) | (t >    len -= 64;

288

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {<< r) | (t >< r) | (t >  }

289

< int32s; ++i) {< 64; ++i) {< 16; ++i) {<< r) | (t >< r) | (t >< 32; ++i) {<< r) | (t >< r) | (t >< 48; ++i) {<< r) | (t >< r) | (t >< 64; ++i) {<< r) | (t >< r) | (t >}

corrade-nucleus-nucleons – Blame information for rev 22