]>
git.ipfire.org Git - thirdparty/bird.git/blob - lib/sha1.c
2 * BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174)
4 * (c) 2015 CZ.NIC z.s.p.o.
6 * Based on the code from libucw-6.4
7 * (c) 2008--2009 Martin Mares <mj@ucw.cz>
9 * Based on the code from libgcrypt-1.2.3, which is
10 * (c) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
12 * Can be freely distributed and used under the terms of the GNU GPL.
16 #include "lib/unaligned.h"
20 sha1_init(struct hash_context
*CTX
)
22 struct sha1_context
*ctx
= (void *) CTX
;
35 * Transform the message X which consists of 16 32-bit-words
38 sha1_transform(struct sha1_context
*ctx
, const byte
*data
)
43 /* Get values from the chaining vars. */
54 for (i
= 0; i
< 16; i
++)
55 x
[i
] = get_u32(data
+4*i
);
58 #define K1 0x5A827999L
59 #define K2 0x6ED9EBA1L
60 #define K3 0x8F1BBCDCL
61 #define K4 0xCA62C1D6L
62 #define F1(x,y,z) ( z ^ ( x & ( y ^ z ) ) )
63 #define F2(x,y,z) ( x ^ y ^ z )
64 #define F3(x,y,z) ( ( x & y ) | ( z & ( x | y ) ) )
65 #define F4(x,y,z) ( x ^ y ^ z )
67 #define M(i) (tm = x[i&0x0f] ^ x[(i-14)&0x0f] ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f], (x[i&0x0f] = ROL(tm, 1)))
69 /* Bitwise rotation of an unsigned int to the left **/
70 #define ROL(x, bits) (((x) << (bits)) | ((uint)(x) >> (sizeof(uint)*8 - (bits))))
72 #define R(a, b, c, d, e, f, k, m) \
75 e += ROL(a, 5) + f(b, c, d) + k + m; \
79 R( a
, b
, c
, d
, e
, F1
, K1
, x
[ 0] );
80 R( e
, a
, b
, c
, d
, F1
, K1
, x
[ 1] );
81 R( d
, e
, a
, b
, c
, F1
, K1
, x
[ 2] );
82 R( c
, d
, e
, a
, b
, F1
, K1
, x
[ 3] );
83 R( b
, c
, d
, e
, a
, F1
, K1
, x
[ 4] );
84 R( a
, b
, c
, d
, e
, F1
, K1
, x
[ 5] );
85 R( e
, a
, b
, c
, d
, F1
, K1
, x
[ 6] );
86 R( d
, e
, a
, b
, c
, F1
, K1
, x
[ 7] );
87 R( c
, d
, e
, a
, b
, F1
, K1
, x
[ 8] );
88 R( b
, c
, d
, e
, a
, F1
, K1
, x
[ 9] );
89 R( a
, b
, c
, d
, e
, F1
, K1
, x
[10] );
90 R( e
, a
, b
, c
, d
, F1
, K1
, x
[11] );
91 R( d
, e
, a
, b
, c
, F1
, K1
, x
[12] );
92 R( c
, d
, e
, a
, b
, F1
, K1
, x
[13] );
93 R( b
, c
, d
, e
, a
, F1
, K1
, x
[14] );
94 R( a
, b
, c
, d
, e
, F1
, K1
, x
[15] );
95 R( e
, a
, b
, c
, d
, F1
, K1
, M(16) );
96 R( d
, e
, a
, b
, c
, F1
, K1
, M(17) );
97 R( c
, d
, e
, a
, b
, F1
, K1
, M(18) );
98 R( b
, c
, d
, e
, a
, F1
, K1
, M(19) );
99 R( a
, b
, c
, d
, e
, F2
, K2
, M(20) );
100 R( e
, a
, b
, c
, d
, F2
, K2
, M(21) );
101 R( d
, e
, a
, b
, c
, F2
, K2
, M(22) );
102 R( c
, d
, e
, a
, b
, F2
, K2
, M(23) );
103 R( b
, c
, d
, e
, a
, F2
, K2
, M(24) );
104 R( a
, b
, c
, d
, e
, F2
, K2
, M(25) );
105 R( e
, a
, b
, c
, d
, F2
, K2
, M(26) );
106 R( d
, e
, a
, b
, c
, F2
, K2
, M(27) );
107 R( c
, d
, e
, a
, b
, F2
, K2
, M(28) );
108 R( b
, c
, d
, e
, a
, F2
, K2
, M(29) );
109 R( a
, b
, c
, d
, e
, F2
, K2
, M(30) );
110 R( e
, a
, b
, c
, d
, F2
, K2
, M(31) );
111 R( d
, e
, a
, b
, c
, F2
, K2
, M(32) );
112 R( c
, d
, e
, a
, b
, F2
, K2
, M(33) );
113 R( b
, c
, d
, e
, a
, F2
, K2
, M(34) );
114 R( a
, b
, c
, d
, e
, F2
, K2
, M(35) );
115 R( e
, a
, b
, c
, d
, F2
, K2
, M(36) );
116 R( d
, e
, a
, b
, c
, F2
, K2
, M(37) );
117 R( c
, d
, e
, a
, b
, F2
, K2
, M(38) );
118 R( b
, c
, d
, e
, a
, F2
, K2
, M(39) );
119 R( a
, b
, c
, d
, e
, F3
, K3
, M(40) );
120 R( e
, a
, b
, c
, d
, F3
, K3
, M(41) );
121 R( d
, e
, a
, b
, c
, F3
, K3
, M(42) );
122 R( c
, d
, e
, a
, b
, F3
, K3
, M(43) );
123 R( b
, c
, d
, e
, a
, F3
, K3
, M(44) );
124 R( a
, b
, c
, d
, e
, F3
, K3
, M(45) );
125 R( e
, a
, b
, c
, d
, F3
, K3
, M(46) );
126 R( d
, e
, a
, b
, c
, F3
, K3
, M(47) );
127 R( c
, d
, e
, a
, b
, F3
, K3
, M(48) );
128 R( b
, c
, d
, e
, a
, F3
, K3
, M(49) );
129 R( a
, b
, c
, d
, e
, F3
, K3
, M(50) );
130 R( e
, a
, b
, c
, d
, F3
, K3
, M(51) );
131 R( d
, e
, a
, b
, c
, F3
, K3
, M(52) );
132 R( c
, d
, e
, a
, b
, F3
, K3
, M(53) );
133 R( b
, c
, d
, e
, a
, F3
, K3
, M(54) );
134 R( a
, b
, c
, d
, e
, F3
, K3
, M(55) );
135 R( e
, a
, b
, c
, d
, F3
, K3
, M(56) );
136 R( d
, e
, a
, b
, c
, F3
, K3
, M(57) );
137 R( c
, d
, e
, a
, b
, F3
, K3
, M(58) );
138 R( b
, c
, d
, e
, a
, F3
, K3
, M(59) );
139 R( a
, b
, c
, d
, e
, F4
, K4
, M(60) );
140 R( e
, a
, b
, c
, d
, F4
, K4
, M(61) );
141 R( d
, e
, a
, b
, c
, F4
, K4
, M(62) );
142 R( c
, d
, e
, a
, b
, F4
, K4
, M(63) );
143 R( b
, c
, d
, e
, a
, F4
, K4
, M(64) );
144 R( a
, b
, c
, d
, e
, F4
, K4
, M(65) );
145 R( e
, a
, b
, c
, d
, F4
, K4
, M(66) );
146 R( d
, e
, a
, b
, c
, F4
, K4
, M(67) );
147 R( c
, d
, e
, a
, b
, F4
, K4
, M(68) );
148 R( b
, c
, d
, e
, a
, F4
, K4
, M(69) );
149 R( a
, b
, c
, d
, e
, F4
, K4
, M(70) );
150 R( e
, a
, b
, c
, d
, F4
, K4
, M(71) );
151 R( d
, e
, a
, b
, c
, F4
, K4
, M(72) );
152 R( c
, d
, e
, a
, b
, F4
, K4
, M(73) );
153 R( b
, c
, d
, e
, a
, F4
, K4
, M(74) );
154 R( a
, b
, c
, d
, e
, F4
, K4
, M(75) );
155 R( e
, a
, b
, c
, d
, F4
, K4
, M(76) );
156 R( d
, e
, a
, b
, c
, F4
, K4
, M(77) );
157 R( c
, d
, e
, a
, b
, F4
, K4
, M(78) );
158 R( b
, c
, d
, e
, a
, F4
, K4
, M(79) );
160 /* Update chaining vars. */
169 * Update the message digest with the contents of BUF with length LEN.
172 sha1_update(struct hash_context
*CTX
, const byte
*buf
, uint len
)
174 struct sha1_context
*ctx
= (void *) CTX
;
178 /* Fill rest of internal buffer */
179 for (; len
&& ctx
->count
< SHA1_BLOCK_SIZE
; len
--)
180 ctx
->buf
[ctx
->count
++] = *buf
++;
182 if (ctx
->count
< SHA1_BLOCK_SIZE
)
185 /* Process data from internal buffer */
186 sha1_transform(ctx
, ctx
->buf
);
194 /* Process data from input buffer */
195 while (len
>= SHA1_BLOCK_SIZE
)
197 sha1_transform(ctx
, buf
);
199 buf
+= SHA1_BLOCK_SIZE
;
200 len
-= SHA1_BLOCK_SIZE
;
203 /* Copy remaining data to internal buffer */
204 memcpy(ctx
->buf
, buf
, len
);
209 * The routine final terminates the computation and returns the digest. The
210 * handle is prepared for a new cycle, but adding bytes to the handle will the
211 * destroy the returned buffer.
213 * Returns: 20 bytes representing the digest.
216 sha1_final(struct hash_context
*CTX
)
218 struct sha1_context
*ctx
= (void *) CTX
;
221 sha1_update(CTX
, NULL
, 0); /* flush */
224 /* multiply by 64 to make a byte count */
229 if ((lsb
+= ctx
->count
) < t
)
231 /* multiply by 8 to make a bit count */
240 ctx
->buf
[ctx
->count
++] = 0x80; /* pad */
241 while (ctx
->count
< 56)
242 ctx
->buf
[ctx
->count
++] = 0; /* pad */
246 /* need one extra block */
247 ctx
->buf
[ctx
->count
++] = 0x80; /* pad character */
248 while (ctx
->count
< 64)
249 ctx
->buf
[ctx
->count
++] = 0;
250 sha1_update(CTX
, NULL
, 0); /* flush */
251 memset(ctx
->buf
, 0, 56); /* fill next block with zeroes */
254 /* append the 64 bit count */
255 ctx
->buf
[56] = msb
>> 24;
256 ctx
->buf
[57] = msb
>> 16;
257 ctx
->buf
[58] = msb
>> 8;
259 ctx
->buf
[60] = lsb
>> 24;
260 ctx
->buf
[61] = lsb
>> 16;
261 ctx
->buf
[62] = lsb
>> 8;
263 sha1_transform(ctx
, ctx
->buf
);
266 #define X(a) do { put_u32(p, ctx->h##a); p += 4; } while(0)