1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
// HMAC_SHA1 implementation
//
// Copyright 2010 Google Inc.
// Author: Markus Gutschke
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <string.h>
#include "hmac.h"
#include "sha1.h"
void hmac_sha1(const uint8_t *key, int keyLength,
const uint8_t *data, int dataLength,
uint8_t *result, int resultLength) {
SHA1_INFO ctx;
uint8_t hashed_key[SHA1_DIGEST_LENGTH];
if (keyLength > 64) {
// The key can be no bigger than 64 bytes. If it is, we'll hash it down to
// 20 bytes.
sha1_init(&ctx);
sha1_update(&ctx, key, keyLength);
sha1_final(&ctx, hashed_key);
key = hashed_key;
keyLength = SHA1_DIGEST_LENGTH;
}
// The key for the inner digest is derived from our key, by padding the key
// the full length of 64 bytes, and then XOR'ing each byte with 0x36.
uint8_t tmp_key[64];
for (int i = 0; i < keyLength; ++i) {
tmp_key[i] = key[i] ^ 0x36;
}
memset(tmp_key + keyLength, 0x36, 64 - keyLength);
// Compute inner digest
sha1_init(&ctx);
sha1_update(&ctx, tmp_key, 64);
sha1_update(&ctx, data, dataLength);
uint8_t sha[SHA1_DIGEST_LENGTH];
sha1_final(&ctx, sha);
// The key for the outer digest is derived from our key, by padding the key
// the full length of 64 bytes, and then XOR'ing each byte with 0x5C.
for (int i = 0; i < keyLength; ++i) {
tmp_key[i] = key[i] ^ 0x5C;
}
memset(tmp_key + keyLength, 0x5C, 64 - keyLength);
// Compute outer digest
sha1_init(&ctx);
sha1_update(&ctx, tmp_key, 64);
sha1_update(&ctx, sha, SHA1_DIGEST_LENGTH);
sha1_final(&ctx, sha);
// Copy result to output buffer and truncate or pad as necessary
memset(result, 0, resultLength);
if (resultLength > SHA1_DIGEST_LENGTH) {
resultLength = SHA1_DIGEST_LENGTH;
}
memcpy(result, sha, resultLength);
// Zero out all internal data structures
memset(hashed_key, 0, sizeof(hashed_key));
memset(sha, 0, sizeof(sha));
memset(tmp_key, 0, sizeof(tmp_key));
}
|
