|
1 /* |
|
2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the License "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * Generates DSA test vectors. |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 /** |
|
23 @file |
|
24 */ |
|
25 |
|
26 #include <stdio.h> |
|
27 #include <openssl/crypto.h> |
|
28 #include <openssl/rand.h> |
|
29 #include <openssl/dsa.h> |
|
30 #include "utils.h" |
|
31 |
|
32 /* |
|
33 * The DSA keys have been choosen from randomly generated ones so that either |
|
34 * the 2nd or 3rd most significant bit of q is set - this is so that a |
|
35 * particular path is followed when the signing procedure generates k, for which |
|
36 * our function that generates a random number in a certain range is equivalent |
|
37 * to the openssl one. |
|
38 * |
|
39 * This is nasty, but it means we don't have to change the openssl code. |
|
40 */ |
|
41 |
|
42 static DSA* createDSAKey1() |
|
43 { |
|
44 unsigned char p_data[] = |
|
45 "\x8d\xf2\xa4\x94\x49\x22\x76\xaa\x3d\x25\x75\x9b\xb0\x68\x69\xcb" |
|
46 "\xea\xc0\xd8\x3a\xfb\x8d\x0c\xf7\xcb\xb8\x32\x4f\x0d\x78\x82\xe5" |
|
47 "\xd0\x76\x2f\xc5\xb7\x21\x0e\xaf\xc2\xe9\xad\xac\x32\xab\x7a\xac" |
|
48 "\x49\x69\x3d\xfb\xf8\x37\x24\xc2\xec\x07\x36\xee\x31\xc8\x02\x91"; |
|
49 |
|
50 int p_data_len = 64; |
|
51 |
|
52 unsigned char q_data[] = |
|
53 "\xc7\x73\x21\x8c\x73\x7e\xc8\xee\x99\x3b\x4f\x2d\xed\x30\xf4\x8e" |
|
54 "\xda\xce\x91\x5f"; |
|
55 |
|
56 int q_data_len = 20; |
|
57 |
|
58 unsigned char g_data[] = |
|
59 "\x62\x6d\x02\x78\x39\xea\x0a\x13\x41\x31\x63\xa5\x5b\x4c\xb5\x00" |
|
60 "\x29\x9d\x55\x22\x95\x6c\xef\xcb\x3b\xff\x10\xf3\x99\xce\x2c\x2e" |
|
61 "\x71\xcb\x9d\xe5\xfa\x24\xba\xbf\x58\xe5\xb7\x95\x21\x92\x5c\x9c" |
|
62 "\xc4\x2e\x9f\x6f\x46\x4b\x08\x8c\xc5\x72\xaf\x53\xe6\xd7\x88\x02"; |
|
63 |
|
64 int g_data_len = 64; |
|
65 |
|
66 unsigned char priv_key_data[] = |
|
67 "\xc2\x5f\xb4\x81\xd7\x9c\x07\x30\x97\xc2\x1d\x0c\xb1\xd7\x07\x2f" |
|
68 "\x04\x1d\xbb\x89"; |
|
69 |
|
70 int priv_key_data_len = 20; |
|
71 |
|
72 unsigned char pub_key_data[] = |
|
73 "\x2d\x52\x1e\x27\x37\xe7\xdb\xdb\xd1\xe4\x7a\xb6\x79\xc5\xae\x69" |
|
74 "\xe1\x25\x37\xe9\x96\xb1\x81\xba\xf0\xb8\x85\x0f\x84\xc8\x2b\x9e" |
|
75 "\xf5\xb8\xb6\xc2\xb2\x22\x1b\xb5\xa9\xd0\x58\x66\x32\x5a\xb1\x62" |
|
76 "\xae\xb7\x13\x68\xbd\xe4\xca\xa0\xf6\x68\x96\x3c\x7d\x1a\x43\x52"; |
|
77 |
|
78 int pub_key_data_len = 64; |
|
79 |
|
80 DSA* key = DSA_new(); |
|
81 key->p = BN_new(); |
|
82 key->q = BN_new(); |
|
83 key->g = BN_new(); |
|
84 key->priv_key = BN_new(); |
|
85 key->pub_key = BN_new(); |
|
86 |
|
87 BN_bin2bn(p_data, p_data_len, key->p); |
|
88 BN_bin2bn(q_data, q_data_len, key->q); |
|
89 BN_bin2bn(g_data, g_data_len, key->g); |
|
90 BN_bin2bn(pub_key_data, pub_key_data_len, key->pub_key); |
|
91 BN_bin2bn(priv_key_data, priv_key_data_len, key->priv_key); |
|
92 |
|
93 return key; |
|
94 } |
|
95 |
|
96 static DSA* createDSAKey2() |
|
97 { |
|
98 unsigned char p_data[] = |
|
99 "\x8d\xf2\xa4\x94\x49\x22\x76\xaa\x3d\x25\x75\x9b\xb0\x68\x69\xcb" |
|
100 "\xea\xc0\xd8\x3a\xfb\x8d\x0c\xf7\xcb\xb8\x32\x4f\x0d\x78\x82\xe5" |
|
101 "\xd0\x76\x2f\xc5\xb7\x21\x0e\xaf\xc2\xe9\xad\xac\x32\xab\x7a\xac" |
|
102 "\x49\x69\x3d\xfb\xf8\x37\x24\xc2\xec\x07\x36\xee\x31\xc8\x02\x91"; |
|
103 |
|
104 int p_data_len = 64; |
|
105 |
|
106 unsigned char q_data[] = |
|
107 "\xc7\x73\x21\x8c\x73\x7e\xc8\xee\x99\x3b\x4f\x2d\xed\x30\xf4\x8e" |
|
108 "\xda\xce\x91\x5f"; |
|
109 |
|
110 int q_data_len = 20; |
|
111 |
|
112 unsigned char g_data[] = |
|
113 "\x62\x6d\x02\x78\x39\xea\x0a\x13\x41\x31\x63\xa5\x5b\x4c\xb5\x00" |
|
114 "\x29\x9d\x55\x22\x95\x6c\xef\xcb\x3b\xff\x10\xf3\x99\xce\x2c\x2e" |
|
115 "\x71\xcb\x9d\xe5\xfa\x24\xba\xbf\x58\xe5\xb7\x95\x21\x92\x5c\x9c" |
|
116 "\xc4\x2e\x9f\x6f\x46\x4b\x08\x8c\xc5\x72\xaf\x53\xe6\xd7\x88\x02"; |
|
117 |
|
118 int g_data_len = 64; |
|
119 |
|
120 unsigned char priv_key_data[] = |
|
121 "\x0f\x36\x53\xf7\x51\xa7\x04\x6e\x0b\x52\x30\xfe\x15\x7c\xa3\x3e" |
|
122 "\x03\xf0\x84\x73"; |
|
123 |
|
124 int priv_key_data_len = 20; |
|
125 |
|
126 unsigned char pub_key_data[] = |
|
127 "\x7f\x9a\xd6\x6d\x4d\xa9\xb0\x0e\x71\x76\x04\xc4\xdb\x3b\x96\x93" |
|
128 "\x6b\x6c\xa6\x16\xa5\x6b\xb6\xe6\x23\x26\xc7\xf5\xd4\xd6\x5b\x06" |
|
129 "\x6c\x10\x47\x0a\xc2\xf2\x1d\xc1\x7b\x39\x54\x6d\x84\x99\x40\xd1" |
|
130 "\x7e\xb0\xb5\x17\xc1\x17\xcd\xa0\x78\x0c\xc1\x67\xf1\x57\x83\x2c"; |
|
131 |
|
132 int pub_key_data_len = 64; |
|
133 |
|
134 DSA* key = DSA_new(); |
|
135 key->p = BN_new(); |
|
136 key->q = BN_new(); |
|
137 key->g = BN_new(); |
|
138 key->priv_key = BN_new(); |
|
139 key->pub_key = BN_new(); |
|
140 |
|
141 BN_bin2bn(p_data, p_data_len, key->p); |
|
142 BN_bin2bn(q_data, q_data_len, key->q); |
|
143 BN_bin2bn(g_data, g_data_len, key->g); |
|
144 BN_bin2bn(pub_key_data, pub_key_data_len, key->pub_key); |
|
145 BN_bin2bn(priv_key_data, priv_key_data_len, key->priv_key); |
|
146 |
|
147 return key; |
|
148 } |
|
149 |
|
150 static DSA* createDSAKey3() |
|
151 { |
|
152 unsigned char p_data[] = |
|
153 "\xcf\x62\x62\xfb\x7e\x7d\xc9\xc3\x7b\x4b\xa3\x62\x02\x1c\xfd\xb0" |
|
154 "\xcc\xd7\xbe\x39\xba\x89\xfc\x86\xf4\x9b\x29\xee\xe8\xee\x47\x23" |
|
155 "\xa8\x36\xd5\xbc\x3f\x31\xfe\x75\xc9\xcc\xc2\xa4\x49\x1d\x44\xc2" |
|
156 "\xb2\x7a\x71\x45\xd8\xcd\x84\x41\xe5\x8a\x94\xaa\x02\x0f\xd9\x03"; |
|
157 |
|
158 int p_data_len = 64; |
|
159 |
|
160 unsigned char q_data[] = |
|
161 "\xfe\xf0\xae\xe8\x2a\x1c\x4b\xdb\xbb\xd7\xdf\x3b\xfa\xc9\x63\xfb" |
|
162 "\x6d\xfc\x1e\xe7"; |
|
163 |
|
164 int q_data_len = 20; |
|
165 |
|
166 unsigned char g_data[] = |
|
167 "\x3b\x48\xa9\x2d\x82\xde\x8c\x21\x81\x09\xf8\x78\xae\xfc\x6a\xf5" |
|
168 "\x0e\x2a\x90\x3d\xfb\x64\x90\x6f\x0d\xbc\xfd\x67\x4e\x2c\x56\x00" |
|
169 "\xa3\x80\x25\x8a\x00\x26\x62\x10\xdc\xb6\xaa\x11\xa6\x36\x8c\x19" |
|
170 "\xb9\x2a\xcc\x00\xca\x84\xd5\xeb\x8f\x9b\x50\x08\x2d\x56\x4b\x37"; |
|
171 |
|
172 int g_data_len = 64; |
|
173 |
|
174 unsigned char priv_key_data[] = |
|
175 "\x8f\xf4\xb0\xe8\x16\x94\xcb\x45\xaf\x26\xfa\x3b\x52\x96\xb3\xe9" |
|
176 "\xc9\x41\xce\x18"; |
|
177 |
|
178 int priv_key_data_len = 20; |
|
179 |
|
180 unsigned char pub_key_data[] = |
|
181 "\x4e\x31\xab\x0e\x9b\xd5\x16\xaf\xf5\xc7\xf8\xe3\x1d\x01\x20\x90" |
|
182 "\x3e\x11\x11\x5f\xf2\x22\x46\x5f\x08\xbb\x9e\x36\x82\xdc\xfb\x33" |
|
183 "\xf9\xaa\xa5\xe9\xa0\x12\x16\x65\xc4\xbc\x7c\x6a\xf8\xb3\xc8\x8c" |
|
184 "\x2e\x45\xcc\x00\xaa\x7b\x4d\xae\xae\x9a\x1d\x37\x75\xb2\xe6\x86"; |
|
185 |
|
186 int pub_key_data_len = 64; |
|
187 |
|
188 DSA* key = DSA_new(); |
|
189 key->p = BN_new(); |
|
190 key->q = BN_new(); |
|
191 key->g = BN_new(); |
|
192 key->priv_key = BN_new(); |
|
193 key->pub_key = BN_new(); |
|
194 |
|
195 BN_bin2bn(p_data, p_data_len, key->p); |
|
196 BN_bin2bn(q_data, q_data_len, key->q); |
|
197 BN_bin2bn(g_data, g_data_len, key->g); |
|
198 BN_bin2bn(pub_key_data, pub_key_data_len, key->pub_key); |
|
199 BN_bin2bn(priv_key_data, priv_key_data_len, key->priv_key); |
|
200 |
|
201 return key; |
|
202 } |
|
203 |
|
204 static int digest_len = 20; |
|
205 |
|
206 static unsigned char digest1[]="12345678901234567890"; |
|
207 |
|
208 static unsigned char digest2[] = |
|
209 "\xb1\xcd\x52\x66\x6d\x22\x60\x16\xd3\x75\x8e\x96\xa1\xff\xfa\xbc" |
|
210 "\x1b\x9a\xe2\xd7"; |
|
211 |
|
212 static unsigned char digest3[] = |
|
213 "\x39\x86\x53\xec\xae\xf6\xd7\x7a\x8a\x67\x8a\x74\x20\x30\x3b\xc9" |
|
214 "\xda\xc9\xf3\xa7"; |
|
215 /** |
|
216 * Print DSA public key. |
|
217 */ |
|
218 |
|
219 void printDSAPublicKey(DSA* key) |
|
220 { |
|
221 printBNElement("keyP", key->p); |
|
222 printBNElement("keyQ", key->q); |
|
223 printBNElement("keyG", key->g); |
|
224 printBNElement("keyY", key->pub_key); |
|
225 } |
|
226 |
|
227 /** |
|
228 * Print DSA private key. |
|
229 */ |
|
230 |
|
231 void printDSAPrivateKey(DSA* key) |
|
232 { |
|
233 printBNElement("keyP", key->p); |
|
234 printBNElement("keyQ", key->q); |
|
235 printBNElement("keyG", key->g); |
|
236 printBNElement("keyX", key->priv_key); |
|
237 } |
|
238 |
|
239 /** |
|
240 * Sign a message - DSA deals with generating a digest for us. |
|
241 */ |
|
242 |
|
243 static void generateSignatureVector(DSA* key, unsigned char* mess, int len, BOOL passes) |
|
244 { |
|
245 unsigned char buf[len]; |
|
246 unsigned int siglen; |
|
247 int err; |
|
248 DSA_SIG* sig; |
|
249 |
|
250 Mem::Copy(buf, mess, len); |
|
251 |
|
252 setOurRandom(); |
|
253 sig = DSA_do_sign(buf, len, key); |
|
254 if (sig == NULL) |
|
255 processError(); |
|
256 |
|
257 if (!passes) |
|
258 scramble(buf, len); |
|
259 |
|
260 printActionHeader("DSA test vector", "DSASignVector"); |
|
261 printDSAPrivateKey(key); |
|
262 printHexElement("digest", buf, len); |
|
263 printBNElement("sigR", sig->r); |
|
264 printBNElement("sigS", sig->s); |
|
265 printActionFooter(passes); |
|
266 |
|
267 printActionHeader("DSA test vector", "DSAVerifyVector"); |
|
268 printDSAPublicKey(key); |
|
269 printHexElement("digest", buf, len); |
|
270 printBNElement("sigR", sig->r); |
|
271 printBNElement("sigS", sig->s); |
|
272 printActionFooter(passes); |
|
273 |
|
274 DSA_SIG_free(sig); |
|
275 } |
|
276 |
|
277 |
|
278 int main(int argc, char **argv) |
|
279 { |
|
280 DSA* key1 = createDSAKey1(); |
|
281 DSA* key2 = createDSAKey2(); |
|
282 DSA* key3 = createDSAKey3(); |
|
283 |
|
284 setOurRandom(); |
|
285 testOurRandom(); |
|
286 |
|
287 generateSignatureVector(key1, digest1, digest_len, TRUE); |
|
288 generateSignatureVector(key2, digest1, digest_len, TRUE); |
|
289 generateSignatureVector(key3, digest1, digest_len, TRUE); |
|
290 |
|
291 generateSignatureVector(key1, digest2, digest_len, TRUE); |
|
292 generateSignatureVector(key2, digest2, digest_len, TRUE); |
|
293 generateSignatureVector(key3, digest2, digest_len, TRUE); |
|
294 |
|
295 generateSignatureVector(key1, digest3, digest_len, TRUE); |
|
296 generateSignatureVector(key2, digest3, digest_len, TRUE); |
|
297 generateSignatureVector(key3, digest3, digest_len, TRUE); |
|
298 |
|
299 generateSignatureVector(key1, digest1, digest_len, FALSE); |
|
300 generateSignatureVector(key2, digest1, digest_len, FALSE); |
|
301 generateSignatureVector(key3, digest1, digest_len, FALSE); |
|
302 |
|
303 return 0; |
|
304 } |
|
305 |