test_file.c revision 294328 
1/* 	$OpenBSD: test_file.c,v 1.1 2014/06/24 01:14:18 djm Exp $ */
2/*
3 * Regress test for sshkey.h key management API
4 *
5 * Placed in the public domain
6 */
7
8#include "includes.h"
9
10#include <sys/types.h>
11#include <sys/param.h>
12#include <sys/stat.h>
13#include <fcntl.h>
14#include <stdio.h>
15#ifdef HAVE_STDINT_H
16#include <stdint.h>
17#endif
18#include <stdlib.h>
19#include <string.h>
20#include <unistd.h>
21
22#include <openssl/bn.h>
23#include <openssl/rsa.h>
24#include <openssl/dsa.h>
25#include <openssl/objects.h>
26#ifdef OPENSSL_HAS_NISTP256
27# include <openssl/ec.h>
28#endif
29
30#include "../test_helper/test_helper.h"
31
32#include "ssherr.h"
33#include "authfile.h"
34#include "sshkey.h"
35#include "sshbuf.h"
36
37#include "common.h"
38
39void sshkey_file_tests(void);
40
41void
42sshkey_file_tests(void)
43{
44	struct sshkey *k1, *k2;
45	struct sshbuf *buf, *pw;
46	BIGNUM *a, *b, *c;
47	char *cp;
48
49	TEST_START("load passphrase");
50	pw = load_text_file("pw");
51	TEST_DONE();
52
53	TEST_START("parse RSA1 from private");
54	buf = load_file("rsa1_1");
55	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", "rsa1_1",
56	    &k1, NULL), 0);
57	sshbuf_free(buf);
58	ASSERT_PTR_NE(k1, NULL);
59	a = load_bignum("rsa1_1.param.n");
60	ASSERT_BIGNUM_EQ(k1->rsa->n, a);
61	BN_free(a);
62	TEST_DONE();
63
64	TEST_START("parse RSA1 from private w/ passphrase");
65	buf = load_file("rsa1_1_pw");
66	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
67	    (const char *)sshbuf_ptr(pw), "rsa1_1_pw", &k2, NULL), 0);
68	sshbuf_free(buf);
69	ASSERT_PTR_NE(k2, NULL);
70	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
71	sshkey_free(k2);
72	TEST_DONE();
73
74	TEST_START("load RSA1 from public");
75	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa1_1.pub"), &k2,
76	    NULL), 0);
77	ASSERT_PTR_NE(k2, NULL);
78	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
79	sshkey_free(k2);
80	TEST_DONE();
81
82	TEST_START("RSA1 key hex fingerprint");
83	buf = load_text_file("rsa1_1.fp");
84	cp = sshkey_fingerprint(k1, SSH_FP_MD5, SSH_FP_HEX);
85	ASSERT_PTR_NE(cp, NULL);
86	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
87	sshbuf_free(buf);
88	free(cp);
89	TEST_DONE();
90
91	TEST_START("RSA1 key bubblebabble fingerprint");
92	buf = load_text_file("rsa1_1.fp.bb");
93	cp = sshkey_fingerprint(k1, SSH_FP_SHA1, SSH_FP_BUBBLEBABBLE);
94	ASSERT_PTR_NE(cp, NULL);
95	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
96	sshbuf_free(buf);
97	free(cp);
98	TEST_DONE();
99
100	sshkey_free(k1);
101
102	TEST_START("parse RSA from private");
103	buf = load_file("rsa_1");
104	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", "rsa_1",
105	    &k1, NULL), 0);
106	sshbuf_free(buf);
107	ASSERT_PTR_NE(k1, NULL);
108	a = load_bignum("rsa_1.param.n");
109	b = load_bignum("rsa_1.param.p");
110	c = load_bignum("rsa_1.param.q");
111	ASSERT_BIGNUM_EQ(k1->rsa->n, a);
112	ASSERT_BIGNUM_EQ(k1->rsa->p, b);
113	ASSERT_BIGNUM_EQ(k1->rsa->q, c);
114	BN_free(a);
115	BN_free(b);
116	BN_free(c);
117	TEST_DONE();
118
119	TEST_START("parse RSA from private w/ passphrase");
120	buf = load_file("rsa_1_pw");
121	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
122	    (const char *)sshbuf_ptr(pw), "rsa_1_pw", &k2, NULL), 0);
123	sshbuf_free(buf);
124	ASSERT_PTR_NE(k2, NULL);
125	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
126	sshkey_free(k2);
127	TEST_DONE();
128
129	TEST_START("parse RSA from new-format");
130	buf = load_file("rsa_n");
131	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
132	    "", "rsa_n", &k2, NULL), 0);
133	sshbuf_free(buf);
134	ASSERT_PTR_NE(k2, NULL);
135	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
136	sshkey_free(k2);
137	TEST_DONE();
138
139	TEST_START("parse RSA from new-format w/ passphrase");
140	buf = load_file("rsa_n_pw");
141	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
142	    (const char *)sshbuf_ptr(pw), "rsa_n_pw", &k2, NULL), 0);
143	sshbuf_free(buf);
144	ASSERT_PTR_NE(k2, NULL);
145	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
146	sshkey_free(k2);
147	TEST_DONE();
148
149	TEST_START("load RSA from public");
150	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_1.pub"), &k2,
151	    NULL), 0);
152	ASSERT_PTR_NE(k2, NULL);
153	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
154	sshkey_free(k2);
155	TEST_DONE();
156
157	TEST_START("load RSA cert");
158	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("rsa_1"), &k2), 0);
159	ASSERT_PTR_NE(k2, NULL);
160	ASSERT_INT_EQ(k2->type, KEY_RSA_CERT);
161	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
162	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
163	TEST_DONE();
164
165	TEST_START("RSA key hex fingerprint");
166	buf = load_text_file("rsa_1.fp");
167	cp = sshkey_fingerprint(k1, SSH_FP_MD5, SSH_FP_HEX);
168	ASSERT_PTR_NE(cp, NULL);
169	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
170	sshbuf_free(buf);
171	free(cp);
172	TEST_DONE();
173
174	TEST_START("RSA cert hex fingerprint");
175	buf = load_text_file("rsa_1-cert.fp");
176	cp = sshkey_fingerprint(k2, SSH_FP_MD5, SSH_FP_HEX);
177	ASSERT_PTR_NE(cp, NULL);
178	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
179	sshbuf_free(buf);
180	free(cp);
181	sshkey_free(k2);
182	TEST_DONE();
183
184	TEST_START("RSA key bubblebabble fingerprint");
185	buf = load_text_file("rsa_1.fp.bb");
186	cp = sshkey_fingerprint(k1, SSH_FP_SHA1, SSH_FP_BUBBLEBABBLE);
187	ASSERT_PTR_NE(cp, NULL);
188	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
189	sshbuf_free(buf);
190	free(cp);
191	TEST_DONE();
192
193	sshkey_free(k1);
194
195	TEST_START("parse DSA from private");
196	buf = load_file("dsa_1");
197	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", "dsa_1",
198	    &k1, NULL), 0);
199	sshbuf_free(buf);
200	ASSERT_PTR_NE(k1, NULL);
201	a = load_bignum("dsa_1.param.g");
202	b = load_bignum("dsa_1.param.priv");
203	c = load_bignum("dsa_1.param.pub");
204	ASSERT_BIGNUM_EQ(k1->dsa->g, a);
205	ASSERT_BIGNUM_EQ(k1->dsa->priv_key, b);
206	ASSERT_BIGNUM_EQ(k1->dsa->pub_key, c);
207	BN_free(a);
208	BN_free(b);
209	BN_free(c);
210	TEST_DONE();
211
212	TEST_START("parse DSA from private w/ passphrase");
213	buf = load_file("dsa_1_pw");
214	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
215	    (const char *)sshbuf_ptr(pw), "dsa_1_pw", &k2, NULL), 0);
216	sshbuf_free(buf);
217	ASSERT_PTR_NE(k2, NULL);
218	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
219	sshkey_free(k2);
220	TEST_DONE();
221
222	TEST_START("parse DSA from new-format");
223	buf = load_file("dsa_n");
224	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
225	    "", "dsa_n", &k2, NULL), 0);
226	sshbuf_free(buf);
227	ASSERT_PTR_NE(k2, NULL);
228	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
229	sshkey_free(k2);
230	TEST_DONE();
231
232	TEST_START("parse DSA from new-format w/ passphrase");
233	buf = load_file("dsa_n_pw");
234	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
235	    (const char *)sshbuf_ptr(pw), "dsa_n_pw", &k2, NULL), 0);
236	sshbuf_free(buf);
237	ASSERT_PTR_NE(k2, NULL);
238	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
239	sshkey_free(k2);
240	TEST_DONE();
241
242	TEST_START("load DSA from public");
243	ASSERT_INT_EQ(sshkey_load_public(test_data_file("dsa_1.pub"), &k2,
244	    NULL), 0);
245	ASSERT_PTR_NE(k2, NULL);
246	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
247	sshkey_free(k2);
248	TEST_DONE();
249
250	TEST_START("load DSA cert");
251	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("dsa_1"), &k2), 0);
252	ASSERT_PTR_NE(k2, NULL);
253	ASSERT_INT_EQ(k2->type, KEY_DSA_CERT);
254	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
255	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
256	TEST_DONE();
257
258	TEST_START("DSA key hex fingerprint");
259	buf = load_text_file("dsa_1.fp");
260	cp = sshkey_fingerprint(k1, SSH_FP_MD5, SSH_FP_HEX);
261	ASSERT_PTR_NE(cp, NULL);
262	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
263	sshbuf_free(buf);
264	free(cp);
265	TEST_DONE();
266
267	TEST_START("DSA cert hex fingerprint");
268	buf = load_text_file("dsa_1-cert.fp");
269	cp = sshkey_fingerprint(k2, SSH_FP_MD5, SSH_FP_HEX);
270	ASSERT_PTR_NE(cp, NULL);
271	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
272	sshbuf_free(buf);
273	free(cp);
274	sshkey_free(k2);
275	TEST_DONE();
276
277	TEST_START("DSA key bubblebabble fingerprint");
278	buf = load_text_file("dsa_1.fp.bb");
279	cp = sshkey_fingerprint(k1, SSH_FP_SHA1, SSH_FP_BUBBLEBABBLE);
280	ASSERT_PTR_NE(cp, NULL);
281	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
282	sshbuf_free(buf);
283	free(cp);
284	TEST_DONE();
285
286	sshkey_free(k1);
287
288#ifdef OPENSSL_HAS_ECC
289	TEST_START("parse ECDSA from private");
290	buf = load_file("ecdsa_1");
291	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", "ecdsa_1",
292	    &k1, NULL), 0);
293	sshbuf_free(buf);
294	ASSERT_PTR_NE(k1, NULL);
295	buf = load_text_file("ecdsa_1.param.curve");
296	ASSERT_STRING_EQ((const char *)sshbuf_ptr(buf),
297	    OBJ_nid2sn(k1->ecdsa_nid));
298	sshbuf_free(buf);
299	a = load_bignum("ecdsa_1.param.priv");
300	b = load_bignum("ecdsa_1.param.pub");
301	c = EC_POINT_point2bn(EC_KEY_get0_group(k1->ecdsa),
302	    EC_KEY_get0_public_key(k1->ecdsa), POINT_CONVERSION_UNCOMPRESSED,
303	    NULL, NULL);
304	ASSERT_PTR_NE(c, NULL);
305	ASSERT_BIGNUM_EQ(EC_KEY_get0_private_key(k1->ecdsa), a);
306	ASSERT_BIGNUM_EQ(b, c);
307	BN_free(a);
308	BN_free(b);
309	BN_free(c);
310	TEST_DONE();
311
312	TEST_START("parse ECDSA from private w/ passphrase");
313	buf = load_file("ecdsa_1_pw");
314	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
315	    (const char *)sshbuf_ptr(pw), "ecdsa_1_pw", &k2, NULL), 0);
316	sshbuf_free(buf);
317	ASSERT_PTR_NE(k2, NULL);
318	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
319	sshkey_free(k2);
320	TEST_DONE();
321
322	TEST_START("parse ECDSA from new-format");
323	buf = load_file("ecdsa_n");
324	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
325	    "", "ecdsa_n", &k2, NULL), 0);
326	sshbuf_free(buf);
327	ASSERT_PTR_NE(k2, NULL);
328	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
329	sshkey_free(k2);
330	TEST_DONE();
331
332	TEST_START("parse ECDSA from new-format w/ passphrase");
333	buf = load_file("ecdsa_n_pw");
334	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
335	    (const char *)sshbuf_ptr(pw), "ecdsa_n_pw", &k2, NULL), 0);
336	sshbuf_free(buf);
337	ASSERT_PTR_NE(k2, NULL);
338	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
339	sshkey_free(k2);
340	TEST_DONE();
341
342	TEST_START("load ECDSA from public");
343	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_1.pub"), &k2,
344	    NULL), 0);
345	ASSERT_PTR_NE(k2, NULL);
346	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
347	sshkey_free(k2);
348	TEST_DONE();
349
350	TEST_START("load ECDSA cert");
351	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ecdsa_1"), &k2), 0);
352	ASSERT_PTR_NE(k2, NULL);
353	ASSERT_INT_EQ(k2->type, KEY_ECDSA_CERT);
354	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
355	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
356	TEST_DONE();
357
358	TEST_START("ECDSA key hex fingerprint");
359	buf = load_text_file("ecdsa_1.fp");
360	cp = sshkey_fingerprint(k1, SSH_FP_MD5, SSH_FP_HEX);
361	ASSERT_PTR_NE(cp, NULL);
362	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
363	sshbuf_free(buf);
364	free(cp);
365	TEST_DONE();
366
367	TEST_START("ECDSA cert hex fingerprint");
368	buf = load_text_file("ecdsa_1-cert.fp");
369	cp = sshkey_fingerprint(k2, SSH_FP_MD5, SSH_FP_HEX);
370	ASSERT_PTR_NE(cp, NULL);
371	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
372	sshbuf_free(buf);
373	free(cp);
374	sshkey_free(k2);
375	TEST_DONE();
376
377	TEST_START("ECDSA key bubblebabble fingerprint");
378	buf = load_text_file("ecdsa_1.fp.bb");
379	cp = sshkey_fingerprint(k1, SSH_FP_SHA1, SSH_FP_BUBBLEBABBLE);
380	ASSERT_PTR_NE(cp, NULL);
381	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
382	sshbuf_free(buf);
383	free(cp);
384	TEST_DONE();
385
386	sshkey_free(k1);
387#endif /* OPENSSL_HAS_ECC */
388
389	TEST_START("parse Ed25519 from private");
390	buf = load_file("ed25519_1");
391	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", "ed25519_1",
392	    &k1, NULL), 0);
393	sshbuf_free(buf);
394	ASSERT_PTR_NE(k1, NULL);
395	ASSERT_INT_EQ(k1->type, KEY_ED25519);
396	/* XXX check key contents */
397	TEST_DONE();
398
399	TEST_START("parse Ed25519 from private w/ passphrase");
400	buf = load_file("ed25519_1_pw");
401	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
402	    (const char *)sshbuf_ptr(pw), "ed25519_1_pw", &k2, NULL), 0);
403	sshbuf_free(buf);
404	ASSERT_PTR_NE(k2, NULL);
405	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
406	sshkey_free(k2);
407	TEST_DONE();
408
409	TEST_START("load Ed25519 from public");
410	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_1.pub"), &k2,
411	    NULL), 0);
412	ASSERT_PTR_NE(k2, NULL);
413	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
414	sshkey_free(k2);
415	TEST_DONE();
416
417	TEST_START("load Ed25519 cert");
418	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ed25519_1"), &k2), 0);
419	ASSERT_PTR_NE(k2, NULL);
420	ASSERT_INT_EQ(k2->type, KEY_ED25519_CERT);
421	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
422	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
423	TEST_DONE();
424
425	TEST_START("Ed25519 key hex fingerprint");
426	buf = load_text_file("ed25519_1.fp");
427	cp = sshkey_fingerprint(k1, SSH_FP_MD5, SSH_FP_HEX);
428	ASSERT_PTR_NE(cp, NULL);
429	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
430	sshbuf_free(buf);
431	free(cp);
432	TEST_DONE();
433
434	TEST_START("Ed25519 cert hex fingerprint");
435	buf = load_text_file("ed25519_1-cert.fp");
436	cp = sshkey_fingerprint(k2, SSH_FP_MD5, SSH_FP_HEX);
437	ASSERT_PTR_NE(cp, NULL);
438	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
439	sshbuf_free(buf);
440	free(cp);
441	sshkey_free(k2);
442	TEST_DONE();
443
444	TEST_START("Ed25519 key bubblebabble fingerprint");
445	buf = load_text_file("ed25519_1.fp.bb");
446	cp = sshkey_fingerprint(k1, SSH_FP_SHA1, SSH_FP_BUBBLEBABBLE);
447	ASSERT_PTR_NE(cp, NULL);
448	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
449	sshbuf_free(buf);
450	free(cp);
451	TEST_DONE();
452
453	sshkey_free(k1);
454
455	sshbuf_free(pw);
456
457}
458