Gaurav Shah | e178fd9 | 2010-02-05 11:44:58 -0800 | [diff] [blame] | 1 | /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved. |
| 2 | * Use of this source code is governed by a BSD-style license that can be |
| 3 | * found in the LICENSE file. |
| 4 | * |
| 5 | * Utility functions for message digest functions. |
| 6 | */ |
| 7 | |
| 8 | #include "padding.h" |
| 9 | #include "rsa_utility.h" |
Gaurav Shah | 08df9b8 | 2010-02-23 16:16:23 -0800 | [diff] [blame^] | 10 | #include "sha_utility.h" |
Gaurav Shah | e178fd9 | 2010-02-05 11:44:58 -0800 | [diff] [blame] | 11 | #include "utility.h" |
| 12 | |
| 13 | int RSAProcessedKeySize(int algorithm) { |
| 14 | int key_len = siglen_map[algorithm] * sizeof(uint32_t); /* Key length in |
| 15 | * bytes. */ |
| 16 | /* Total size needed by a RSAPublicKey structure is = |
| 17 | * 2 * key_len bytes for the n and rr arrays |
| 18 | * + sizeof len + sizeof n0inv. |
| 19 | */ |
| 20 | return (2 * key_len + sizeof(int) + sizeof(uint32_t)); |
| 21 | } |
| 22 | |
Gaurav Shah | 08df9b8 | 2010-02-23 16:16:23 -0800 | [diff] [blame^] | 23 | void RSAPublicKeyFree(RSAPublicKey* key) { |
| 24 | if (key) { |
| 25 | Free(key->n); |
| 26 | Free(key->rr); |
| 27 | Free(key); |
| 28 | } |
| 29 | } |
| 30 | |
| 31 | RSAPublicKey* RSAPublicKeyFromBuf(const uint8_t* buf, int len) { |
Gaurav Shah | e178fd9 | 2010-02-05 11:44:58 -0800 | [diff] [blame] | 32 | RSAPublicKey* key = (RSAPublicKey*) Malloc(sizeof(RSAPublicKey)); |
| 33 | MemcpyState st; |
| 34 | int key_len; |
| 35 | |
Gaurav Shah | 08df9b8 | 2010-02-23 16:16:23 -0800 | [diff] [blame^] | 36 | st.remaining_buf = (uint8_t*) buf; |
Gaurav Shah | e178fd9 | 2010-02-05 11:44:58 -0800 | [diff] [blame] | 37 | st.remaining_len = len; |
| 38 | |
| 39 | StatefulMemcpy(&st, &key->len, sizeof(key->len)); |
| 40 | key_len = key->len * sizeof(uint32_t); /* key length in bytes. */ |
| 41 | key->n = (uint32_t*) Malloc(key_len); |
| 42 | key->rr = (uint32_t*) Malloc(key_len); |
| 43 | |
| 44 | StatefulMemcpy(&st, &key->n0inv, sizeof(key->n0inv)); |
| 45 | StatefulMemcpy(&st, key->n, key_len); |
| 46 | StatefulMemcpy(&st, key->rr, key_len); |
| 47 | if (st.remaining_len != 0) { /* Underrun or overrun. */ |
| 48 | Free(key->n); |
| 49 | Free(key->rr); |
| 50 | Free(key); |
| 51 | return NULL; |
| 52 | } |
| 53 | |
| 54 | return key; |
| 55 | } |
Gaurav Shah | 08df9b8 | 2010-02-23 16:16:23 -0800 | [diff] [blame^] | 56 | |
| 57 | int RSAVerifyBinary_f(const uint8_t* key_blob, |
| 58 | const RSAPublicKey* key, |
| 59 | const uint8_t* buf, |
| 60 | int len, |
| 61 | const uint8_t* sig, |
| 62 | int algorithm) { |
| 63 | RSAPublicKey* verification_key = NULL; |
| 64 | uint8_t* digest = NULL; |
| 65 | int key_size; |
| 66 | int sig_size; |
| 67 | int success; |
| 68 | |
| 69 | if (algorithm >= kNumAlgorithms) |
| 70 | return 0; /* Invalid algorithm. */ |
| 71 | key_size = RSAProcessedKeySize(algorithm); |
| 72 | sig_size = siglen_map[algorithm] * sizeof(uint32_t); |
| 73 | |
| 74 | if (key_blob && !key) |
| 75 | verification_key = RSAPublicKeyFromBuf(key_blob, key_size); |
| 76 | else if (!key_blob && key) |
| 77 | verification_key = (RSAPublicKey*) key; /* Supress const warning. */ |
| 78 | else |
| 79 | return 0; /* Both can't be NULL or non-NULL. */ |
| 80 | |
| 81 | digest = DigestBuf(buf, len, algorithm); |
| 82 | success = RSA_verify(verification_key, sig, sig_size, algorithm, digest); |
| 83 | |
| 84 | Free(digest); |
| 85 | if (!key) |
| 86 | RSAPublicKeyFree(verification_key); /* Only free if we allocated it. */ |
| 87 | return success; |
| 88 | } |