]>
git.proxmox.com Git - mirror_ovs.git/blob - lib/sha1.c
2 * This file is from the Apache Portable Runtime Library.
3 * The full upstream copyright and license statement is included below.
4 * Modifications copyright (c) 2009 Nicira Networks.
7 /* Licensed to the Apache Software Foundation (ASF) under one or more
8 * contributor license agreements. See the NOTICE file distributed with
9 * this work for additional information regarding copyright ownership.
10 * The ASF licenses this file to You under the Apache License, Version 2.0
11 * (the "License"); you may not use this file except in compliance with
12 * the License. You may obtain a copy of the License at
14 * http://www.apache.org/licenses/LICENSE-2.0
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
23 /* This software also makes use of the following component:
25 * NIST Secure Hash Algorithm
26 * heavily modified by Uwe Hollerbach uh@alumni.caltech edu
27 * from Peter C. Gutmann's implementation as found in
28 * Applied Cryptography by Bruce Schneier
29 * This code is hereby placed in the public domain
38 /* a bit faster & bigger, if defined */
41 /* SHA f()-functions */
42 static inline uint32_t
43 f1(uint32_t x
, uint32_t y
, uint32_t z
)
45 return (x
& y
) | (~x
& z
);
48 static inline uint32_t
49 f2(uint32_t x
, uint32_t y
, uint32_t z
)
54 static inline uint32_t
55 f3(uint32_t x
, uint32_t y
, uint32_t z
)
57 return (x
& y
) | (x
& z
) | (y
& z
);
60 static inline uint32_t
61 f4(uint32_t x
, uint32_t y
, uint32_t z
)
67 #define CONST1 0x5a827999L
68 #define CONST2 0x6ed9eba1L
69 #define CONST3 0x8f1bbcdcL
70 #define CONST4 0xca62c1d6L
73 static inline uint32_t
74 rotate32(uint32_t x
, int n
)
76 return ((x
<< n
) | (x
>> (32 - n
)));
81 temp = rotate32(A, 5) + f##n(B, C, D) + E + W[i] + CONST##n; \
84 C = rotate32(B, 30); \
89 #define SHA_BLOCK_SIZE 64
91 /* Do SHA transformation. */
93 sha_transform(struct sha1_ctx
*sha_info
)
96 uint32_t temp
, A
, B
, C
, D
, E
, W
[80];
98 for (i
= 0; i
< 16; ++i
) {
99 W
[i
] = sha_info
->data
[i
];
101 for (i
= 16; i
< 80; ++i
) {
102 W
[i
] = W
[i
-3] ^ W
[i
-8] ^ W
[i
-14] ^ W
[i
-16];
103 W
[i
] = rotate32(W
[i
], 1);
105 A
= sha_info
->digest
[0];
106 B
= sha_info
->digest
[1];
107 C
= sha_info
->digest
[2];
108 D
= sha_info
->digest
[3];
109 E
= sha_info
->digest
[4];
111 FUNC(1, 0); FUNC(1, 1); FUNC(1, 2); FUNC(1, 3); FUNC(1, 4);
112 FUNC(1, 5); FUNC(1, 6); FUNC(1, 7); FUNC(1, 8); FUNC(1, 9);
113 FUNC(1,10); FUNC(1,11); FUNC(1,12); FUNC(1,13); FUNC(1,14);
114 FUNC(1,15); FUNC(1,16); FUNC(1,17); FUNC(1,18); FUNC(1,19);
116 FUNC(2,20); FUNC(2,21); FUNC(2,22); FUNC(2,23); FUNC(2,24);
117 FUNC(2,25); FUNC(2,26); FUNC(2,27); FUNC(2,28); FUNC(2,29);
118 FUNC(2,30); FUNC(2,31); FUNC(2,32); FUNC(2,33); FUNC(2,34);
119 FUNC(2,35); FUNC(2,36); FUNC(2,37); FUNC(2,38); FUNC(2,39);
121 FUNC(3,40); FUNC(3,41); FUNC(3,42); FUNC(3,43); FUNC(3,44);
122 FUNC(3,45); FUNC(3,46); FUNC(3,47); FUNC(3,48); FUNC(3,49);
123 FUNC(3,50); FUNC(3,51); FUNC(3,52); FUNC(3,53); FUNC(3,54);
124 FUNC(3,55); FUNC(3,56); FUNC(3,57); FUNC(3,58); FUNC(3,59);
126 FUNC(4,60); FUNC(4,61); FUNC(4,62); FUNC(4,63); FUNC(4,64);
127 FUNC(4,65); FUNC(4,66); FUNC(4,67); FUNC(4,68); FUNC(4,69);
128 FUNC(4,70); FUNC(4,71); FUNC(4,72); FUNC(4,73); FUNC(4,74);
129 FUNC(4,75); FUNC(4,76); FUNC(4,77); FUNC(4,78); FUNC(4,79);
130 #else /* !UNROLL_LOOPS */
131 for (i
= 0; i
< 20; ++i
) {
134 for (i
= 20; i
< 40; ++i
) {
137 for (i
= 40; i
< 60; ++i
) {
140 for (i
= 60; i
< 80; ++i
) {
143 #endif /* !UNROLL_LOOPS */
144 sha_info
->digest
[0] += A
;
145 sha_info
->digest
[1] += B
;
146 sha_info
->digest
[2] += C
;
147 sha_info
->digest
[3] += D
;
148 sha_info
->digest
[4] += E
;
151 /* 'count' is the number of bytes to do an endian flip. */
153 maybe_byte_reverse(uint32_t *buffer
, int count
)
159 count
/= sizeof(uint32_t);
160 cp
= (uint8_t *) buffer
;
161 for (i
= 0; i
< count
; i
++) {
170 cp
+= sizeof(uint32_t);
176 * Initialize the SHA digest.
177 * context: The SHA context to initialize
180 sha1_init(struct sha1_ctx
*sha_info
)
182 sha_info
->digest
[0] = 0x67452301L
;
183 sha_info
->digest
[1] = 0xefcdab89L
;
184 sha_info
->digest
[2] = 0x98badcfeL
;
185 sha_info
->digest
[3] = 0x10325476L
;
186 sha_info
->digest
[4] = 0xc3d2e1f0L
;
187 sha_info
->count_lo
= 0L;
188 sha_info
->count_hi
= 0L;
193 * Update the SHA digest.
194 * context: The SHA1 context to update.
195 * input: The buffer to add to the SHA digest.
196 * inputLen: The length of the input buffer.
199 sha1_update(struct sha1_ctx
*ctx
, const void *buffer_
, size_t count
)
201 const uint8_t *buffer
= buffer_
;
204 if ((ctx
->count_lo
+ (count
<< 3)) < ctx
->count_lo
) {
207 ctx
->count_lo
+= count
<< 3;
208 ctx
->count_hi
+= count
>> 29;
210 i
= SHA_BLOCK_SIZE
- ctx
->local
;
214 memcpy(((uint8_t *) ctx
->data
) + ctx
->local
, buffer
, i
);
218 if (ctx
->local
== SHA_BLOCK_SIZE
) {
219 maybe_byte_reverse(ctx
->data
, SHA_BLOCK_SIZE
);
225 while (count
>= SHA_BLOCK_SIZE
) {
226 memcpy(ctx
->data
, buffer
, SHA_BLOCK_SIZE
);
227 buffer
+= SHA_BLOCK_SIZE
;
228 count
-= SHA_BLOCK_SIZE
;
229 maybe_byte_reverse(ctx
->data
, SHA_BLOCK_SIZE
);
232 memcpy(ctx
->data
, buffer
, count
);
237 * Finish computing the SHA digest.
238 * digest: the output buffer in which to store the digest.
239 * context: The context to finalize.
242 sha1_final(struct sha1_ctx
*ctx
, uint8_t digest
[SHA1_DIGEST_SIZE
])
245 uint32_t lo_bit_count
, hi_bit_count
, k
;
247 lo_bit_count
= ctx
->count_lo
;
248 hi_bit_count
= ctx
->count_hi
;
249 count
= (int) ((lo_bit_count
>> 3) & 0x3f);
250 ((uint8_t *) ctx
->data
)[count
++] = 0x80;
251 if (count
> SHA_BLOCK_SIZE
- 8) {
252 memset(((uint8_t *) ctx
->data
) + count
, 0, SHA_BLOCK_SIZE
- count
);
253 maybe_byte_reverse(ctx
->data
, SHA_BLOCK_SIZE
);
255 memset((uint8_t *) ctx
->data
, 0, SHA_BLOCK_SIZE
- 8);
257 memset(((uint8_t *) ctx
->data
) + count
, 0,
258 SHA_BLOCK_SIZE
- 8 - count
);
260 maybe_byte_reverse(ctx
->data
, SHA_BLOCK_SIZE
);
261 ctx
->data
[14] = hi_bit_count
;
262 ctx
->data
[15] = lo_bit_count
;
265 for (i
= j
= 0; j
< SHA1_DIGEST_SIZE
; i
++) {
267 digest
[j
++] = k
>> 24;
268 digest
[j
++] = k
>> 16;
269 digest
[j
++] = k
>> 8;
274 /* Computes the hash of 'n' bytes in 'data' into 'digest'. */
276 sha1_bytes(const void *data
, size_t n
, uint8_t digest
[SHA1_DIGEST_SIZE
])
281 sha1_update(&ctx
, data
, n
);
282 sha1_final(&ctx
, digest
);
286 sha1_to_hex(const uint8_t digest
[SHA1_DIGEST_SIZE
],
287 char hex
[SHA1_HEX_DIGEST_LEN
+ 1])
291 for (i
= 0; i
< SHA1_DIGEST_SIZE
; i
++) {
292 *hex
++ = "0123456789abcdef"[digest
[i
] >> 4];
293 *hex
++ = "0123456789abcdef"[digest
[i
] & 15];
299 sha1_from_hex(uint8_t digest
[SHA1_DIGEST_SIZE
], const char *hex
)
303 for (i
= 0; i
< SHA1_DIGEST_SIZE
; i
++) {
304 if (!isxdigit(hex
[0]) || !isxdigit(hex
[1])) {
307 digest
[i
] = (hexit_value(hex
[0]) << 4) | hexit_value(hex
[1]);