tests/vb21_host_key_tests.c - mirrors/cros/chromiumos/platform/vboot_reference - Git at Google

 /* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Tests for host library vboot2 key functions
  */

 #include <stdio.h>
 #include <unistd.h>

 #include "2sysincludes.h"
 #include "2common.h"
 #include "2rsa.h"
 #include "vb21_common.h"
 #include "host_common.h"
 #include "host_key2.h"

 #include "test_common.h"

 /* Test only the algorithms we use */
 struct alg_combo {
 	const char *name;
 	enum vb2_signature_algorithm sig_alg;
 	enum vb2_hash_algorithm hash_alg;
 };

 static const struct alg_combo test_algs[] = {
 	{"RSA2048/SHA-256", VB2_SIG_RSA2048, VB2_HASH_SHA256},
 	{"RSA4096/SHA-256", VB2_SIG_RSA4096, VB2_HASH_SHA256},
 	{"RSA8192/SHA-512", VB2_SIG_RSA8192, VB2_HASH_SHA512},
 };

 static void private_key_tests(const struct alg_combo *combo,
 			      const char *pemfile, const char *temp_dir)
 {
 	struct vb2_private_key *key, *k2;
 	const struct vb2_private_key *ckey;
 	struct vb21_packed_private_key *pkey;
 	char *testfile;
 	const char notapem[] = "not_a_pem";
 	const char testdesc[] = "test desc";
 	const struct vb2_id test_id = {.raw = {0xaa}};
 	uint8_t *buf, *buf2;
 	uint32_t bufsize;

 	xasprintf(&testfile, "%s/test.vbprik2", temp_dir);

 	TEST_SUCC(vb2_private_key_read_pem(&key, pemfile), "Read pem - good");
 	TEST_PTR_NEQ(key, NULL, "  key_ptr");
 	TEST_PTR_NEQ(key->rsa_private_key, NULL, "  rsa_private_key");
 	TEST_PTR_EQ(key->desc, NULL, "  desc");
 	vb2_private_key_free(key);

 	TEST_EQ(vb2_private_key_read_pem(&key, "no_such_key"),
 		VB2_ERROR_READ_PEM_FILE_OPEN, "Read pem - no key");
 	TEST_PTR_EQ(key, NULL, "  key_ptr");

 	vb2_write_file(testfile, (const uint8_t *)notapem, sizeof(notapem));
 	TEST_EQ(vb2_private_key_read_pem(&key, testfile),
 		VB2_ERROR_READ_PEM_RSA, "Read pem - not a pem");
 	unlink(testfile);

 	TEST_SUCC(vb2_private_key_read_pem(&key, pemfile), "Read pem - good2");
 	TEST_SUCC(vb2_private_key_set_desc(key, testdesc), "Set desc");
 	TEST_PTR_NEQ(key->desc, NULL, "  desc");
 	TEST_PTR_NEQ(key->desc, testdesc, "  made a copy");
 	TEST_EQ(strcmp(key->desc, testdesc), 0, "  right contents");
 	TEST_SUCC(vb2_private_key_set_desc(key, NULL), "Clear desc");
 	TEST_PTR_EQ(key->desc, NULL, "  desc");
 	TEST_SUCC(vb2_private_key_set_desc(key, testdesc), "Set desc");
 	vb2_private_key_free(key);

 	TEST_SUCC(vb2_private_key_read_pem(&key, pemfile), "Read pem - good3");
 	TEST_SUCC(vb2_private_key_set_desc(key, testdesc), "Set desc");
 	key->hash_alg = combo->hash_alg;
 	key->sig_alg = combo->sig_alg;
 	key->id = test_id;

 	unlink(testfile);

 	TEST_EQ(vb21_private_key_read(&k2, testfile),
 		VB2_ERROR_READ_FILE_OPEN, "Read key no file");
 	TEST_EQ(vb21_private_key_write(key, "no/such/dir"),
 		VB2_ERROR_PRIVATE_KEY_WRITE_FILE, "Write key to bad path");

 	TEST_SUCC(vb21_private_key_write(key, testfile), "Write key good");
 	TEST_SUCC(vb21_private_key_read(&k2, testfile), "Read key good");
 	TEST_PTR_NEQ(k2, NULL, "  key_ptr");
 	TEST_EQ(k2->sig_alg, key->sig_alg, "  sig alg");
 	TEST_EQ(k2->hash_alg, key->hash_alg, "  hash alg");
 	TEST_EQ(memcmp(&k2->id, &key->id, sizeof(k2->id)), 0, "  id");
 	TEST_EQ(strcmp(k2->desc, testdesc), 0, "  desc");
 	vb2_private_key_free(k2);

 	TEST_SUCC(vb2_read_file(testfile, &buf, &bufsize), "Read key raw");
 	pkey = (struct vb21_packed_private_key *)buf;

 	/* Make a backup of the good buffer so we can mangle it */
 	buf2 = malloc(bufsize);
 	memcpy(buf2, buf, bufsize);

 	TEST_SUCC(vb21_private_key_unpack(&k2, buf, bufsize),
 		  "Unpack private key good");
 	vb2_private_key_free(k2);

 	memcpy(buf, buf2, bufsize);
 	pkey->c.magic = VB21_MAGIC_PACKED_KEY;
 	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
 		VB2_ERROR_UNPACK_PRIVATE_KEY_MAGIC,
 		"Unpack private key bad magic");
 	TEST_PTR_EQ(k2, NULL, "  key_ptr");

 	memcpy(buf, buf2, bufsize);
 	pkey->c.desc_size++;
 	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
 		VB2_ERROR_UNPACK_PRIVATE_KEY_HEADER,
 		"Unpack private key bad header");

 	memcpy(buf, buf2, bufsize);
 	pkey->key_size += pkey->c.total_size;
 	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
 		VB2_ERROR_UNPACK_PRIVATE_KEY_DATA,
 		"Unpack private key bad data size");

 	memcpy(buf, buf2, bufsize);
 	pkey->c.struct_version_major++;
 	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
 		VB2_ERROR_UNPACK_PRIVATE_KEY_STRUCT_VERSION,
 		"Unpack private key bad struct version");

 	memcpy(buf, buf2, bufsize);
 	pkey->c.struct_version_minor++;
 	TEST_SUCC(vb21_private_key_unpack(&k2, buf, bufsize),
 		  "Unpack private key minor version");
 	vb2_private_key_free(k2);

 	memcpy(buf, buf2, bufsize);
 	pkey->key_size -= 32;
 	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
 		VB2_ERROR_UNPACK_PRIVATE_KEY_RSA,
 		"Unpack private key bad rsa data");

 	memcpy(buf, buf2, bufsize);
 	pkey->sig_alg = VB2_SIG_NONE;
 	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
 		VB2_ERROR_UNPACK_PRIVATE_KEY_HASH,
 		"Unpack private key hash but has data");

 	free(buf);
 	free(buf2);
 	unlink(testfile);

 	TEST_EQ(vb2_private_key_hash(&ckey, VB2_HASH_INVALID),
 		VB2_ERROR_PRIVATE_KEY_HASH,
 		"Hash key invalid");
 	TEST_PTR_EQ(ckey, NULL, "  key_ptr");

 	TEST_SUCC(vb2_private_key_hash(&ckey, combo->hash_alg), "Hash key");
 	TEST_PTR_NEQ(ckey, NULL, "  key_ptr");
 	TEST_EQ(ckey->hash_alg, combo->hash_alg, "  hash_alg");
 	TEST_EQ(ckey->sig_alg, VB2_SIG_NONE, "  sig_alg");
 	TEST_EQ(memcmp(&ckey->id, vb2_hash_id(combo->hash_alg),
 		       sizeof(ckey->id)), 0, "  id");

 	TEST_SUCC(vb21_private_key_write(ckey, testfile), "Write hash key");
 	TEST_SUCC(vb21_private_key_read(&key, testfile), "Read hash key");
 	unlink(testfile);
 }

 static void public_key_tests(const struct alg_combo *combo,
 			     const char *keybfile, const char *temp_dir)
 {
 	struct vb2_public_key *key, k2;
 	struct vb21_packed_key *pkey;
 	char *testfile;
 	const char *testdesc = "test desc";
 	const struct vb2_id test_id = {.raw = {0xbb}};
 	const uint32_t test_version = 0xcc01;
 	uint8_t *buf;
 	uint32_t bufsize;

 	xasprintf(&testfile, "%s/test.vbprik2", temp_dir);

 	TEST_EQ(vb2_public_key_read_keyb(&key, "no_such_key"),
 		VB2_ERROR_READ_KEYB_DATA, "Read keyb - no file");
 	TEST_PTR_EQ(key, NULL, "  key_ptr");

 	TEST_SUCC(vb2_public_key_read_keyb(&key, keybfile), "Read keyb - good");
 	TEST_PTR_NEQ(key, NULL, "  key_ptr");
 	TEST_EQ(key->sig_alg, combo->sig_alg, "  sig_alg");
 	TEST_PTR_EQ(key->desc, NULL, "  desc");
 	vb2_public_key_free(key);

 	bufsize = vb2_packed_key_size(combo->sig_alg);
 	buf = calloc(1, bufsize);

 	vb2_write_file(testfile, buf, bufsize - 1);
 	TEST_EQ(vb2_public_key_read_keyb(&key, testfile),
 		VB2_ERROR_READ_KEYB_SIZE, "Read keyb - bad size");
 	unlink(testfile);

 	vb2_write_file(testfile, buf, bufsize);
 	free(buf);
 	TEST_EQ(vb2_public_key_read_keyb(&key, testfile),
 		VB2_ERROR_READ_KEYB_UNPACK, "Read keyb - unpack");
 	unlink(testfile);

 	TEST_SUCC(vb2_public_key_read_keyb(&key, keybfile), "Read keyb 2");
 	TEST_SUCC(vb2_public_key_set_desc(key, testdesc), "Set desc");
 	TEST_PTR_NEQ(key->desc, NULL, "  desc");
 	TEST_PTR_NEQ(key->desc, testdesc, "  made a copy");
 	TEST_EQ(strcmp(key->desc, testdesc), 0, "  right contents");
 	TEST_SUCC(vb2_public_key_set_desc(key, NULL), "Clear desc");
 	TEST_PTR_EQ(key->desc, NULL, "  desc");
 	TEST_SUCC(vb2_public_key_set_desc(key, testdesc), "Set desc");
 	vb2_public_key_free(key);

 	TEST_SUCC(vb2_public_key_read_keyb(&key, keybfile), "Read keyb 3");
 	TEST_SUCC(vb2_public_key_set_desc(key, testdesc), "Set desc");
 	key->hash_alg = combo->hash_alg;
 	key->id = &test_id;
 	key->version = test_version;

 	TEST_SUCC(vb21_public_key_pack(&pkey, key), "Pack public key");
 	TEST_PTR_NEQ(pkey, NULL, "  key_ptr");
 	TEST_EQ(pkey->hash_alg, key->hash_alg, "  hash_alg");
 	TEST_EQ(pkey->sig_alg, key->sig_alg, "  sig_alg");
 	TEST_EQ(pkey->key_version, key->version, "  version");
 	TEST_EQ(memcmp(&pkey->id, key->id, sizeof(pkey->id)), 0,
 		"  id");
 	TEST_EQ(strcmp(vb21_common_desc(pkey), key->desc), 0, "  desc");
 	TEST_SUCC(vb21_unpack_key(&k2, (uint8_t *)pkey, pkey->c.total_size),
 		  "Unpack public key");
 	TEST_EQ(key->arrsize, k2.arrsize, "  arrsize");
 	TEST_EQ(key->n0inv, k2.n0inv, "  n0inv");
 	TEST_EQ(memcmp(key->n, k2.n, key->arrsize * sizeof(uint32_t)), 0,
 		"  n");
 	TEST_EQ(memcmp(key->rr, k2.rr, key->arrsize * sizeof(uint32_t)), 0,
 		"  rr");

 	TEST_SUCC(vb21_write_object(testfile, pkey), "Write packed key");
 	free(pkey);

 	TEST_SUCC(vb21_packed_key_read(&pkey, testfile), "Read packed key");
 	TEST_PTR_NEQ(pkey, NULL, "  key_ptr");
 	unlink(testfile);

 	pkey->hash_alg = VB2_HASH_INVALID;
 	TEST_SUCC(vb21_write_object(testfile, pkey), "Write bad packed key");
 	free(pkey);

 	TEST_EQ(vb21_packed_key_read(&pkey, testfile),
 		VB2_ERROR_READ_PACKED_KEY, "Read bad packed key");
 	TEST_PTR_EQ(pkey, NULL, "  key_ptr");
 	unlink(testfile);

 	TEST_EQ(vb21_packed_key_read(&pkey, testfile),
 		VB2_ERROR_READ_PACKED_KEY_DATA, "Read missing packed key");

 	key->sig_alg = VB2_SIG_INVALID;
 	TEST_EQ(vb21_public_key_pack(&pkey, key),
 		VB2_ERROR_PUBLIC_KEY_PACK_SIZE,
 		"Pack invalid sig alg");
 	vb2_public_key_free(key);

 	TEST_EQ(vb2_public_key_hash(&k2, VB2_HASH_INVALID),
 		VB2_ERROR_PUBLIC_KEY_HASH,
 		"Hash key invalid");

 	TEST_SUCC(vb2_public_key_hash(&k2, combo->hash_alg), "Hash key");
 	TEST_EQ(k2.hash_alg, combo->hash_alg, "  hash_alg");
 	TEST_EQ(k2.sig_alg, VB2_SIG_NONE, "  sig_alg");
 	TEST_EQ(memcmp(k2.id, vb2_hash_id(combo->hash_alg),
 		       sizeof(*k2.id)), 0, "  id");

 	TEST_SUCC(vb21_public_key_pack(&pkey, &k2), "Pack public hash key");
 	TEST_PTR_NEQ(pkey, NULL, "  key_ptr");
 	TEST_SUCC(vb21_unpack_key(&k2, (uint8_t *)pkey, pkey->c.total_size),
 		  "Unpack public hash key");
 	free(pkey);
 }

 static int test_algorithm(const struct alg_combo *combo, const char *keys_dir,
                           const char *temp_dir)
 {
 	int rsa_bits = vb2_rsa_sig_size(combo->sig_alg) * 8;
 	char *pemfile;
 	char *keybfile;

 	printf("***Testing algorithm: %s\n", combo->name);

 	xasprintf(&pemfile, "%s/key_rsa%d.pem", keys_dir, rsa_bits);
 	xasprintf(&keybfile, "%s/key_rsa%d.keyb", keys_dir, rsa_bits);

 	private_key_tests(combo, pemfile, temp_dir);
 	public_key_tests(combo, keybfile, temp_dir);

 	free(pemfile);
 	free(keybfile);

 	return 0;
 }

 int main(int argc, char *argv[]) {

 	if (argc == 3) {
 		const char *keys_dir = argv[1];
 		const char *temp_dir = argv[2];
 		int i;

 		for (i = 0; i < ARRAY_SIZE(test_algs); i++) {
 			if (test_algorithm(test_algs + i, keys_dir, temp_dir))
 				return 1;
 		}
 	} else {
 		fprintf(stderr, "Usage: %s <keys_dir> <temp_dir>\n", argv[0]);
 		return -1;
 	}

 	return gTestSuccess ? 0 : 255;
 }
	/* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*
	* Tests for host library vboot2 key functions
	*/

	#include <stdio.h>
	#include <unistd.h>

	#include "2sysincludes.h"
	#include "2common.h"
	#include "2rsa.h"
	#include "vb21_common.h"
	#include "host_common.h"
	#include "host_key2.h"

	#include "test_common.h"

	/* Test only the algorithms we use */
	struct alg_combo {
	const char *name;
	enum vb2_signature_algorithm sig_alg;
	enum vb2_hash_algorithm hash_alg;
	};

	static const struct alg_combo test_algs[] = {
	{"RSA2048/SHA-256", VB2_SIG_RSA2048, VB2_HASH_SHA256},
	{"RSA4096/SHA-256", VB2_SIG_RSA4096, VB2_HASH_SHA256},
	{"RSA8192/SHA-512", VB2_SIG_RSA8192, VB2_HASH_SHA512},
	};

	static void private_key_tests(const struct alg_combo *combo,
	const char pemfile, const char temp_dir)
	{
	struct vb2_private_key key, k2;
	const struct vb2_private_key *ckey;
	struct vb21_packed_private_key *pkey;
	char *testfile;
	const char notapem[] = "not_a_pem";
	const char testdesc[] = "test desc";
	const struct vb2_id test_id = {.raw = {0xaa}};
	uint8_t buf, buf2;
	uint32_t bufsize;

	xasprintf(&testfile, "%s/test.vbprik2", temp_dir);

	TEST_SUCC(vb2_private_key_read_pem(&key, pemfile), "Read pem - good");
	TEST_PTR_NEQ(key, NULL, " key_ptr");
	TEST_PTR_NEQ(key->rsa_private_key, NULL, " rsa_private_key");
	TEST_PTR_EQ(key->desc, NULL, " desc");
	vb2_private_key_free(key);

	TEST_EQ(vb2_private_key_read_pem(&key, "no_such_key"),
	VB2_ERROR_READ_PEM_FILE_OPEN, "Read pem - no key");
	TEST_PTR_EQ(key, NULL, " key_ptr");

	vb2_write_file(testfile, (const uint8_t *)notapem, sizeof(notapem));
	TEST_EQ(vb2_private_key_read_pem(&key, testfile),
	VB2_ERROR_READ_PEM_RSA, "Read pem - not a pem");
	unlink(testfile);

	TEST_SUCC(vb2_private_key_read_pem(&key, pemfile), "Read pem - good2");
	TEST_SUCC(vb2_private_key_set_desc(key, testdesc), "Set desc");
	TEST_PTR_NEQ(key->desc, NULL, " desc");
	TEST_PTR_NEQ(key->desc, testdesc, " made a copy");
	TEST_EQ(strcmp(key->desc, testdesc), 0, " right contents");
	TEST_SUCC(vb2_private_key_set_desc(key, NULL), "Clear desc");
	TEST_PTR_EQ(key->desc, NULL, " desc");
	TEST_SUCC(vb2_private_key_set_desc(key, testdesc), "Set desc");
	vb2_private_key_free(key);

	TEST_SUCC(vb2_private_key_read_pem(&key, pemfile), "Read pem - good3");
	TEST_SUCC(vb2_private_key_set_desc(key, testdesc), "Set desc");
	key->hash_alg = combo->hash_alg;
	key->sig_alg = combo->sig_alg;
	key->id = test_id;

	unlink(testfile);

	TEST_EQ(vb21_private_key_read(&k2, testfile),
	VB2_ERROR_READ_FILE_OPEN, "Read key no file");
	TEST_EQ(vb21_private_key_write(key, "no/such/dir"),
	VB2_ERROR_PRIVATE_KEY_WRITE_FILE, "Write key to bad path");

	TEST_SUCC(vb21_private_key_write(key, testfile), "Write key good");
	TEST_SUCC(vb21_private_key_read(&k2, testfile), "Read key good");
	TEST_PTR_NEQ(k2, NULL, " key_ptr");
	TEST_EQ(k2->sig_alg, key->sig_alg, " sig alg");
	TEST_EQ(k2->hash_alg, key->hash_alg, " hash alg");
	TEST_EQ(memcmp(&k2->id, &key->id, sizeof(k2->id)), 0, " id");
	TEST_EQ(strcmp(k2->desc, testdesc), 0, " desc");
	vb2_private_key_free(k2);

	TEST_SUCC(vb2_read_file(testfile, &buf, &bufsize), "Read key raw");
	pkey = (struct vb21_packed_private_key *)buf;

	/* Make a backup of the good buffer so we can mangle it */
	buf2 = malloc(bufsize);
	memcpy(buf2, buf, bufsize);

	TEST_SUCC(vb21_private_key_unpack(&k2, buf, bufsize),
	"Unpack private key good");
	vb2_private_key_free(k2);

	memcpy(buf, buf2, bufsize);
	pkey->c.magic = VB21_MAGIC_PACKED_KEY;
	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
	VB2_ERROR_UNPACK_PRIVATE_KEY_MAGIC,
	"Unpack private key bad magic");
	TEST_PTR_EQ(k2, NULL, " key_ptr");

	memcpy(buf, buf2, bufsize);
	pkey->c.desc_size++;
	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
	VB2_ERROR_UNPACK_PRIVATE_KEY_HEADER,
	"Unpack private key bad header");

	memcpy(buf, buf2, bufsize);
	pkey->key_size += pkey->c.total_size;
	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
	VB2_ERROR_UNPACK_PRIVATE_KEY_DATA,
	"Unpack private key bad data size");

	memcpy(buf, buf2, bufsize);
	pkey->c.struct_version_major++;
	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
	VB2_ERROR_UNPACK_PRIVATE_KEY_STRUCT_VERSION,
	"Unpack private key bad struct version");

	memcpy(buf, buf2, bufsize);
	pkey->c.struct_version_minor++;
	TEST_SUCC(vb21_private_key_unpack(&k2, buf, bufsize),
	"Unpack private key minor version");
	vb2_private_key_free(k2);

	memcpy(buf, buf2, bufsize);
	pkey->key_size -= 32;
	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
	VB2_ERROR_UNPACK_PRIVATE_KEY_RSA,
	"Unpack private key bad rsa data");

	memcpy(buf, buf2, bufsize);
	pkey->sig_alg = VB2_SIG_NONE;
	TEST_EQ(vb21_private_key_unpack(&k2, buf, bufsize),
	VB2_ERROR_UNPACK_PRIVATE_KEY_HASH,
	"Unpack private key hash but has data");

	free(buf);
	free(buf2);
	unlink(testfile);

	TEST_EQ(vb2_private_key_hash(&ckey, VB2_HASH_INVALID),
	VB2_ERROR_PRIVATE_KEY_HASH,
	"Hash key invalid");
	TEST_PTR_EQ(ckey, NULL, " key_ptr");

	TEST_SUCC(vb2_private_key_hash(&ckey, combo->hash_alg), "Hash key");
	TEST_PTR_NEQ(ckey, NULL, " key_ptr");
	TEST_EQ(ckey->hash_alg, combo->hash_alg, " hash_alg");
	TEST_EQ(ckey->sig_alg, VB2_SIG_NONE, " sig_alg");
	TEST_EQ(memcmp(&ckey->id, vb2_hash_id(combo->hash_alg),
	sizeof(ckey->id)), 0, " id");

	TEST_SUCC(vb21_private_key_write(ckey, testfile), "Write hash key");
	TEST_SUCC(vb21_private_key_read(&key, testfile), "Read hash key");
	unlink(testfile);
	}

	static void public_key_tests(const struct alg_combo *combo,
	const char keybfile, const char temp_dir)
	{
	struct vb2_public_key *key, k2;
	struct vb21_packed_key *pkey;
	char *testfile;
	const char *testdesc = "test desc";
	const struct vb2_id test_id = {.raw = {0xbb}};
	const uint32_t test_version = 0xcc01;
	uint8_t *buf;
	uint32_t bufsize;

	xasprintf(&testfile, "%s/test.vbprik2", temp_dir);

	TEST_EQ(vb2_public_key_read_keyb(&key, "no_such_key"),
	VB2_ERROR_READ_KEYB_DATA, "Read keyb - no file");
	TEST_PTR_EQ(key, NULL, " key_ptr");

	TEST_SUCC(vb2_public_key_read_keyb(&key, keybfile), "Read keyb - good");
	TEST_PTR_NEQ(key, NULL, " key_ptr");
	TEST_EQ(key->sig_alg, combo->sig_alg, " sig_alg");
	TEST_PTR_EQ(key->desc, NULL, " desc");
	vb2_public_key_free(key);

	bufsize = vb2_packed_key_size(combo->sig_alg);
	buf = calloc(1, bufsize);

	vb2_write_file(testfile, buf, bufsize - 1);
	TEST_EQ(vb2_public_key_read_keyb(&key, testfile),
	VB2_ERROR_READ_KEYB_SIZE, "Read keyb - bad size");
	unlink(testfile);

	vb2_write_file(testfile, buf, bufsize);
	free(buf);
	TEST_EQ(vb2_public_key_read_keyb(&key, testfile),
	VB2_ERROR_READ_KEYB_UNPACK, "Read keyb - unpack");
	unlink(testfile);

	TEST_SUCC(vb2_public_key_read_keyb(&key, keybfile), "Read keyb 2");
	TEST_SUCC(vb2_public_key_set_desc(key, testdesc), "Set desc");
	TEST_PTR_NEQ(key->desc, NULL, " desc");
	TEST_PTR_NEQ(key->desc, testdesc, " made a copy");
	TEST_EQ(strcmp(key->desc, testdesc), 0, " right contents");
	TEST_SUCC(vb2_public_key_set_desc(key, NULL), "Clear desc");
	TEST_PTR_EQ(key->desc, NULL, " desc");
	TEST_SUCC(vb2_public_key_set_desc(key, testdesc), "Set desc");
	vb2_public_key_free(key);

	TEST_SUCC(vb2_public_key_read_keyb(&key, keybfile), "Read keyb 3");
	TEST_SUCC(vb2_public_key_set_desc(key, testdesc), "Set desc");
	key->hash_alg = combo->hash_alg;
	key->id = &test_id;
	key->version = test_version;

	TEST_SUCC(vb21_public_key_pack(&pkey, key), "Pack public key");
	TEST_PTR_NEQ(pkey, NULL, " key_ptr");
	TEST_EQ(pkey->hash_alg, key->hash_alg, " hash_alg");
	TEST_EQ(pkey->sig_alg, key->sig_alg, " sig_alg");
	TEST_EQ(pkey->key_version, key->version, " version");
	TEST_EQ(memcmp(&pkey->id, key->id, sizeof(pkey->id)), 0,
	" id");
	TEST_EQ(strcmp(vb21_common_desc(pkey), key->desc), 0, " desc");
	TEST_SUCC(vb21_unpack_key(&k2, (uint8_t *)pkey, pkey->c.total_size),
	"Unpack public key");
	TEST_EQ(key->arrsize, k2.arrsize, " arrsize");
	TEST_EQ(key->n0inv, k2.n0inv, " n0inv");
	TEST_EQ(memcmp(key->n, k2.n, key->arrsize * sizeof(uint32_t)), 0,
	" n");
	TEST_EQ(memcmp(key->rr, k2.rr, key->arrsize * sizeof(uint32_t)), 0,
	" rr");

	TEST_SUCC(vb21_write_object(testfile, pkey), "Write packed key");
	free(pkey);

	TEST_SUCC(vb21_packed_key_read(&pkey, testfile), "Read packed key");
	TEST_PTR_NEQ(pkey, NULL, " key_ptr");
	unlink(testfile);

	pkey->hash_alg = VB2_HASH_INVALID;
	TEST_SUCC(vb21_write_object(testfile, pkey), "Write bad packed key");
	free(pkey);

	TEST_EQ(vb21_packed_key_read(&pkey, testfile),
	VB2_ERROR_READ_PACKED_KEY, "Read bad packed key");
	TEST_PTR_EQ(pkey, NULL, " key_ptr");
	unlink(testfile);

	TEST_EQ(vb21_packed_key_read(&pkey, testfile),
	VB2_ERROR_READ_PACKED_KEY_DATA, "Read missing packed key");

	key->sig_alg = VB2_SIG_INVALID;
	TEST_EQ(vb21_public_key_pack(&pkey, key),
	VB2_ERROR_PUBLIC_KEY_PACK_SIZE,
	"Pack invalid sig alg");
	vb2_public_key_free(key);

	TEST_EQ(vb2_public_key_hash(&k2, VB2_HASH_INVALID),
	VB2_ERROR_PUBLIC_KEY_HASH,
	"Hash key invalid");

	TEST_SUCC(vb2_public_key_hash(&k2, combo->hash_alg), "Hash key");
	TEST_EQ(k2.hash_alg, combo->hash_alg, " hash_alg");
	TEST_EQ(k2.sig_alg, VB2_SIG_NONE, " sig_alg");
	TEST_EQ(memcmp(k2.id, vb2_hash_id(combo->hash_alg),
	sizeof(*k2.id)), 0, " id");

	TEST_SUCC(vb21_public_key_pack(&pkey, &k2), "Pack public hash key");
	TEST_PTR_NEQ(pkey, NULL, " key_ptr");
	TEST_SUCC(vb21_unpack_key(&k2, (uint8_t *)pkey, pkey->c.total_size),
	"Unpack public hash key");
	free(pkey);
	}

	static int test_algorithm(const struct alg_combo combo, const char keys_dir,
	const char *temp_dir)
	{
	int rsa_bits = vb2_rsa_sig_size(combo->sig_alg) * 8;
	char *pemfile;
	char *keybfile;

	printf("***Testing algorithm: %s\n", combo->name);

	xasprintf(&pemfile, "%s/key_rsa%d.pem", keys_dir, rsa_bits);
	xasprintf(&keybfile, "%s/key_rsa%d.keyb", keys_dir, rsa_bits);

	private_key_tests(combo, pemfile, temp_dir);
	public_key_tests(combo, keybfile, temp_dir);

	free(pemfile);
	free(keybfile);

	return 0;
	}

	int main(int argc, char *argv[]) {

	if (argc == 3) {
	const char *keys_dir = argv[1];
	const char *temp_dir = argv[2];
	int i;

	for (i = 0; i < ARRAY_SIZE(test_algs); i++) {
	if (test_algorithm(test_algs + i, keys_dir, temp_dir))
	return 1;
	}
	} else {
	fprintf(stderr, "Usage: %s <keys_dir> <temp_dir>\n", argv[0]);
	return -1;
	}

	return gTestSuccess ? 0 : 255;
	}