]>
git.proxmox.com Git - mirror_ovs.git/blob - lib/sha1.c
f73f2d6477e28e32ceed79f2e57e78544bd6190e
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
36 /* a bit faster & bigger, if defined */
39 /* SHA f()-functions */
40 static inline uint32_t
41 f1(uint32_t x
, uint32_t y
, uint32_t z
)
43 return (x
& y
) | (~x
& z
);
46 static inline uint32_t
47 f2(uint32_t x
, uint32_t y
, uint32_t z
)
52 static inline uint32_t
53 f3(uint32_t x
, uint32_t y
, uint32_t z
)
55 return (x
& y
) | (x
& z
) | (y
& z
);
58 static inline uint32_t
59 f4(uint32_t x
, uint32_t y
, uint32_t z
)
65 #define CONST1 0x5a827999L
66 #define CONST2 0x6ed9eba1L
67 #define CONST3 0x8f1bbcdcL
68 #define CONST4 0xca62c1d6L
71 static inline uint32_t
72 rotate32(uint32_t x
, int n
)
74 return ((x
<< n
) | (x
>> (32 - n
)));
79 temp = rotate32(A, 5) + f##n(B, C, D) + E + W[i] + CONST##n; \
82 C = rotate32(B, 30); \
87 #define SHA_BLOCK_SIZE 64
89 /* Do SHA transformation. */
91 sha_transform(struct sha1_ctx
*sha_info
)
94 uint32_t temp
, A
, B
, C
, D
, E
, W
[80];
96 for (i
= 0; i
< 16; ++i
) {
97 W
[i
] = sha_info
->data
[i
];
99 for (i
= 16; i
< 80; ++i
) {
100 W
[i
] = W
[i
-3] ^ W
[i
-8] ^ W
[i
-14] ^ W
[i
-16];
101 W
[i
] = rotate32(W
[i
], 1);
103 A
= sha_info
->digest
[0];
104 B
= sha_info
->digest
[1];
105 C
= sha_info
->digest
[2];
106 D
= sha_info
->digest
[3];
107 E
= sha_info
->digest
[4];
109 FUNC(1, 0); FUNC(1, 1); FUNC(1, 2); FUNC(1, 3); FUNC(1, 4);
110 FUNC(1, 5); FUNC(1, 6); FUNC(1, 7); FUNC(1, 8); FUNC(1, 9);
111 FUNC(1,10); FUNC(1,11); FUNC(1,12); FUNC(1,13); FUNC(1,14);
112 FUNC(1,15); FUNC(1,16); FUNC(1,17); FUNC(1,18); FUNC(1,19);
114 FUNC(2,20); FUNC(2,21); FUNC(2,22); FUNC(2,23); FUNC(2,24);
115 FUNC(2,25); FUNC(2,26); FUNC(2,27); FUNC(2,28); FUNC(2,29);
116 FUNC(2,30); FUNC(2,31); FUNC(2,32); FUNC(2,33); FUNC(2,34);
117 FUNC(2,35); FUNC(2,36); FUNC(2,37); FUNC(2,38); FUNC(2,39);
119 FUNC(3,40); FUNC(3,41); FUNC(3,42); FUNC(3,43); FUNC(3,44);
120 FUNC(3,45); FUNC(3,46); FUNC(3,47); FUNC(3,48); FUNC(3,49);
121 FUNC(3,50); FUNC(3,51); FUNC(3,52); FUNC(3,53); FUNC(3,54);
122 FUNC(3,55); FUNC(3,56); FUNC(3,57); FUNC(3,58); FUNC(3,59);
124 FUNC(4,60); FUNC(4,61); FUNC(4,62); FUNC(4,63); FUNC(4,64);
125 FUNC(4,65); FUNC(4,66); FUNC(4,67); FUNC(4,68); FUNC(4,69);
126 FUNC(4,70); FUNC(4,71); FUNC(4,72); FUNC(4,73); FUNC(4,74);
127 FUNC(4,75); FUNC(4,76); FUNC(4,77); FUNC(4,78); FUNC(4,79);
128 #else /* !UNROLL_LOOPS */
129 for (i
= 0; i
< 20; ++i
) {
132 for (i
= 20; i
< 40; ++i
) {
135 for (i
= 40; i
< 60; ++i
) {
138 for (i
= 60; i
< 80; ++i
) {
141 #endif /* !UNROLL_LOOPS */
142 sha_info
->digest
[0] += A
;
143 sha_info
->digest
[1] += B
;
144 sha_info
->digest
[2] += C
;
145 sha_info
->digest
[3] += D
;
146 sha_info
->digest
[4] += E
;
149 /* 'count' is the number of bytes to do an endian flip. */
151 maybe_byte_reverse(uint32_t *buffer
, int count
)
157 count
/= sizeof(uint32_t);
158 cp
= (uint8_t *) buffer
;
159 for (i
= 0; i
< count
; i
++) {
168 cp
+= sizeof(uint32_t);
174 * Initialize the SHA digest.
175 * context: The SHA context to initialize
178 sha1_init(struct sha1_ctx
*sha_info
)
180 sha_info
->digest
[0] = 0x67452301L
;
181 sha_info
->digest
[1] = 0xefcdab89L
;
182 sha_info
->digest
[2] = 0x98badcfeL
;
183 sha_info
->digest
[3] = 0x10325476L
;
184 sha_info
->digest
[4] = 0xc3d2e1f0L
;
185 sha_info
->count_lo
= 0L;
186 sha_info
->count_hi
= 0L;
191 * Update the SHA digest.
192 * context: The SHA1 context to update.
193 * input: The buffer to add to the SHA digest.
194 * inputLen: The length of the input buffer.
197 sha1_update(struct sha1_ctx
*ctx
, const void *buffer_
, size_t count
)
199 const uint8_t *buffer
= buffer_
;
202 if ((ctx
->count_lo
+ (count
<< 3)) < ctx
->count_lo
) {
205 ctx
->count_lo
+= count
<< 3;
206 ctx
->count_hi
+= count
>> 29;
208 i
= SHA_BLOCK_SIZE
- ctx
->local
;
212 memcpy(((uint8_t *) ctx
->data
) + ctx
->local
, buffer
, i
);
216 if (ctx
->local
== SHA_BLOCK_SIZE
) {
217 maybe_byte_reverse(ctx
->data
, SHA_BLOCK_SIZE
);
223 while (count
>= SHA_BLOCK_SIZE
) {
224 memcpy(ctx
->data
, buffer
, SHA_BLOCK_SIZE
);
225 buffer
+= SHA_BLOCK_SIZE
;
226 count
-= SHA_BLOCK_SIZE
;
227 maybe_byte_reverse(ctx
->data
, SHA_BLOCK_SIZE
);
230 memcpy(ctx
->data
, buffer
, count
);
235 * Finish computing the SHA digest.
236 * digest: the output buffer in which to store the digest.
237 * context: The context to finalize.
240 sha1_final(struct sha1_ctx
*ctx
, uint8_t digest
[SHA1_DIGEST_SIZE
])
243 uint32_t lo_bit_count
, hi_bit_count
, k
;
245 lo_bit_count
= ctx
->count_lo
;
246 hi_bit_count
= ctx
->count_hi
;
247 count
= (int) ((lo_bit_count
>> 3) & 0x3f);
248 ((uint8_t *) ctx
->data
)[count
++] = 0x80;
249 if (count
> SHA_BLOCK_SIZE
- 8) {
250 memset(((uint8_t *) ctx
->data
) + count
, 0, SHA_BLOCK_SIZE
- count
);
251 maybe_byte_reverse(ctx
->data
, SHA_BLOCK_SIZE
);
253 memset((uint8_t *) ctx
->data
, 0, SHA_BLOCK_SIZE
- 8);
255 memset(((uint8_t *) ctx
->data
) + count
, 0,
256 SHA_BLOCK_SIZE
- 8 - count
);
258 maybe_byte_reverse(ctx
->data
, SHA_BLOCK_SIZE
);
259 ctx
->data
[14] = hi_bit_count
;
260 ctx
->data
[15] = lo_bit_count
;
263 for (i
= j
= 0; j
< SHA1_DIGEST_SIZE
; i
++) {
265 digest
[j
++] = k
>> 24;
266 digest
[j
++] = k
>> 16;
267 digest
[j
++] = k
>> 8;
272 /* Computes the hash of 'n' bytes in 'data' into 'digest'. */
274 sha1_bytes(const void *data
, size_t n
, uint8_t digest
[SHA1_DIGEST_SIZE
])
279 sha1_update(&ctx
, data
, n
);
280 sha1_final(&ctx
, digest
);