145 lines
4.7 KiB
C
145 lines
4.7 KiB
C
/* Copyright (c) (2016,2018,2019,2020) Apple Inc. All rights reserved.
|
||
*
|
||
* corecrypto is licensed under Apple Inc.’s Internal Use License Agreement (which
|
||
* is contained in the License.txt file distributed with corecrypto) and only to
|
||
* people who accept that license. IMPORTANT: Any license rights granted to you by
|
||
* Apple Inc. (if any) are limited to internal use within your organization only on
|
||
* devices and computers you own or control, for the sole purpose of verifying the
|
||
* security characteristics and correct functioning of the Apple Software. You may
|
||
* not, directly or indirectly, redistribute the Apple Software or any portions thereof.
|
||
*/
|
||
|
||
#include <corecrypto/ccrsa_priv.h>
|
||
#include <corecrypto/ccrsa.h>
|
||
#include <corecrypto/ccdigest.h>
|
||
#include <corecrypto/ccsha1.h>
|
||
#include <corecrypto/ccrng_sequence.h>
|
||
#include <corecrypto/ccsha2.h>
|
||
#include "crypto_test_rsapkcs1v15.h"
|
||
#include "testmore.h"
|
||
|
||
struct ccrsa_verify_vector {
|
||
const struct ccdigest_info *di;
|
||
unsigned long modlen; // in bits
|
||
const void *mod;
|
||
cc_unit exp;
|
||
const void *digest; /* length governed by di */
|
||
unsigned long msglen; // in bytes
|
||
const void *msg;
|
||
unsigned long siglen; // in bytes - should be modlen/8
|
||
const void *sig;
|
||
bool valid; // expected result
|
||
};
|
||
|
||
static int ccrsa_test_verify_pkcs1v15_vector(const struct ccrsa_verify_vector *v)
|
||
{
|
||
bool ok;
|
||
int rc;
|
||
const struct ccdigest_info *di = v->di;
|
||
const cc_size n = ccn_nof(v->modlen);
|
||
const size_t s = ccn_sizeof(v->modlen);
|
||
unsigned char H[di->output_size];
|
||
const uint8_t *sig = v->sig;
|
||
unsigned long siglen = v->siglen;
|
||
|
||
uint8_t canary_out[sizeof(CCRSA_PKCS1_FAULT_CANARY)];
|
||
|
||
cc_unit exponent[n];
|
||
cc_unit modulus[n];
|
||
ccrsa_pub_ctx_decl(ccn_sizeof(v->modlen), key);
|
||
ccrsa_ctx_n(key) = n;
|
||
ccn_seti(n, exponent, v->exp);
|
||
ccn_read_uint(n, modulus, s, v->mod);
|
||
|
||
ccrsa_init_pub(key, modulus, exponent);
|
||
if (v->digest) {
|
||
memcpy(H, v->digest, sizeof(H));
|
||
} else {
|
||
ccdigest(di, v->msglen, v->msg, H);
|
||
}
|
||
|
||
ok = !v->valid;
|
||
rc = ccrsa_verify_pkcs1v15(key, di->oid, di->output_size, H, siglen, sig, &ok);
|
||
if (rc || (ok != v->valid)) {
|
||
return -1;
|
||
}
|
||
|
||
rc = ccrsa_verify_pkcs1v15_digest(key, di->oid, di->output_size, H, siglen, sig, canary_out);
|
||
if ((v->valid && rc != CCERR_VALID_SIGNATURE) || (!v->valid && rc == CCERR_VALID_SIGNATURE)) {
|
||
return -1;
|
||
}
|
||
if (v->valid && memcmp(canary_out, CCRSA_PKCS1_FAULT_CANARY, sizeof(CCRSA_PKCS1_FAULT_CANARY)) != 0) {
|
||
return -1;
|
||
}
|
||
|
||
if (!v->digest) {
|
||
rc = ccrsa_verify_pkcs1v15_msg(key, di, v->msglen, v->msg, siglen, sig, canary_out);
|
||
if ((v->valid && rc != CCERR_VALID_SIGNATURE) || (!v->valid && rc == CCERR_VALID_SIGNATURE)) {
|
||
return -1;
|
||
}
|
||
if (v->valid && memcmp(canary_out, CCRSA_PKCS1_FAULT_CANARY, sizeof(CCRSA_PKCS1_FAULT_CANARY)) != 0) {
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
while (siglen > 0 && sig[0] == 0) {
|
||
sig += 1;
|
||
siglen -= 1;
|
||
|
||
ok = true;
|
||
rc = ccrsa_verify_pkcs1v15(key, di->oid, di->output_size, H, siglen, sig, &ok);
|
||
if (!rc || ok) {
|
||
return -1;
|
||
}
|
||
|
||
ok = !v->valid;
|
||
rc = ccrsa_verify_pkcs1v15_allowshortsigs(key, di->oid, di->output_size, H, siglen, sig, &ok);
|
||
if (rc || (ok != v->valid)) {
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Nist CAVP vectors specifies the hash as strings - those are matching hashes implementations */
|
||
/* We picked the implementations that are on all platform, it does not matter since we are not testing the hash here */
|
||
#define di_SHA1 &ccsha1_eay_di
|
||
#define di_SHA224 &ccsha224_ltc_di
|
||
#define di_SHA256 &ccsha256_ltc_di
|
||
#define di_SHA384 &ccsha384_ltc_di
|
||
#define di_SHA512 &ccsha512_ltc_di
|
||
|
||
/* Nist CAVP vectors for verify specify the result as F (failed) or P (passed)
|
||
those translate as true or false */
|
||
|
||
#define P true
|
||
#define F false
|
||
|
||
const struct ccrsa_verify_vector verify_vectors_pkcs1v15[] = {
|
||
#include "../test_vectors/SigVer15.inc"
|
||
};
|
||
|
||
int test_verify_pkcs1v15_known_answer_test(void)
|
||
{
|
||
uint32_t i;
|
||
uint32_t nb_test_passed, nb_test;
|
||
nb_test_passed = 0;
|
||
nb_test = 0;
|
||
// Run only tests for supported hash algorithms
|
||
for (i = 0; i < sizeof(verify_vectors_pkcs1v15) / sizeof(struct ccrsa_verify_vector); i++) {
|
||
if (verify_vectors_pkcs1v15[i].di != NULL) {
|
||
// 1 bit is set to one when the test passed
|
||
nb_test++;
|
||
if (ccrsa_test_verify_pkcs1v15_vector(&verify_vectors_pkcs1v15[i]) == 0) {
|
||
nb_test_passed += 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
if ((nb_test_passed == nb_test) && (nb_test > 0)) {
|
||
return 0;
|
||
}
|
||
return -1;
|
||
}
|