1 /*-
2 * Copyright (c) 2003 Allan Saddi <allan@saddi.com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY ALLAN SADDI AND HIS CONTRIBUTORS ``AS IS''
15 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL ALLAN SADDI OR HIS CONTRIBUTORS BE
18 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
24 * POSSIBILITY OF SUCH DAMAGE.
25 *
26 * $Id$
27 */
28
29 #ifdef HAVE_CONFIG_H
30 #include <config.h>
31 #endif /* HAVE_CONFIG_H */
32
33 #if HAVE_INTTYPES_H
34 # include <inttypes.h>
35 #else
36 # if HAVE_STDINT_H
37 # include <stdint.h>
38 # endif
39 #endif
40
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44
45 #include "sha1.h"
46 #include "sha256.h"
47 #include "sha384.h"
48 #include "sha512.h"
49
50 static uint8_t tv1[3] = {
51 0x61, 0x62, 0x63
52 };
53
54 static uint8_t tv2[56] = {
55 0x61, 0x62, 0x63, 0x64, 0x62, 0x63, 0x64, 0x65,
56 0x63, 0x64, 0x65, 0x66, 0x64, 0x65, 0x66, 0x67,
57 0x65, 0x66, 0x67, 0x68, 0x66, 0x67, 0x68, 0x69,
58 0x67, 0x68, 0x69, 0x6a, 0x68, 0x69, 0x6a, 0x6b,
59 0x69, 0x6a, 0x6b, 0x6c, 0x6a, 0x6b, 0x6c, 0x6d,
60 0x6b, 0x6c, 0x6d, 0x6e, 0x6c, 0x6d, 0x6e, 0x6f,
61 0x6d, 0x6e, 0x6f, 0x70, 0x6e, 0x6f, 0x70, 0x71
62 };
63
64 static uint8_t tv3[112] = {
65 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
66 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
67 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
68 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
69 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c,
70 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
71 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e,
72 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
73 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
74 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71,
75 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
76 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73,
77 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
78 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75
79 };
80
81 static uint8_t res1[3][SHA1_HASH_SIZE] = {
82 { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e, 0x25, 0x71,
83 0x78, 0x50, 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d },
84 { 0x84, 0x98, 0x3e, 0x44, 0x1c, 0x3b, 0xd2, 0x6e, 0xba, 0xae, 0x4a, 0xa1,
85 0xf9, 0x51, 0x29, 0xe5, 0xe5, 0x46, 0x70, 0xf1 },
86 { 0x34, 0xaa, 0x97, 0x3c, 0xd4, 0xc4, 0xda, 0xa4, 0xf6, 0x1e, 0xeb, 0x2b,
87 0xdb, 0xad, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6f }
88 };
89
90 static uint8_t res256[3][SHA256_HASH_SIZE] = {
91 { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde,
92 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
93 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad },
94 { 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26, 0x93,
95 0x0c, 0x3e, 0x60, 0x39, 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67,
96 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 },
97 { 0xcd, 0xc7, 0x6e, 0x5c, 0x99, 0x14, 0xfb, 0x92, 0x81, 0xa1, 0xc7, 0xe2,
98 0x84, 0xd7, 0x3e, 0x67, 0xf1, 0x80, 0x9a, 0x48, 0xa4, 0x97, 0x20, 0x0e,
99 0x04, 0x6d, 0x39, 0xcc, 0xc7, 0x11, 0x2c, 0xd0 }
100 };
101
102 static uint8_t res384[3][SHA384_HASH_SIZE] = {
103 { 0xcb, 0x00, 0x75, 0x3f, 0x45, 0xa3, 0x5e, 0x8b, 0xb5, 0xa0, 0x3d, 0x69,
104 0x9a, 0xc6, 0x50, 0x07, 0x27, 0x2c, 0x32, 0xab, 0x0e, 0xde, 0xd1, 0x63,
105 0x1a, 0x8b, 0x60, 0x5a, 0x43, 0xff, 0x5b, 0xed, 0x80, 0x86, 0x07, 0x2b,
106 0xa1, 0xe7, 0xcc, 0x23, 0x58, 0xba, 0xec, 0xa1, 0x34, 0xc8, 0x25, 0xa7 },
107 { 0x09, 0x33, 0x0c, 0x33, 0xf7, 0x11, 0x47, 0xe8, 0x3d, 0x19, 0x2f, 0xc7,
108 0x82, 0xcd, 0x1b, 0x47, 0x53, 0x11, 0x1b, 0x17, 0x3b, 0x3b, 0x05, 0xd2,
109 0x2f, 0xa0, 0x80, 0x86, 0xe3, 0xb0, 0xf7, 0x12, 0xfc, 0xc7, 0xc7, 0x1a,
110 0x55, 0x7e, 0x2d, 0xb9, 0x66, 0xc3, 0xe9, 0xfa, 0x91, 0x74, 0x60, 0x39 },
111 { 0x9d, 0x0e, 0x18, 0x09, 0x71, 0x64, 0x74, 0xcb, 0x08, 0x6e, 0x83, 0x4e,
112 0x31, 0x0a, 0x4a, 0x1c, 0xed, 0x14, 0x9e, 0x9c, 0x00, 0xf2, 0x48, 0x52,
113 0x79, 0x72, 0xce, 0xc5, 0x70, 0x4c, 0x2a, 0x5b, 0x07, 0xb8, 0xb3, 0xdc,
114 0x38, 0xec, 0xc4, 0xeb, 0xae, 0x97, 0xdd, 0xd8, 0x7f, 0x3d, 0x89, 0x85 }
115 };
116
117 static uint8_t res512[3][SHA512_HASH_SIZE] = {
118 { 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba, 0xcc, 0x41, 0x73, 0x49,
119 0xae, 0x20, 0x41, 0x31, 0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9, 0x7e, 0xa2,
120 0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a, 0x21, 0x92, 0x99, 0x2a,
121 0x27, 0x4f, 0xc1, 0xa8, 0x36, 0xba, 0x3c, 0x23, 0xa3, 0xfe, 0xeb, 0xbd,
122 0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8, 0x0e, 0x2a, 0x9a, 0xc9, 0x4f,
123 0xa5, 0x4c, 0xa4, 0x9f },
124 { 0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda, 0x8c, 0xf4, 0xf7, 0x28,
125 0x14, 0xfc, 0x14, 0x3f, 0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f, 0x7f, 0xa1,
126 0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18, 0x50, 0x1d, 0x28, 0x9e,
127 0x49, 0x00, 0xf7, 0xe4, 0x33, 0x1b, 0x99, 0xde, 0xc4, 0xb5, 0x43, 0x3a,
128 0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26, 0x54, 0x5e, 0x96, 0xe5, 0x5b,
129 0x87, 0x4b, 0xe9, 0x09 },
130 { 0xe7, 0x18, 0x48, 0x3d, 0x0c, 0xe7, 0x69, 0x64, 0x4e, 0x2e, 0x42, 0xc7,
131 0xbc, 0x15, 0xb4, 0x63, 0x8e, 0x1f, 0x98, 0xb1, 0x3b, 0x20, 0x44, 0x28,
132 0x56, 0x32, 0xa8, 0x03, 0xaf, 0xa9, 0x73, 0xeb, 0xde, 0x0f, 0xf2, 0x44,
133 0x87, 0x7e, 0xa6, 0x0a, 0x4c, 0xb0, 0x43, 0x2c, 0xe5, 0x77, 0xc3, 0x1b,
134 0xeb, 0x00, 0x9c, 0x5c, 0x2c, 0x49, 0xaa, 0x2e, 0x4e, 0xad, 0xb2, 0x17,
135 0xad, 0x8c, 0xc0, 0x9b }
136 };
137
138 int
main(int argc,char * argv[])139 main (int argc, char *argv[])
140 {
141 union {
142 SHA1Context sha1;
143 SHA256Context sha256;
144 SHA384Context sha384;
145 SHA512Context sha512;
146 } s;
147 union {
148 uint8_t sha1[SHA1_HASH_SIZE];
149 uint8_t sha256[SHA256_HASH_SIZE];
150 uint8_t sha384[SHA384_HASH_SIZE];
151 uint8_t sha512[SHA512_HASH_SIZE];
152 } h;
153 uint8_t buf[1000];
154 int i;
155 int retval = 0;
156
157 memset (buf, 0x61, sizeof (buf));
158
159 printf ("SHA-1:\n");
160
161 printf (" Test vector #1: ");
162 SHA1Init (&s.sha1);
163 SHA1Update (&s.sha1, tv1, sizeof (tv1));
164 SHA1Final (&s.sha1, h.sha1);
165 if (!memcmp (h.sha1, res1[0], sizeof (h.sha1)))
166 printf ("PASS\n");
167 else {
168 printf ("FAIL\n");
169 retval = 1;
170 }
171
172 printf (" Test vector #2: ");
173 SHA1Init (&s.sha1);
174 SHA1Update (&s.sha1, tv2, sizeof (tv2));
175 SHA1Final (&s.sha1, h.sha1);
176 if (!memcmp (h.sha1, res1[1], sizeof (h.sha1)))
177 printf ("PASS\n");
178 else {
179 printf ("FAIL\n");
180 retval = 1;
181 }
182
183 printf (" Test vector #3: ");
184 SHA1Init (&s.sha1);
185 for (i = 0; i < 1000; i++)
186 SHA1Update (&s.sha1, buf, sizeof (buf));
187 SHA1Final (&s.sha1, h.sha1);
188 if (!memcmp (h.sha1, res1[2], sizeof (h.sha1)))
189 printf ("PASS\n");
190 else {
191 printf ("FAIL\n");
192 retval = 1;
193 }
194
195 printf ("SHA-256:\n");
196
197 printf (" Test vector #1: ");
198 SHA256Init (&s.sha256);
199 SHA256Update (&s.sha256, tv1, sizeof (tv1));
200 SHA256Final (&s.sha256, h.sha256);
201 if (!memcmp (h.sha256, res256[0], sizeof (h.sha256)))
202 printf ("PASS\n");
203 else {
204 printf ("FAIL\n");
205 retval = 1;
206 }
207
208 printf (" Test vector #2: ");
209 SHA256Init (&s.sha256);
210 SHA256Update (&s.sha256, tv2, sizeof (tv2));
211 SHA256Final (&s.sha256, h.sha256);
212 if (!memcmp (h.sha256, res256[1], sizeof (h.sha256)))
213 printf ("PASS\n");
214 else {
215 printf ("FAIL\n");
216 retval = 1;
217 }
218
219 printf (" Test vector #3: ");
220 SHA256Init (&s.sha256);
221 for (i = 0; i < 1000; i++)
222 SHA256Update (&s.sha256, buf, sizeof (buf));
223 SHA256Final (&s.sha256, h.sha256);
224 if (!memcmp (h.sha256, res256[2], sizeof (h.sha256)))
225 printf ("PASS\n");
226 else {
227 printf ("FAIL\n");
228 retval = 1;
229 }
230
231 printf ("SHA-384:\n");
232
233 printf (" Test vector #1: ");
234 SHA384Init (&s.sha384);
235 SHA384Update (&s.sha384, tv1, sizeof (tv1));
236 SHA384Final (&s.sha384, h.sha384);
237 if (!memcmp (h.sha384, res384[0], sizeof (h.sha384)))
238 printf ("PASS\n");
239 else {
240 printf ("FAIL\n");
241 retval = 1;
242 }
243
244 printf (" Test vector #2: ");
245 SHA384Init (&s.sha384);
246 SHA384Update (&s.sha384, tv3, sizeof (tv3));
247 SHA384Final (&s.sha384, h.sha384);
248 if (!memcmp (h.sha384, res384[1], sizeof (h.sha384)))
249 printf ("PASS\n");
250 else {
251 printf ("FAIL\n");
252 retval = 1;
253 }
254
255 printf (" Test vector #3: ");
256 SHA384Init (&s.sha384);
257 for (i = 0; i < 1000; i++)
258 SHA384Update (&s.sha384, buf, sizeof (buf));
259 SHA384Final (&s.sha384, h.sha384);
260 if (!memcmp (h.sha384, res384[2], sizeof (h.sha384)))
261 printf ("PASS\n");
262 else {
263 printf ("FAIL\n");
264 retval = 1;
265 }
266
267 printf ("SHA-512:\n");
268
269 printf (" Test vector #1: ");
270 SHA512Init (&s.sha512);
271 SHA512Update (&s.sha512, tv1, sizeof (tv1));
272 SHA512Final (&s.sha512, h.sha512);
273 if (!memcmp (h.sha512, res512[0], sizeof (h.sha512)))
274 printf ("PASS\n");
275 else {
276 printf ("FAIL\n");
277 retval = 1;
278 }
279
280 printf (" Test vector #2: ");
281 SHA512Init (&s.sha512);
282 SHA512Update (&s.sha512, tv3, sizeof (tv3));
283 SHA512Final (&s.sha512, h.sha512);
284 if (!memcmp (h.sha512, res512[1], sizeof (h.sha512)))
285 printf ("PASS\n");
286 else {
287 printf ("FAIL\n");
288 retval = 1;
289 }
290
291 printf (" Test vector #3: ");
292 SHA512Init (&s.sha512);
293 for (i = 0; i < 1000; i++)
294 SHA512Update (&s.sha512, buf, sizeof (buf));
295 SHA512Final (&s.sha512, h.sha512);
296 if (!memcmp (h.sha512, res512[2], sizeof (h.sha512)))
297 printf ("PASS\n");
298 else {
299 printf ("FAIL\n");
300 retval = 1;
301 }
302
303 return retval;
304 }
305