blob: 475a0597bb592beee428500f34bdb1f3553dc3f5 [file] [log] [blame]
/*
* Copyright 2015 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.
*/
#include <openssl/pem.h>
#include "2sysincludes.h"
#include "2common.h"
#include "2id.h"
#include "2rsa.h"
#include "2sha.h"
#include "openssl_compat.h"
#include "util_misc.h"
#include "vb21_common.h"
#include "host_common.h"
#include "host_key2.h"
#include "host_misc2.h"
#include "file_type.h"
#include "futility.h"
int vb2_lookup_hash_alg(const char *str, enum vb2_hash_algorithm *alg)
{
const struct vb2_text_vs_enum *entry;
uint32_t val;
char *e;
/* try string first */
entry = vb2_lookup_by_name(vb2_text_vs_hash, str);
if (entry) {
*alg = entry->num;
return 1;
}
/* fine, try number */
val = strtoul(str, &e, 0);
if (!*str || (e && *e))
/* that's not a number */
return 0;
if (!vb2_lookup_by_num(vb2_text_vs_hash, val))
/* That's not a valid alg */
return 0;
*alg = val;
return 1;
}
enum futil_file_type ft_recognize_vb21_key(uint8_t *buf, uint32_t len)
{
struct vb2_public_key pubkey;
struct vb2_private_key *privkey = 0;
/* The pubkey points into buf, so nothing to free */
if (VB2_SUCCESS == vb21_unpack_key(&pubkey, buf, len))
return FILE_TYPE_VB2_PUBKEY;
/* The private key unpacks into new structs */
if (VB2_SUCCESS == vb21_private_key_unpack(&privkey, buf, len)) {
vb2_private_key_free(privkey);
return FILE_TYPE_VB2_PRIVKEY;
}
return FILE_TYPE_UNKNOWN;
}
static inline void vb2_print_bytes(const void *ptr, uint32_t len)
{
const uint8_t *buf = (const uint8_t *)ptr;
int i;
for (i = 0; i < len; i++)
printf("%02x", *buf++);
}
static int vb2_public_key_sha1sum(struct vb2_public_key *key, uint8_t *digest)
{
struct vb21_packed_key *pkey;
if (vb21_public_key_pack(&pkey, key))
return 0;
vb2_digest_buffer((uint8_t *)pkey + pkey->key_offset, pkey->key_size,
VB2_HASH_SHA1, digest, VB2_SHA1_DIGEST_SIZE);
free(pkey);
return 1;
}
int ft_show_vb21_pubkey(const char *name, uint8_t *buf, uint32_t len,
void *data)
{
struct vb2_public_key key;
uint8_t sha1sum[VB2_SHA1_DIGEST_SIZE];
/* The key's members will point into the state buffer after this. Don't
* free anything. */
if (VB2_SUCCESS != vb21_unpack_key(&key, buf, len))
return 1;
printf("Public Key file: %s\n", name);
printf(" Vboot API: 2.1\n");
printf(" Desc: \"%s\"\n", key.desc);
printf(" Signature Algorithm: %d %s\n", key.sig_alg,
vb2_get_sig_algorithm_name(key.sig_alg));
printf(" Hash Algorithm: %d %s\n", key.hash_alg,
vb2_get_hash_algorithm_name(key.hash_alg));
printf(" Version: 0x%08x\n", key.version);
printf(" ID: ");
vb2_print_bytes(key.id, sizeof(*key.id));
printf("\n");
if (vb2_public_key_sha1sum(&key, sha1sum) &&
memcmp(key.id, sha1sum, sizeof(*key.id))) {
printf(" Key sha1sum: ");
vb2_print_bytes(sha1sum, sizeof(sha1sum));
printf("\n");
}
return 0;
}
static int vb2_private_key_sha1sum(struct vb2_private_key *key, uint8_t *digest)
{
uint8_t *buf;
uint32_t buflen;
if (vb_keyb_from_rsa(key->rsa_private_key, &buf, &buflen))
return 0;
vb2_digest_buffer(buf, buflen, VB2_HASH_SHA1, digest,
VB2_SHA1_DIGEST_SIZE);
free(buf);
return 1;
}
int ft_show_vb21_privkey(const char *name, uint8_t *buf, uint32_t len,
void *data)
{
struct vb2_private_key *key = 0;
uint8_t sha1sum[VB2_SHA1_DIGEST_SIZE];
if (VB2_SUCCESS != vb21_private_key_unpack(&key, buf, len))
return 1;
printf("Private key file: %s\n", name);
printf(" Vboot API: 2.1\n");
printf(" Desc: \"%s\"\n", key->desc ? key->desc : "");
printf(" Signature Algorithm: %d %s\n", key->sig_alg,
vb2_get_sig_algorithm_name(key->sig_alg));
printf(" Hash Algorithm: %d %s\n", key->hash_alg,
vb2_get_hash_algorithm_name(key->hash_alg));
printf(" ID: ");
vb2_print_bytes(&key->id, sizeof(key->id));
printf("\n");
if (vb2_private_key_sha1sum(key, sha1sum) &&
memcmp(&key->id, sha1sum, sizeof(key->id))) {
printf(" Key sha1sum: ");
vb2_print_bytes(sha1sum, sizeof(sha1sum));
printf("\n");
}
vb2_private_key_free(key);
return 0;
}
static RSA *rsa_from_buffer(uint8_t *buf, uint32_t len)
{
BIO *bp;
RSA *rsa_key;
bp = BIO_new_mem_buf(buf, len);
if (!bp)
return 0;
rsa_key = PEM_read_bio_RSAPrivateKey(bp, NULL, NULL, NULL);
if (!rsa_key) {
if (BIO_reset(bp) < 0)
return 0;
rsa_key = PEM_read_bio_RSA_PUBKEY(bp, NULL, NULL, NULL);
}
if (!rsa_key) {
BIO_free(bp);
return 0;
}
BIO_free(bp);
return rsa_key;
}
enum futil_file_type ft_recognize_pem(uint8_t *buf, uint32_t len)
{
RSA *rsa_key = rsa_from_buffer(buf, len);
if (rsa_key) {
RSA_free(rsa_key);
return FILE_TYPE_PEM;
}
return FILE_TYPE_UNKNOWN;
}
int ft_show_pem(const char *name, uint8_t *buf, uint32_t len, void *data)
{
RSA *rsa_key;
uint8_t *keyb;
uint8_t digest[VB2_SHA1_DIGEST_SIZE];
uint32_t keyb_len;
int i, bits;
const BIGNUM *rsa_key_n, *rsa_key_d;
/* We're called only after ft_recognize_pem, so this should work. */
rsa_key = rsa_from_buffer(buf, len);
if (!rsa_key)
DIE;
/* Use to presence of the private exponent to decide if it's public */
RSA_get0_key(rsa_key, &rsa_key_n, NULL, &rsa_key_d);
printf("%s Key file: %s\n", rsa_key_d ? "Private" : "Public",
name);
bits = BN_num_bits(rsa_key_n);
printf(" Key length: %d\n", bits);
if (vb_keyb_from_rsa(rsa_key, &keyb, &keyb_len)) {
printf(" Key sha1sum: <error>");
RSA_free(rsa_key);
return 1;
}
printf(" Key sha1sum: ");
vb2_digest_buffer(keyb, keyb_len, VB2_HASH_SHA1,
digest, sizeof(digest));
for (i = 0; i < sizeof(digest); i++)
printf("%02x", digest[i]);
printf("\n");
free(keyb);
RSA_free(rsa_key);
return 0;
}