Debian Codegraph @

closure-library/closure/goog/crypt/hmac.js

raw
1 // Copyright 2011 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 /**
16 * @fileoverview Implementation of HMAC in JavaScript.
17 *
18 * Usage:
19 * var hmac = new goog.crypt.Hmac(new goog.crypt.sha1(), key, 64);
20 * var digest = hmac.getHmac(bytes);
21 *
22 * @author [email protected] (Jige Yu) - port to closure
23 */
24
25
26 goog.provide('goog.crypt.Hmac');
27
28 goog.require('goog.crypt.Hash');
29
30
31
32 /**
33 * @constructor
34 * @param {!goog.crypt.Hash} hasher An object to serve as a hash function.
35 * @param {Array<number>} key The secret key to use to calculate the hmac.
36 * Should be an array of not more than {@code blockSize} integers in
37 {0, 255}.
38 * @param {number=} opt_blockSize Optional. The block size {@code hasher} uses.
39 * If not specified, uses the block size from the hasher, or 16 if it is
40 * not specified.
41 * @extends {goog.crypt.Hash}
42 * @final
43 * @struct
44 */
45 goog.crypt.Hmac = function(hasher, key, opt_blockSize) {
46 goog.crypt.Hmac.base(this, 'constructor');
47
48 /**
49 * The underlying hasher to calculate hash.
50 *
51 * @type {!goog.crypt.Hash}
52 * @private
53 */
54 this.hasher_ = hasher;
55
56 this.blockSize = opt_blockSize || hasher.blockSize || 16;
57
58 /**
59 * The outer padding array of hmac
60 *
61 * @type {!Array<number>}
62 * @private
63 */
64 this.keyO_ = new Array(this.blockSize);
65
66 /**
67 * The inner padding array of hmac
68 *
69 * @type {!Array<number>}
70 * @private
71 */
72 this.keyI_ = new Array(this.blockSize);
73
74 this.initialize_(key);
75 };
76 goog.inherits(goog.crypt.Hmac, goog.crypt.Hash);
77
78
79 /**
80 * Outer padding byte of HMAC algorith, per http://en.wikipedia.org/wiki/HMAC
81 *
82 * @type {number}
83 * @private
84 */
85 goog.crypt.Hmac.OPAD_ = 0x5c;
86
87
88 /**
89 * Inner padding byte of HMAC algorith, per http://en.wikipedia.org/wiki/HMAC
90 *
91 * @type {number}
92 * @private
93 */
94 goog.crypt.Hmac.IPAD_ = 0x36;
95
96
97 /**
98 * Initializes Hmac by precalculating the inner and outer paddings.
99 *
100 * @param {Array<number>} key The secret key to use to calculate the hmac.
101 * Should be an array of not more than {@code blockSize} integers in
102 {0, 255}.
103 * @private
104 */
105 goog.crypt.Hmac.prototype.initialize_ = function(key) {
106 if (key.length > this.blockSize) {
107 this.hasher_.update(key);
108 key = this.hasher_.digest();
109 this.hasher_.reset();
110 }
111 // Precalculate padded and xor'd keys.
112 var keyByte;
113 for (var i = 0; i < this.blockSize; i++) {
114 if (i < key.length) {
115 keyByte = key[i];
116 } else {
117 keyByte = 0;
118 }
119 this.keyO_[i] = keyByte ^ goog.crypt.Hmac.OPAD_;
120 this.keyI_[i] = keyByte ^ goog.crypt.Hmac.IPAD_;
121 }
122 // Be ready for an immediate update.
123 this.hasher_.update(this.keyI_);
124 };
125
126
127 /** @override */
128 goog.crypt.Hmac.prototype.reset = function() {
129 this.hasher_.reset();
130 this.hasher_.update(this.keyI_);
131 };
132
133
134 /** @override */
135 goog.crypt.Hmac.prototype.update = function(bytes, opt_length) {
136 this.hasher_.update(bytes, opt_length);
137 };
138
139
140 /** @override */
141 goog.crypt.Hmac.prototype.digest = function() {
142 var temp = this.hasher_.digest();
143 this.hasher_.reset();
144 this.hasher_.update(this.keyO_);
145 this.hasher_.update(temp);
146 return this.hasher_.digest();
147 };
148
149
150 /**
151 * Calculates an HMAC for a given message.
152 *
153 * @param {Array<number>|Uint8Array|string} message Data to Hmac.
154 * @return {!Array<number>} the digest of the given message.
155 */
156 goog.crypt.Hmac.prototype.getHmac = function(message) {
157 this.reset();
158 this.update(message);
159 return this.digest();
160 };