1 /* 	$OpenBSD: test_sshkey.c,v 1.25 2024/08/15 00:52:23 djm Exp $ */
2 /*
3  * Regress test for sshkey.h key management API
4  *
5  * Placed in the public domain
6  */
7 
8 #include <sys/types.h>
9 #include <stdio.h>
10 #include <stdint.h>
11 #include <stdlib.h>
12 #include <string.h>
13 
14 #include <openssl/bn.h>
15 #include <openssl/ec.h>
16 #include <openssl/rsa.h>
17 #include <openssl/dsa.h>
18 
19 #include "test_helper.h"
20 
21 #include "ssherr.h"
22 #include "sshbuf.h"
23 #define SSHBUF_INTERNAL 1	/* access internals for testing */
24 #include "sshkey.h"
25 
26 #include "authfile.h"
27 #include "common.h"
28 #include "ssh2.h"
29 
30 void sshkey_tests(void);
31 
32 static void
put_opt(struct sshbuf * b,const char * name,const char * value)33 put_opt(struct sshbuf *b, const char *name, const char *value)
34 {
35 	struct sshbuf *sect;
36 
37 	sect = sshbuf_new();
38 	ASSERT_PTR_NE(sect, NULL);
39 	ASSERT_INT_EQ(sshbuf_put_cstring(b, name), 0);
40 	if (value != NULL)
41 		ASSERT_INT_EQ(sshbuf_put_cstring(sect, value), 0);
42 	ASSERT_INT_EQ(sshbuf_put_stringb(b, sect), 0);
43 	sshbuf_free(sect);
44 }
45 
46 static void
build_cert(struct sshbuf * b,struct sshkey * k,const char * type,struct sshkey * sign_key,struct sshkey * ca_key,const char * sig_alg)47 build_cert(struct sshbuf *b, struct sshkey *k, const char *type,
48     struct sshkey *sign_key, struct sshkey *ca_key,
49     const char *sig_alg)
50 {
51 	struct sshbuf *ca_buf, *pk, *principals, *critopts, *exts;
52 	u_char *sigblob;
53 	size_t siglen;
54 
55 	ca_buf = sshbuf_new();
56 	ASSERT_PTR_NE(ca_buf, NULL);
57 	ASSERT_INT_EQ(sshkey_putb(ca_key, ca_buf), 0);
58 
59 	/*
60 	 * Get the public key serialisation by rendering the key and skipping
61 	 * the type string. This is a bit of a hack :/
62 	 */
63 	pk = sshbuf_new();
64 	ASSERT_PTR_NE(pk, NULL);
65 	ASSERT_INT_EQ(sshkey_putb_plain(k, pk), 0);
66 	ASSERT_INT_EQ(sshbuf_skip_string(pk), 0);
67 
68 	principals = sshbuf_new();
69 	ASSERT_PTR_NE(principals, NULL);
70 	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gsamsa"), 0);
71 	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gregor"), 0);
72 
73 	critopts = sshbuf_new();
74 	ASSERT_PTR_NE(critopts, NULL);
75 	put_opt(critopts, "force-command", "/usr/local/bin/nethack");
76 	put_opt(critopts, "source-address", "192.168.0.0/24,127.0.0.1,::1");
77 
78 	exts = sshbuf_new();
79 	ASSERT_PTR_NE(exts, NULL);
80 	put_opt(critopts, "permit-X11-forwarding", NULL);
81 
82 	ASSERT_INT_EQ(sshbuf_put_cstring(b, type), 0);
83 	ASSERT_INT_EQ(sshbuf_put_cstring(b, "noncenoncenonce!"), 0); /* nonce */
84 	ASSERT_INT_EQ(sshbuf_putb(b, pk), 0); /* public key serialisation */
85 	ASSERT_INT_EQ(sshbuf_put_u64(b, 1234), 0); /* serial */
86 	ASSERT_INT_EQ(sshbuf_put_u32(b, SSH2_CERT_TYPE_USER), 0); /* type */
87 	ASSERT_INT_EQ(sshbuf_put_cstring(b, "gregor"), 0); /* key ID */
88 	ASSERT_INT_EQ(sshbuf_put_stringb(b, principals), 0); /* principals */
89 	ASSERT_INT_EQ(sshbuf_put_u64(b, 0), 0); /* start */
90 	ASSERT_INT_EQ(sshbuf_put_u64(b, 0xffffffffffffffffULL), 0); /* end */
91 	ASSERT_INT_EQ(sshbuf_put_stringb(b, critopts), 0); /* options */
92 	ASSERT_INT_EQ(sshbuf_put_stringb(b, exts), 0); /* extensions */
93 	ASSERT_INT_EQ(sshbuf_put_string(b, NULL, 0), 0); /* reserved */
94 	ASSERT_INT_EQ(sshbuf_put_stringb(b, ca_buf), 0); /* signature key */
95 	ASSERT_INT_EQ(sshkey_sign(sign_key, &sigblob, &siglen,
96 	    sshbuf_ptr(b), sshbuf_len(b), sig_alg, NULL, NULL, 0), 0);
97 	ASSERT_INT_EQ(sshbuf_put_string(b, sigblob, siglen), 0); /* signature */
98 
99 	free(sigblob);
100 	sshbuf_free(ca_buf);
101 	sshbuf_free(exts);
102 	sshbuf_free(critopts);
103 	sshbuf_free(principals);
104 	sshbuf_free(pk);
105 }
106 
107 static void
signature_test(struct sshkey * k,struct sshkey * bad,const char * sig_alg,const u_char * d,size_t l)108 signature_test(struct sshkey *k, struct sshkey *bad, const char *sig_alg,
109     const u_char *d, size_t l)
110 {
111 	size_t len;
112 	u_char *sig;
113 
114 	ASSERT_INT_EQ(sshkey_sign(k, &sig, &len, d, l, sig_alg,
115 	    NULL, NULL, 0), 0);
116 	ASSERT_SIZE_T_GT(len, 8);
117 	ASSERT_PTR_NE(sig, NULL);
118 	ASSERT_INT_EQ(sshkey_verify(k, sig, len, d, l, NULL, 0, NULL), 0);
119 	ASSERT_INT_NE(sshkey_verify(bad, sig, len, d, l, NULL, 0, NULL), 0);
120 	/* Fuzz test is more comprehensive, this is just a smoke test */
121 	sig[len - 5] ^= 0x10;
122 	ASSERT_INT_NE(sshkey_verify(k, sig, len, d, l, NULL, 0, NULL), 0);
123 	free(sig);
124 }
125 
126 static void
banana(u_char * s,size_t l)127 banana(u_char *s, size_t l)
128 {
129 	size_t o;
130 	const u_char the_banana[] = { 'b', 'a', 'n', 'a', 'n', 'a' };
131 
132 	for (o = 0; o < l; o += sizeof(the_banana)) {
133 		if (l - o < sizeof(the_banana)) {
134 			memcpy(s + o, "nanananana", l - o);
135 			break;
136 		}
137 		memcpy(s + o, the_banana, sizeof(the_banana));
138 	}
139 }
140 
141 static void
signature_tests(struct sshkey * k,struct sshkey * bad,const char * sig_alg)142 signature_tests(struct sshkey *k, struct sshkey *bad, const char *sig_alg)
143 {
144 	u_char i, buf[2049];
145 	size_t lens[] = {
146 		1, 2, 7, 8, 9, 15, 16, 17, 31, 32, 33, 127, 128, 129,
147 		255, 256, 257, 1023, 1024, 1025, 2047, 2048, 2049
148 	};
149 
150 	for (i = 0; i < (sizeof(lens)/sizeof(lens[0])); i++) {
151 		test_subtest_info("%s key, banana length %zu",
152 		    sshkey_type(k), lens[i]);
153 		banana(buf, lens[i]);
154 		signature_test(k, bad, sig_alg, buf, lens[i]);
155 	}
156 }
157 
158 static struct sshkey *
get_private(const char * n)159 get_private(const char *n)
160 {
161 	struct sshbuf *b;
162 	struct sshkey *ret;
163 
164 	b = load_file(n);
165 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(b, "", &ret, NULL), 0);
166 	sshbuf_free(b);
167 	return ret;
168 }
169 
170 void
sshkey_tests(void)171 sshkey_tests(void)
172 {
173 	struct sshkey *k1 = NULL, *k2 = NULL, *k3 = NULL, *k4 = NULL;
174 	struct sshkey *kr = NULL, *kd = NULL, *ke = NULL, *kf = NULL;
175 	struct sshbuf *b = NULL;
176 
177 	TEST_START("new invalid");
178 	k1 = sshkey_new(-42);
179 	ASSERT_PTR_EQ(k1, NULL);
180 	TEST_DONE();
181 
182 	TEST_START("new/free KEY_UNSPEC");
183 	k1 = sshkey_new(KEY_UNSPEC);
184 	ASSERT_PTR_NE(k1, NULL);
185 	sshkey_free(k1);
186 	TEST_DONE();
187 
188 	TEST_START("new/free KEY_RSA");
189 	k1 = sshkey_new(KEY_RSA);
190 	ASSERT_PTR_NE(k1, NULL);
191 	ASSERT_PTR_NE(k1->pkey, NULL);
192 	sshkey_free(k1);
193 	TEST_DONE();
194 
195 #ifdef WiTH_DSA
196 	TEST_START("new/free KEY_DSA");
197 	k1 = sshkey_new(KEY_DSA);
198 	ASSERT_PTR_NE(k1, NULL);
199 	ASSERT_PTR_NE(k1->dsa, NULL);
200 	sshkey_free(k1);
201 	TEST_DONE();
202 #endif
203 
204 	TEST_START("new/free KEY_ECDSA");
205 	k1 = sshkey_new(KEY_ECDSA);
206 	ASSERT_PTR_NE(k1, NULL);
207 	ASSERT_PTR_EQ(k1->pkey, NULL);  /* Can't allocate without NID */
208 	sshkey_free(k1);
209 	TEST_DONE();
210 
211 	TEST_START("new/free KEY_ED25519");
212 	k1 = sshkey_new(KEY_ED25519);
213 	ASSERT_PTR_NE(k1, NULL);
214 	/* These should be blank until key loaded or generated */
215 	ASSERT_PTR_EQ(k1->ed25519_sk, NULL);
216 	ASSERT_PTR_EQ(k1->ed25519_pk, NULL);
217 	sshkey_free(k1);
218 	TEST_DONE();
219 
220 	TEST_START("generate KEY_RSA too small modulus");
221 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 128, &k1),
222 	    SSH_ERR_KEY_LENGTH);
223 	ASSERT_PTR_EQ(k1, NULL);
224 	TEST_DONE();
225 
226 	TEST_START("generate KEY_RSA too large modulus");
227 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1 << 20, &k1),
228 	    SSH_ERR_KEY_LENGTH);
229 	ASSERT_PTR_EQ(k1, NULL);
230 	TEST_DONE();
231 
232 #ifdef WITH_DSA
233 	TEST_START("generate KEY_DSA wrong bits");
234 	ASSERT_INT_EQ(sshkey_generate(KEY_DSA, 2048, &k1),
235 	    SSH_ERR_KEY_LENGTH);
236 	ASSERT_PTR_EQ(k1, NULL);
237 	sshkey_free(k1);
238 	TEST_DONE();
239 #endif
240 
241 	TEST_START("generate KEY_ECDSA wrong bits");
242 	ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 42, &k1),
243 	    SSH_ERR_KEY_LENGTH);
244 	ASSERT_PTR_EQ(k1, NULL);
245 	sshkey_free(k1);
246 	TEST_DONE();
247 
248 	TEST_START("generate KEY_RSA");
249 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 767, &kr),
250 	    SSH_ERR_KEY_LENGTH);
251 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1024, &kr), 0);
252 	ASSERT_PTR_NE(kr, NULL);
253 	ASSERT_PTR_NE(EVP_PKEY_get0_RSA(kr->pkey), NULL);
254 	ASSERT_PTR_NE(rsa_n(kr), NULL);
255 	ASSERT_PTR_NE(rsa_e(kr), NULL);
256 	ASSERT_PTR_NE(rsa_p(kr), NULL);
257 	ASSERT_INT_EQ(BN_num_bits(rsa_n(kr)), 1024);
258 	TEST_DONE();
259 
260 #ifdef WITH_DSA
261 	TEST_START("generate KEY_DSA");
262 	ASSERT_INT_EQ(sshkey_generate(KEY_DSA, 1024, &kd), 0);
263 	ASSERT_PTR_NE(kd, NULL);
264 	ASSERT_PTR_NE(kd->dsa, NULL);
265 	ASSERT_PTR_NE(dsa_g(kd), NULL);
266 	ASSERT_PTR_NE(dsa_priv_key(kd), NULL);
267 	TEST_DONE();
268 #endif
269 
270 	TEST_START("generate KEY_ECDSA");
271 	ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 256, &ke), 0);
272 	ASSERT_PTR_NE(ke, NULL);
273 	ASSERT_PTR_NE(EVP_PKEY_get0_EC_KEY(ke->pkey), NULL);
274 	ASSERT_PTR_NE(EC_KEY_get0_public_key(EVP_PKEY_get0_EC_KEY(ke->pkey)),
275 	    NULL);
276 	ASSERT_PTR_NE(EC_KEY_get0_private_key(EVP_PKEY_get0_EC_KEY(ke->pkey)),
277 	    NULL);
278 	TEST_DONE();
279 
280 	TEST_START("generate KEY_ED25519");
281 	ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 256, &kf), 0);
282 	ASSERT_PTR_NE(kf, NULL);
283 	ASSERT_INT_EQ(kf->type, KEY_ED25519);
284 	ASSERT_PTR_NE(kf->ed25519_pk, NULL);
285 	ASSERT_PTR_NE(kf->ed25519_sk, NULL);
286 	TEST_DONE();
287 
288 	TEST_START("demote KEY_RSA");
289 	ASSERT_INT_EQ(sshkey_from_private(kr, &k1), 0);
290 	ASSERT_PTR_NE(k1, NULL);
291 	ASSERT_PTR_NE(kr, k1);
292 	ASSERT_INT_EQ(k1->type, KEY_RSA);
293 	ASSERT_PTR_NE(EVP_PKEY_get0_RSA(k1->pkey), NULL);
294 	ASSERT_PTR_NE(rsa_n(k1), NULL);
295 	ASSERT_PTR_NE(rsa_e(k1), NULL);
296 	ASSERT_PTR_EQ(rsa_p(k1), NULL);
297 	TEST_DONE();
298 
299 	TEST_START("equal KEY_RSA/demoted KEY_RSA");
300 	ASSERT_INT_EQ(sshkey_equal(kr, k1), 1);
301 	sshkey_free(k1);
302 	TEST_DONE();
303 
304 #ifdef WITH_DSA
305 	TEST_START("demote KEY_DSA");
306 	ASSERT_INT_EQ(sshkey_from_private(kd, &k1), 0);
307 	ASSERT_PTR_NE(k1, NULL);
308 	ASSERT_PTR_NE(kd, k1);
309 	ASSERT_INT_EQ(k1->type, KEY_DSA);
310 	ASSERT_PTR_NE(k1->dsa, NULL);
311 	ASSERT_PTR_NE(dsa_g(k1), NULL);
312 	ASSERT_PTR_EQ(dsa_priv_key(k1), NULL);
313 	TEST_DONE();
314 
315 	TEST_START("equal KEY_DSA/demoted KEY_DSA");
316 	ASSERT_INT_EQ(sshkey_equal(kd, k1), 1);
317 	sshkey_free(k1);
318 	TEST_DONE();
319 #endif
320 
321 	TEST_START("demote KEY_ECDSA");
322 	ASSERT_INT_EQ(sshkey_from_private(ke, &k1), 0);
323 	ASSERT_PTR_NE(k1, NULL);
324 	ASSERT_PTR_NE(ke, k1);
325 	ASSERT_INT_EQ(k1->type, KEY_ECDSA);
326 	ASSERT_PTR_NE(EVP_PKEY_get0_EC_KEY(k1->pkey), NULL);
327 	ASSERT_INT_EQ(k1->ecdsa_nid, ke->ecdsa_nid);
328 	ASSERT_PTR_NE(EC_KEY_get0_public_key(EVP_PKEY_get0_EC_KEY(ke->pkey)),
329 	   NULL);
330 	ASSERT_PTR_EQ(EC_KEY_get0_private_key(EVP_PKEY_get0_EC_KEY(k1->pkey)),
331 	   NULL);
332 	TEST_DONE();
333 
334 	TEST_START("equal KEY_ECDSA/demoted KEY_ECDSA");
335 	ASSERT_INT_EQ(sshkey_equal(ke, k1), 1);
336 	sshkey_free(k1);
337 	TEST_DONE();
338 
339 	TEST_START("demote KEY_ED25519");
340 	ASSERT_INT_EQ(sshkey_from_private(kf, &k1), 0);
341 	ASSERT_PTR_NE(k1, NULL);
342 	ASSERT_PTR_NE(kf, k1);
343 	ASSERT_INT_EQ(k1->type, KEY_ED25519);
344 	ASSERT_PTR_NE(k1->ed25519_pk, NULL);
345 	ASSERT_PTR_EQ(k1->ed25519_sk, NULL);
346 	TEST_DONE();
347 
348 	TEST_START("equal KEY_ED25519/demoted KEY_ED25519");
349 	ASSERT_INT_EQ(sshkey_equal(kf, k1), 1);
350 	sshkey_free(k1);
351 	TEST_DONE();
352 
353 	TEST_START("equal mismatched key types");
354 	ASSERT_INT_EQ(sshkey_equal(kd, kr), 0);
355 	ASSERT_INT_EQ(sshkey_equal(kd, ke), 0);
356 	ASSERT_INT_EQ(sshkey_equal(kr, ke), 0);
357 	ASSERT_INT_EQ(sshkey_equal(ke, kf), 0);
358 	ASSERT_INT_EQ(sshkey_equal(kd, kf), 0);
359 	TEST_DONE();
360 
361 	TEST_START("equal different keys");
362 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1024, &k1), 0);
363 	ASSERT_INT_EQ(sshkey_equal(kr, k1), 0);
364 	sshkey_free(k1);
365 	ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 256, &k1), 0);
366 	ASSERT_INT_EQ(sshkey_equal(ke, k1), 0);
367 	sshkey_free(k1);
368 	ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 256, &k1), 0);
369 	ASSERT_INT_EQ(sshkey_equal(kf, k1), 0);
370 	sshkey_free(k1);
371 	TEST_DONE();
372 
373 	sshkey_free(kr);
374 	sshkey_free(kd);
375 	sshkey_free(ke);
376 	sshkey_free(kf);
377 
378 	TEST_START("certify key");
379 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_1.pub"),
380 	    &k1, NULL), 0);
381 	k2 = get_private("ed25519_2");
382 	ASSERT_INT_EQ(sshkey_to_certified(k1), 0);
383 	ASSERT_PTR_NE(k1->cert, NULL);
384 	k1->cert->type = SSH2_CERT_TYPE_USER;
385 	k1->cert->serial = 1234;
386 	k1->cert->key_id = strdup("estragon");
387 	ASSERT_PTR_NE(k1->cert->key_id, NULL);
388 	k1->cert->principals = calloc(4, sizeof(*k1->cert->principals));
389 	ASSERT_PTR_NE(k1->cert->principals, NULL);
390 	k1->cert->principals[0] = strdup("estragon");
391 	k1->cert->principals[1] = strdup("vladimir");
392 	k1->cert->principals[2] = strdup("pozzo");
393 	k1->cert->principals[3] = strdup("lucky");
394 	ASSERT_PTR_NE(k1->cert->principals[0], NULL);
395 	ASSERT_PTR_NE(k1->cert->principals[1], NULL);
396 	ASSERT_PTR_NE(k1->cert->principals[2], NULL);
397 	ASSERT_PTR_NE(k1->cert->principals[3], NULL);
398 	k1->cert->nprincipals = 4;
399 	k1->cert->valid_after = 0;
400 	k1->cert->valid_before = (u_int64_t)-1;
401 	sshbuf_free(k1->cert->critical);
402 	k1->cert->critical = sshbuf_new();
403 	ASSERT_PTR_NE(k1->cert->critical, NULL);
404 	sshbuf_free(k1->cert->extensions);
405 	k1->cert->extensions = sshbuf_new();
406 	ASSERT_PTR_NE(k1->cert->extensions, NULL);
407 	put_opt(k1->cert->critical, "force-command", "/usr/bin/true");
408 	put_opt(k1->cert->critical, "source-address", "127.0.0.1");
409 	put_opt(k1->cert->extensions, "permit-X11-forwarding", NULL);
410 	put_opt(k1->cert->extensions, "permit-agent-forwarding", NULL);
411 	ASSERT_INT_EQ(sshkey_from_private(k2, &k1->cert->signature_key), 0);
412 	ASSERT_INT_EQ(sshkey_certify(k1, k2, NULL, NULL, NULL), 0);
413 	b = sshbuf_new();
414 	ASSERT_PTR_NE(b, NULL);
415 	ASSERT_INT_EQ(sshkey_putb(k1, b), 0);
416 	ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k3), 0);
417 
418 	sshkey_free(k1);
419 	sshkey_free(k2);
420 	sshkey_free(k3);
421 	sshbuf_reset(b);
422 	TEST_DONE();
423 
424 	TEST_START("sign and verify RSA");
425 	k1 = get_private("rsa_1");
426 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2,
427 	    NULL), 0);
428 	signature_tests(k1, k2, "ssh-rsa");
429 	sshkey_free(k1);
430 	sshkey_free(k2);
431 	TEST_DONE();
432 
433 	TEST_START("sign and verify RSA-SHA256");
434 	k1 = get_private("rsa_1");
435 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2,
436 	    NULL), 0);
437 	signature_tests(k1, k2, "rsa-sha2-256");
438 	sshkey_free(k1);
439 	sshkey_free(k2);
440 	TEST_DONE();
441 
442 	TEST_START("sign and verify RSA-SHA512");
443 	k1 = get_private("rsa_1");
444 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2,
445 	    NULL), 0);
446 	signature_tests(k1, k2, "rsa-sha2-512");
447 	sshkey_free(k1);
448 	sshkey_free(k2);
449 	TEST_DONE();
450 
451 #ifdef WITH_DSA
452 	TEST_START("sign and verify DSA");
453 	k1 = get_private("dsa_1");
454 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("dsa_2.pub"), &k2,
455 	    NULL), 0);
456 	signature_tests(k1, k2, NULL);
457 	sshkey_free(k1);
458 	sshkey_free(k2);
459 	TEST_DONE();
460 #endif
461 
462 	TEST_START("sign and verify ECDSA");
463 	k1 = get_private("ecdsa_1");
464 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_2.pub"), &k2,
465 	    NULL), 0);
466 	signature_tests(k1, k2, NULL);
467 	sshkey_free(k1);
468 	sshkey_free(k2);
469 	TEST_DONE();
470 
471 	TEST_START("sign and verify ED25519");
472 	k1 = get_private("ed25519_1");
473 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_2.pub"), &k2,
474 	    NULL), 0);
475 	signature_tests(k1, k2, NULL);
476 	sshkey_free(k1);
477 	sshkey_free(k2);
478 	TEST_DONE();
479 
480 	TEST_START("nested certificate");
481 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("rsa_1"), &k1), 0);
482 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_1.pub"), &k2,
483 	    NULL), 0);
484 	k3 = get_private("rsa_1");
485 	build_cert(b, k2, "ssh-rsa-cert-v01@openssh.com", k3, k1, NULL);
486 	ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k4),
487 	    SSH_ERR_KEY_CERT_INVALID_SIGN_KEY);
488 	ASSERT_PTR_EQ(k4, NULL);
489 	sshkey_free(k1);
490 	sshkey_free(k2);
491 	sshkey_free(k3);
492 	sshbuf_free(b);
493 	TEST_DONE();
494 
495 }
496