int main(int argc, char **argv) {
size_t i, j;
uint8_t md[SHA_DIGEST_LENGTH];
char md_hex[sizeof(md) * 2 + 1];
int ok = 1;
CRYPTO_library_init();
for (i = 0; test[i] != NULL; i++) {
EVP_Digest(test[i], strlen(test[i]), md, NULL, EVP_sha1(), NULL);
for (j = 0; j < sizeof(md); j++) {
sprintf(&md_hex[j * 2], "%02x", md[j]);
}
if (strcmp(md_hex, expected[i]) != 0) {
fprintf(stderr, "#%u: got %s, wanted %s\n", (unsigned)i, md_hex,
expected[i]);
ok = 0;
}
}
ok &= test_incremental();
if (ok) {
printf("PASS\n");
}
return ok ? 0 : 1;
}
int main(void)
{
CRYPTO_library_init();
const struct set_name_fn *pfn = name_fns;
while (pfn->name) {
const char *const *pname = names;
while (*pname) {
X509 *crt = make_cert();
if (crt == NULL) {
fprintf(stderr, "make_cert failed\n");
return 1;
}
if (!pfn->fn(crt, *pname)) {
fprintf(stderr, "X509 name setting failed\n");
return 1;
}
run_cert(crt, *pname, pfn);
X509_free(crt);
++pname;
}
++pfn;
}
if (errors == 0) {
printf("PASS\n");
}
return errors > 0 ? 1 : 0;
}
int main(void) {
int ret = 1;
BIO *out;
CRYPTO_library_init();
ERR_load_crypto_strings();
out = BIO_new_fp(stdout, BIO_NOCLOSE);
if (!test_builtin(out))
goto err;
ret = 0;
err:
if (ret)
BIO_printf(out, "\nECDSA test failed\n");
else
BIO_printf(out, "\nPASS\n");
if (ret)
BIO_print_errors(out);
if (out != NULL)
BIO_free(out);
return ret;
}
int main(void) {
uint8_t buf[82];
size_t i;
CRYPTO_library_init();
ERR_load_crypto_strings();
for (i = 0; i < sizeof(kTests) / sizeof(kTests[0]); i++) {
const hkdf_test_vector_t *test = &kTests[i];
if (!HKDF(buf, test->out_len, test->md_func(), test->ikm, test->ikm_len,
test->salt, test->salt_len, test->info, test->info_len)) {
fprintf(stderr, "Call to HKDF failed\n");
ERR_print_errors_fp(stderr);
return 1;
}
if (memcmp(buf, test->out, test->out_len) != 0) {
fprintf(stderr, "%u: Resulting key material does not match test vector\n",
(unsigned)i);
return 1;
}
}
printf("PASS\n");
ERR_free_strings();
return 0;
}
int main(void) {
CRYPTO_library_init();
ERR_load_crypto_strings();
if (!test_EVP_DigestSignInit()) {
fprintf(stderr, "EVP_DigestSignInit failed\n");
return 1;
}
if (!test_EVP_DigestVerifyInit()) {
fprintf(stderr, "EVP_DigestVerifyInit failed\n");
return 1;
}
if (!test_EVP_DigestSignAlgorithm()) {
fprintf(stderr, "EVP_DigestSignInit failed\n");
return 1;
}
if (!test_EVP_DigestVerifyInitFromAlgorithm()) {
fprintf(stderr, "EVP_DigestVerifyInitFromAlgorithm failed\n");
return 1;
}
if (!test_d2i_AutoPrivateKey(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER),
EVP_PKEY_RSA)) {
fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyDER) failed\n");
return 1;
}
if (!test_d2i_AutoPrivateKey(kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8),
EVP_PKEY_RSA)) {
fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyPKCS8) failed\n");
return 1;
}
if (!test_d2i_AutoPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER),
EVP_PKEY_EC)) {
fprintf(stderr, "d2i_AutoPrivateKey(kExampleECKeyDER) failed\n");
return 1;
}
if (!test_EVP_PKCS82PKEY()) {
fprintf(stderr, "test_EVP_PKCS82PKEY failed\n");
return 1;
}
printf("PASS\n");
return 0;
}
int main(void) {
CRYPTO_library_init();
if (!test_cert_reparse(kPKCS7NSS, sizeof(kPKCS7NSS)) ||
!test_cert_reparse(kPKCS7Windows, sizeof(kPKCS7Windows)) ||
!test_crl_reparse(kOpenSSLCRL, sizeof(kOpenSSLCRL)) ||
!test_pem_certs(kPEMCert) ||
!test_pem_crls(kPEMCRL)) {
return 1;
}
printf("PASS\n");
return 0;
}
int main(void) {
uint8_t buf[82], prk[EVP_MAX_MD_SIZE];
size_t i, prk_len;
CRYPTO_library_init();
for (i = 0; i < OPENSSL_ARRAY_SIZE(kTests); i++) {
const hkdf_test_vector_t *test = &kTests[i];
if (!HKDF_extract(prk, &prk_len, test->md_func(), test->ikm, test->ikm_len,
test->salt, test->salt_len)) {
fprintf(stderr, "Call to HKDF_extract failed\n");
ERR_print_errors_fp(stderr);
return 1;
}
if (prk_len != test->prk_len ||
memcmp(prk, test->prk, test->prk_len) != 0) {
fprintf(stderr, "%zu: Resulting PRK does not match test vector\n", i);
return 1;
}
if (!HKDF_expand(buf, test->out_len, test->md_func(), prk, prk_len,
test->info, test->info_len)) {
fprintf(stderr, "Call to HKDF_expand failed\n");
ERR_print_errors_fp(stderr);
return 1;
}
if (memcmp(buf, test->out, test->out_len) != 0) {
fprintf(stderr,
"%zu: Resulting key material does not match test vector\n", i);
return 1;
}
if (!HKDF(buf, test->out_len, test->md_func(), test->ikm, test->ikm_len,
test->salt, test->salt_len, test->info, test->info_len)) {
fprintf(stderr, "Call to HKDF failed\n");
ERR_print_errors_fp(stderr);
return 1;
}
if (memcmp(buf, test->out, test->out_len) != 0) {
fprintf(stderr,
"%zu: Resulting key material does not match test vector\n", i);
return 1;
}
}
printf("PASS\n");
ERR_free_strings();
return 0;
}
int main(void) {
int ret = 0;
unsigned i;
CRYPTO_library_init();
for (i = 0; i < sizeof(test_cases) / sizeof(struct test_case); i++) {
if (!run_test_case(i, &test_cases[i])) {
ret = 1;
}
}
if (ret == 0) {
printf("PASS\n");
}
return ret;
}
int main(void) {
#if defined(OPENSSL_WINDOWS)
WSADATA wsa_data;
WORD wsa_version;
int wsa_err;
#endif
CRYPTO_library_init();
ERR_load_crypto_strings();
#if defined(OPENSSL_WINDOWS)
/* Initialize Winsock. */
wsa_version = MAKEWORD(2, 2);
wsa_err = WSAStartup(wsa_version, &wsa_data);
if (wsa_err != 0) {
fprintf(stderr, "WSAStartup failed: %d\n", wsa_err);
return 1;
}
if (wsa_data.wVersion != wsa_version) {
fprintf(stderr, "Didn't get expected version: %x\n", wsa_data.wVersion);
return 1;
}
#endif
if (!test_socket_connect()) {
return 1;
}
if (!test_printf()) {
return 1;
}
if (!test_zero_copy_bio_pairs()) {
return 1;
}
printf("PASS\n");
return 0;
}
int main(int argc, char **argv) {
CRYPTO_library_init();
bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
bio_out = BIO_new_fp(stdout, BIO_NOCLOSE);
if (!test_generate() ||
!test_verify(fips_sig, sizeof(fips_sig), 1) ||
!test_verify(fips_sig_negative, sizeof(fips_sig_negative), -1) ||
!test_verify(fips_sig_extra, sizeof(fips_sig_extra), -1) ||
!test_verify(fips_sig_bad_length, sizeof(fips_sig_bad_length), -1) ||
!test_verify(fips_sig_bad_r, sizeof(fips_sig_bad_r), 0)) {
BIO_print_errors(bio_err);
BIO_free(bio_err);
BIO_free(bio_out);
return 1;
}
BIO_free(bio_err);
BIO_free(bio_out);
printf("PASS\n");
return 0;
}
int main(void) {
CRYPTO_library_init();
if (!test_skip() ||
!test_get_u() ||
!test_get_prefixed() ||
!test_get_prefixed_bad() ||
!test_get_asn1() ||
!test_cbb_basic() ||
!test_cbb_fixed() ||
!test_cbb_finish_child() ||
!test_cbb_misuse() ||
!test_cbb_prefixed() ||
!test_cbb_asn1() ||
!test_ber_convert() ||
!test_asn1_uint64() ||
!test_get_optional_asn1_bool()) {
return 1;
}
printf("PASS\n");
return 0;
}
int main(int argc, char *argv[]) {
int err = 0;
int v;
RSA *key;
unsigned char ptext[256];
unsigned char ctext[256];
static unsigned char ptext_ex[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
unsigned char ctext_ex[256];
int plen;
int clen = 0;
int num;
int n;
CRYPTO_library_init();
plen = sizeof(ptext_ex) - 1;
for (v = 0; v < 3; v++) {
key = RSA_new();
switch (v) {
case 0:
clen = key1(key, ctext_ex);
break;
case 1:
clen = key2(key, ctext_ex);
break;
case 2:
clen = key3(key, ctext_ex);
break;
default:
abort();
}
if (!RSA_check_key(key)) {
printf("%d: RSA_check_key failed\n", v);
err = 1;
goto oaep;
}
num = RSA_public_encrypt(plen, ptext_ex, ctext, key, RSA_PKCS1_PADDING);
if (num != clen) {
printf("PKCS#1 v1.5 encryption failed!\n");
err = 1;
goto oaep;
}
num = RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0) {
printf("PKCS#1 v1.5 decryption failed!\n");
err = 1;
} else {
printf("PKCS #1 v1.5 encryption/decryption ok\n");
}
oaep:
ERR_clear_error();
num =
RSA_public_encrypt(plen, ptext_ex, ctext, key, RSA_PKCS1_OAEP_PADDING);
if (num == -1) {
printf("No OAEP support\n");
goto next;
}
if (num != clen) {
printf("OAEP encryption failed!\n");
err = 1;
goto next;
}
num = RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0) {
printf("OAEP decryption (encrypted data) failed!\n");
err = 1;
} else if (memcmp(ctext, ctext_ex, num) == 0) {
printf("OAEP test vector %d passed!\n", v);
}
/* Different ciphertexts (rsa_oaep.c without -DPKCS_TESTVECT).
Try decrypting ctext_ex */
num =
RSA_private_decrypt(clen, ctext_ex, ptext, key, RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0) {
printf("OAEP decryption (test vector data) failed!\n");
err = 1;
} else {
printf("OAEP encryption/decryption ok\n");
}
/* Try decrypting corrupted ciphertexts */
for (n = 0; n < clen; ++n) {
int b;
unsigned char saved = ctext[n];
for (b = 0; b < 256; ++b) {
if (b == saved) {
continue;
}
ctext[n] = b;
num =
RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_OAEP_PADDING);
if (num > 0) {
printf("Corrupt data decrypted!\n");
err = 1;
}
}
}
next:
RSA_free(key);
}
if (err != 0 ||
!test_only_d_given() ||
!test_recover_crt_params() ||
!test_bad_key()) {
err = 1;
}
if (err == 0) {
printf("PASS\n");
}
return err;
}
int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) {
CRYPTO_library_init();
return 1;
}
int SSL_library_init(void) {
CRYPTO_library_init();
return 1;
}
int main(int argc, char *argv[]) {
unsigned i;
char *p;
int err = 0;
uint8_t out[EVP_MAX_MD_SIZE];
unsigned out_len;
CRYPTO_library_init();
for (i = 0; i < NUM_TESTS; i++) {
const struct test_st *test = &kTests[i];
/* Test using the one-shot API. */
if (NULL == HMAC(EVP_md5(), test->key, test->key_len, test->data,
test->data_len, out, &out_len)) {
fprintf(stderr, "%u: HMAC failed.\n", i);
err++;
continue;
}
p = to_hex(out, out_len);
if (strcmp(p, test->hex_digest) != 0) {
fprintf(stderr, "%u: got %s instead of %s\n", i, p, test->hex_digest);
err++;
}
/* Test using HMAC_CTX. */
HMAC_CTX ctx;
HMAC_CTX_init(&ctx);
if (!HMAC_Init_ex(&ctx, test->key, test->key_len, EVP_md5(), NULL) ||
!HMAC_Update(&ctx, test->data, test->data_len) ||
!HMAC_Final(&ctx, out, &out_len)) {
fprintf(stderr, "%u: HMAC failed.\n", i);
err++;
HMAC_CTX_cleanup(&ctx);
continue;
}
p = to_hex(out, out_len);
if (strcmp(p, test->hex_digest) != 0) {
fprintf(stderr, "%u: got %s instead of %s\n", i, p, test->hex_digest);
err++;
}
/* Test that an HMAC_CTX may be reset with the same key. */
if (!HMAC_Init_ex(&ctx, NULL, 0, EVP_md5(), NULL) ||
!HMAC_Update(&ctx, test->data, test->data_len) ||
!HMAC_Final(&ctx, out, &out_len)) {
fprintf(stderr, "%u: HMAC failed.\n", i);
err++;
HMAC_CTX_cleanup(&ctx);
continue;
}
p = to_hex(out, out_len);
if (strcmp(p, test->hex_digest) != 0) {
fprintf(stderr, "%u: got %s instead of %s\n", i, p, test->hex_digest);
err++;
}
HMAC_CTX_cleanup(&ctx);
}
/* Test that HMAC() uses the empty key when called with key = NULL. */
const struct test_st *test = &kTests[0];
assert(test->key_len == 0);
if (NULL == HMAC(EVP_md5(), NULL, 0, test->data, test->data_len, out,
&out_len)) {
fprintf(stderr, "HMAC failed.\n");
err++;
} else {
p = to_hex(out, out_len);
if (strcmp(p, test->hex_digest) != 0) {
fprintf(stderr, "got %s instead of %s\n", p, test->hex_digest);
err++;
}
}
/* Test that HMAC_Init, etc., uses the empty key when called initially with
* key = NULL. */
assert(test->key_len == 0);
HMAC_CTX ctx;
HMAC_CTX_init(&ctx);
if (!HMAC_Init_ex(&ctx, NULL, 0, EVP_md5(), NULL) ||
!HMAC_Update(&ctx, test->data, test->data_len) ||
!HMAC_Final(&ctx, out, &out_len)) {
fprintf(stderr, "HMAC failed.\n");
err++;
} else {
p = to_hex(out, out_len);
if (strcmp(p, test->hex_digest) != 0) {
fprintf(stderr, "got %s instead of %s\n", p, test->hex_digest);
err++;
}
}
HMAC_CTX_cleanup(&ctx);
if (err) {
return 1;
}
printf("PASS\n");
return 0;
}
int main(int argc, char *argv[]) {
BN_GENCB _cb;
DH *a;
DH *b = NULL;
char buf[12];
unsigned char *abuf = NULL, *bbuf = NULL;
int i, alen, blen, aout, bout, ret = 1;
CRYPTO_library_init();
BN_GENCB_set(&_cb, &cb, stdout);
if (((a = DH_new()) == NULL) ||
!DH_generate_parameters_ex(a, 64, DH_GENERATOR_5, &_cb)) {
goto err;
}
if (!DH_check(a, &i)) {
goto err;
}
if (i & DH_CHECK_P_NOT_PRIME) {
puts("p value is not prime\n");
}
if (i & DH_CHECK_P_NOT_SAFE_PRIME) {
puts("p value is not a safe prime\n");
}
if (i & DH_CHECK_UNABLE_TO_CHECK_GENERATOR) {
puts("unable to check the generator value\n");
}
if (i & DH_CHECK_NOT_SUITABLE_GENERATOR) {
puts("the g value is not a generator\n");
}
puts("\np =");
BN_print_fp(stdout, a->p);
puts("\ng =");
BN_print_fp(stdout, a->g);
puts("\n");
b = DH_new();
if (b == NULL) {
goto err;
}
b->p = BN_dup(a->p);
b->g = BN_dup(a->g);
if (b->p == NULL || b->g == NULL) {
goto err;
}
if (!DH_generate_key(a)) {
goto err;
}
puts("pri 1=");
BN_print_fp(stdout, a->priv_key);
puts("\npub 1=");
BN_print_fp(stdout, a->pub_key);
puts("\n");
if (!DH_generate_key(b)) {
goto err;
}
puts("pri 2=");
BN_print_fp(stdout, b->priv_key);
puts("\npub 2=");
BN_print_fp(stdout, b->pub_key);
puts("\n");
alen = DH_size(a);
abuf = (unsigned char *)OPENSSL_malloc(alen);
aout = DH_compute_key(abuf, b->pub_key, a);
puts("key1 =");
for (i = 0; i < aout; i++) {
sprintf(buf, "%02X", abuf[i]);
puts(buf);
}
puts("\n");
blen = DH_size(b);
bbuf = (unsigned char *)OPENSSL_malloc(blen);
bout = DH_compute_key(bbuf, a->pub_key, b);
puts("key2 =");
for (i = 0; i < bout; i++) {
sprintf(buf, "%02X", bbuf[i]);
puts(buf);
}
puts("\n");
if ((aout < 4) || (bout != aout) || (memcmp(abuf, bbuf, aout) != 0)) {
fprintf(stderr, "Error in DH routines\n");
ret = 1;
} else {
ret = 0;
}
if (!run_rfc5114_tests()) {
ret = 1;
}
err:
ERR_print_errors_fp(stderr);
if (abuf != NULL) {
OPENSSL_free(abuf);
}
if (bbuf != NULL) {
OPENSSL_free(bbuf);
}
if (b != NULL) {
DH_free(b);
}
if (a != NULL) {
DH_free(a);
}
return ret;
}
int main(int argc, char **argv) {
_LHASH *lh;
struct dummy_lhash dummy_lh = {NULL};
unsigned i;
CRYPTO_library_init();
lh = lh_new(NULL, NULL);
if (lh == NULL) {
return 1;
}
for (i = 0; i < 100000; i++) {
unsigned action;
char *s, *s1, *s2;
if (dummy_lh_num_items(&dummy_lh) != lh_num_items(lh)) {
fprintf(stderr, "Length mismatch\n");
return 1;
}
action = rand() % 3;
switch (action) {
case 0:
s = rand_string();
s1 = (char *)lh_retrieve(lh, s);
s2 = dummy_lh_retrieve(&dummy_lh, s);
if (s1 != NULL && (s2 == NULL || strcmp(s1, s2) != 0)) {
fprintf(stderr, "lh_retrieve failure\n");
abort();
}
free(s);
break;
case 1:
s = rand_string();
lh_insert(lh, (void **)&s1, s);
dummy_lh_insert(&dummy_lh, &s2, strdup(s));
if (s1 != NULL && (s2 == NULL || strcmp(s1, s2) != 0)) {
fprintf(stderr, "lh_insert failure\n");
abort();
}
if (s1) {
free(s1);
}
if (s2) {
free(s2);
}
break;
case 2:
s = rand_string();
s1 = lh_delete(lh, s);
s2 = dummy_lh_delete(&dummy_lh, s);
if (s1 != NULL && (s2 == NULL || strcmp(s1, s2) != 0)) {
fprintf(stderr, "lh_insert failure\n");
abort();
}
if (s1) {
free(s1);
}
if (s2) {
free(s2);
}
free(s);
break;
default:
abort();
}
}
lh_doall(lh, free);
lh_free(lh);
dummy_lh_free(&dummy_lh);
printf("PASS\n");
return 0;
}
