diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/libcrypto/engine/eng_lib.c | 290 | ||||
| -rw-r--r-- | lib/libcrypto/engine/eng_openssl.c | 228 | ||||
| -rw-r--r-- | lib/libcrypto/engine/eng_padlock.c | 496 | ||||
| -rw-r--r-- | lib/libcrypto/engine/eng_pkey.c | 157 | ||||
| -rw-r--r-- | lib/libcrypto/engine/eng_rsax.c | 613 | ||||
| -rw-r--r-- | lib/libcrypto/engine/eng_table.c | 258 |
6 files changed, 1081 insertions, 961 deletions
diff --git a/lib/libcrypto/engine/eng_lib.c b/lib/libcrypto/engine/eng_lib.c index 4288535d72f..569b7199cec 100644 --- a/lib/libcrypto/engine/eng_lib.c +++ b/lib/libcrypto/engine/eng_lib.c @@ -1,4 +1,4 @@ -/* $OpenBSD: eng_lib.c,v 1.7 2014/06/12 15:49:29 deraadt Exp $ */ +/* $OpenBSD: eng_lib.c,v 1.8 2014/06/22 12:05:09 jsing Exp $ */ /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL * project 2000. */ @@ -10,7 +10,7 @@ * are met: * * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in @@ -61,28 +61,29 @@ /* The "new"/"free" stuff first */ -ENGINE *ENGINE_new(void) - { +ENGINE * +ENGINE_new(void) +{ ENGINE *ret; ret = malloc(sizeof(ENGINE)); - if(ret == NULL) - { + if (ret == NULL) { ENGINEerr(ENGINE_F_ENGINE_NEW, ERR_R_MALLOC_FAILURE); return NULL; - } + } memset(ret, 0, sizeof(ENGINE)); ret->struct_ref = 1; engine_ref_debug(ret, 0, 1) CRYPTO_new_ex_data(CRYPTO_EX_INDEX_ENGINE, ret, &ret->ex_data); return ret; - } +} /* Placed here (close proximity to ENGINE_new) so that modifications to the * elements of the ENGINE structure are more likely to be caught and changed * here. */ -void engine_set_all_null(ENGINE *e) - { +void +engine_set_all_null(ENGINE *e) +{ e->id = NULL; e->name = NULL; e->rsa_meth = NULL; @@ -100,41 +101,43 @@ void engine_set_all_null(ENGINE *e) e->load_pubkey = NULL; e->cmd_defns = NULL; e->flags = 0; - } +} -int engine_free_util(ENGINE *e, int locked) - { +int +engine_free_util(ENGINE *e, int locked) +{ int i; - if(e == NULL) - { + if (e == NULL) { ENGINEerr(ENGINE_F_ENGINE_FREE_UTIL, - ERR_R_PASSED_NULL_PARAMETER); + ERR_R_PASSED_NULL_PARAMETER); return 0; - } - if(locked) - i = CRYPTO_add(&e->struct_ref,-1,CRYPTO_LOCK_ENGINE); + } + if (locked) + i = CRYPTO_add(&e->struct_ref, -1, CRYPTO_LOCK_ENGINE); else i = --e->struct_ref; engine_ref_debug(e, 0, -1) - if (i > 0) return 1; + if (i > 0) + return 1; /* Free up any dynamically allocated public key methods */ engine_pkey_meths_free(e); engine_pkey_asn1_meths_free(e); /* Give the ENGINE a chance to do any structural cleanup corresponding * to allocation it did in its constructor (eg. unload error strings) */ - if(e->destroy) + if (e->destroy) e->destroy(e); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_ENGINE, e, &e->ex_data); free(e); return 1; - } +} -int ENGINE_free(ENGINE *e) - { +int +ENGINE_free(ENGINE *e) +{ return engine_free_util(e, 1); - } +} /* Cleanup stuff */ @@ -143,183 +146,218 @@ int ENGINE_free(ENGINE *e) * bloat by referring to all *possible* cleanups, but any linker bloat into code * "X" will cause X's cleanup function to end up here. */ static STACK_OF(ENGINE_CLEANUP_ITEM) *cleanup_stack = NULL; -static int int_cleanup_check(int create) - { - if(cleanup_stack) return 1; - if(!create) return 0; +static int +int_cleanup_check(int create) +{ + if (cleanup_stack) + return 1; + if (!create) + return 0; cleanup_stack = sk_ENGINE_CLEANUP_ITEM_new_null(); return (cleanup_stack ? 1 : 0); - } -static ENGINE_CLEANUP_ITEM *int_cleanup_item(ENGINE_CLEANUP_CB *cb) - { +} + +static ENGINE_CLEANUP_ITEM * +int_cleanup_item(ENGINE_CLEANUP_CB *cb) +{ ENGINE_CLEANUP_ITEM *item = malloc(sizeof(ENGINE_CLEANUP_ITEM)); - if(!item) return NULL; + + if (!item) + return NULL; item->cb = cb; return item; - } -void engine_cleanup_add_first(ENGINE_CLEANUP_CB *cb) - { +} + +void +engine_cleanup_add_first(ENGINE_CLEANUP_CB *cb) +{ ENGINE_CLEANUP_ITEM *item; - if(!int_cleanup_check(1)) return; + + if (!int_cleanup_check(1)) + return; item = int_cleanup_item(cb); - if(item) + if (item) sk_ENGINE_CLEANUP_ITEM_insert(cleanup_stack, item, 0); - } -void engine_cleanup_add_last(ENGINE_CLEANUP_CB *cb) - { +} + +void +engine_cleanup_add_last(ENGINE_CLEANUP_CB *cb) +{ ENGINE_CLEANUP_ITEM *item; - if(!int_cleanup_check(1)) return; + + if (!int_cleanup_check(1)) + return; item = int_cleanup_item(cb); - if(item) + if (item) sk_ENGINE_CLEANUP_ITEM_push(cleanup_stack, item); - } +} /* The API function that performs all cleanup */ -static void engine_cleanup_cb_free(ENGINE_CLEANUP_ITEM *item) - { +static void +engine_cleanup_cb_free(ENGINE_CLEANUP_ITEM *item) +{ (*(item->cb))(); free(item); - } -void ENGINE_cleanup(void) - { - if(int_cleanup_check(0)) - { +} + +void +ENGINE_cleanup(void) +{ + if (int_cleanup_check(0)) { sk_ENGINE_CLEANUP_ITEM_pop_free(cleanup_stack, - engine_cleanup_cb_free); + engine_cleanup_cb_free); cleanup_stack = NULL; - } + } /* FIXME: This should be handled (somehow) through RAND, eg. by it * registering a cleanup callback. */ RAND_set_rand_method(NULL); - } +} /* Now the "ex_data" support */ -int ENGINE_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, - CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func) - { +int +ENGINE_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, + CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func) +{ return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ENGINE, argl, argp, - new_func, dup_func, free_func); - } + new_func, dup_func, free_func); +} -int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg) - { - return(CRYPTO_set_ex_data(&e->ex_data, idx, arg)); - } +int +ENGINE_set_ex_data(ENGINE *e, int idx, void *arg) +{ + return (CRYPTO_set_ex_data(&e->ex_data, idx, arg)); +} -void *ENGINE_get_ex_data(const ENGINE *e, int idx) - { - return(CRYPTO_get_ex_data(&e->ex_data, idx)); - } +void * +ENGINE_get_ex_data(const ENGINE *e, int idx) +{ + return (CRYPTO_get_ex_data(&e->ex_data, idx)); +} /* Functions to get/set an ENGINE's elements - mainly to avoid exposing the * ENGINE structure itself. */ -int ENGINE_set_id(ENGINE *e, const char *id) - { - if(id == NULL) - { +int +ENGINE_set_id(ENGINE *e, const char *id) +{ + if (id == NULL) { ENGINEerr(ENGINE_F_ENGINE_SET_ID, - ERR_R_PASSED_NULL_PARAMETER); + ERR_R_PASSED_NULL_PARAMETER); return 0; - } + } e->id = id; return 1; - } +} -int ENGINE_set_name(ENGINE *e, const char *name) - { - if(name == NULL) - { +int +ENGINE_set_name(ENGINE *e, const char *name) +{ + if (name == NULL) { ENGINEerr(ENGINE_F_ENGINE_SET_NAME, - ERR_R_PASSED_NULL_PARAMETER); + ERR_R_PASSED_NULL_PARAMETER); return 0; - } + } e->name = name; return 1; - } +} -int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f) - { +int +ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f) +{ e->destroy = destroy_f; return 1; - } +} -int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f) - { +int +ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f) +{ e->init = init_f; return 1; - } +} -int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f) - { +int +ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f) +{ e->finish = finish_f; return 1; - } +} -int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f) - { +int +ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f) +{ e->ctrl = ctrl_f; return 1; - } +} -int ENGINE_set_flags(ENGINE *e, int flags) - { +int +ENGINE_set_flags(ENGINE *e, int flags) +{ e->flags = flags; return 1; - } +} -int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns) - { +int +ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns) +{ e->cmd_defns = defns; return 1; - } +} -const char *ENGINE_get_id(const ENGINE *e) - { +const char * +ENGINE_get_id(const ENGINE *e) +{ return e->id; - } +} -const char *ENGINE_get_name(const ENGINE *e) - { +const char * +ENGINE_get_name(const ENGINE *e) +{ return e->name; - } +} -ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e) - { +ENGINE_GEN_INT_FUNC_PTR +ENGINE_get_destroy_function(const ENGINE *e) +{ return e->destroy; - } +} -ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e) - { +ENGINE_GEN_INT_FUNC_PTR +ENGINE_get_init_function(const ENGINE *e) +{ return e->init; - } +} -ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e) - { +ENGINE_GEN_INT_FUNC_PTR +ENGINE_get_finish_function(const ENGINE *e) +{ return e->finish; - } +} -ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e) - { +ENGINE_CTRL_FUNC_PTR +ENGINE_get_ctrl_function(const ENGINE *e) +{ return e->ctrl; - } +} -int ENGINE_get_flags(const ENGINE *e) - { +int +ENGINE_get_flags(const ENGINE *e) +{ return e->flags; - } +} -const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e) - { +const ENGINE_CMD_DEFN * +ENGINE_get_cmd_defns(const ENGINE *e) +{ return e->cmd_defns; - } +} /* eng_lib.o is pretty much linked into anything that touches ENGINE already, so * put the "static_state" hack here. */ static int internal_static_hack = 0; -void *ENGINE_get_static_state(void) - { +void * +ENGINE_get_static_state(void) +{ return &internal_static_hack; - } +} diff --git a/lib/libcrypto/engine/eng_openssl.c b/lib/libcrypto/engine/eng_openssl.c index f7cd8df622b..9ba61dd842b 100644 --- a/lib/libcrypto/engine/eng_openssl.c +++ b/lib/libcrypto/engine/eng_openssl.c @@ -1,4 +1,4 @@ -/* $OpenBSD: eng_openssl.c,v 1.5 2014/06/12 15:49:29 deraadt Exp $ */ +/* $OpenBSD: eng_openssl.c,v 1.6 2014/06/22 12:05:09 jsing Exp $ */ /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL * project 2000. */ @@ -10,7 +10,7 @@ * are met: * * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in @@ -57,7 +57,7 @@ */ /* ==================================================================== * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. - * ECDH support in OpenSSL originally developed by + * ECDH support in OpenSSL originally developed by * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. */ @@ -106,21 +106,21 @@ #undef TEST_ENG_OPENSSL_SHA_OTHERS #undef TEST_ENG_OPENSSL_SHA_P_INIT #undef TEST_ENG_OPENSSL_SHA_P_UPDATE -#undef TEST_ENG_OPENSSL_SHA_P_FINAL +#undef TEST_ENG_OPENSSL_SHA_P_FINAL #endif #ifdef TEST_ENG_OPENSSL_RC4 static int openssl_ciphers(ENGINE *e, const EVP_CIPHER **cipher, - const int **nids, int nid); + const int **nids, int nid); #endif #ifdef TEST_ENG_OPENSSL_SHA static int openssl_digests(ENGINE *e, const EVP_MD **digest, - const int **nids, int nid); + const int **nids, int nid); #endif #ifdef TEST_ENG_OPENSSL_PKEY static EVP_PKEY *openssl_load_privkey(ENGINE *eng, const char *key_id, - UI_METHOD *ui_method, void *callback_data); + UI_METHOD *ui_method, void *callback_data); #endif /* The constants used when creating the ENGINE */ @@ -129,79 +129,85 @@ static const char *engine_openssl_name = "Software engine support"; /* This internal function is used by ENGINE_openssl() and possibly by the * "dynamic" ENGINE support too */ -static int bind_helper(ENGINE *e) - { - if(!ENGINE_set_id(e, engine_openssl_id) - || !ENGINE_set_name(e, engine_openssl_name) +static int +bind_helper(ENGINE *e) +{ + if (!ENGINE_set_id(e, engine_openssl_id) || + !ENGINE_set_name(e, engine_openssl_name) #ifndef TEST_ENG_OPENSSL_NO_ALGORITHMS #ifndef OPENSSL_NO_RSA - || !ENGINE_set_RSA(e, RSA_get_default_method()) + || !ENGINE_set_RSA(e, RSA_get_default_method()) #endif #ifndef OPENSSL_NO_DSA - || !ENGINE_set_DSA(e, DSA_get_default_method()) + || !ENGINE_set_DSA(e, DSA_get_default_method()) #endif #ifndef OPENSSL_NO_ECDH - || !ENGINE_set_ECDH(e, ECDH_OpenSSL()) + || !ENGINE_set_ECDH(e, ECDH_OpenSSL()) #endif #ifndef OPENSSL_NO_ECDSA - || !ENGINE_set_ECDSA(e, ECDSA_OpenSSL()) + || !ENGINE_set_ECDSA(e, ECDSA_OpenSSL()) #endif #ifndef OPENSSL_NO_DH - || !ENGINE_set_DH(e, DH_get_default_method()) + || !ENGINE_set_DH(e, DH_get_default_method()) #endif - || !ENGINE_set_RAND(e, RAND_SSLeay()) + || !ENGINE_set_RAND(e, RAND_SSLeay()) #ifdef TEST_ENG_OPENSSL_RC4 - || !ENGINE_set_ciphers(e, openssl_ciphers) + || !ENGINE_set_ciphers(e, openssl_ciphers) #endif #ifdef TEST_ENG_OPENSSL_SHA - || !ENGINE_set_digests(e, openssl_digests) + || !ENGINE_set_digests(e, openssl_digests) #endif #endif #ifdef TEST_ENG_OPENSSL_PKEY - || !ENGINE_set_load_privkey_function(e, openssl_load_privkey) + || !ENGINE_set_load_privkey_function(e, openssl_load_privkey) #endif - ) + ) return 0; /* If we add errors to this ENGINE, ensure the error handling is setup here */ /* openssl_load_error_strings(); */ return 1; - } +} -static ENGINE *engine_openssl(void) - { +static ENGINE * +engine_openssl(void) +{ ENGINE *ret = ENGINE_new(); - if(!ret) + + if (!ret) return NULL; - if(!bind_helper(ret)) - { + if (!bind_helper(ret)) { ENGINE_free(ret); return NULL; - } - return ret; } + return ret; +} -void ENGINE_load_openssl(void) - { +void +ENGINE_load_openssl(void) +{ ENGINE *toadd = engine_openssl(); - if(!toadd) return; + + if (!toadd) + return; ENGINE_add(toadd); /* If the "add" worked, it gets a structural reference. So either way, * we release our just-created reference. */ ENGINE_free(toadd); ERR_clear_error(); - } +} /* This stuff is needed if this ENGINE is being compiled into a self-contained * shared-library. */ #ifdef ENGINE_DYNAMIC_SUPPORT -static int bind_fn(ENGINE *e, const char *id) - { - if(id && (strcmp(id, engine_openssl_id) != 0)) +static int +bind_fn(ENGINE *e, const char *id) +{ + if (id && (strcmp(id, engine_openssl_id) != 0)) return 0; - if(!bind_helper(e)) + if (!bind_helper(e)) return 0; return 1; - } +} IMPLEMENT_DYNAMIC_CHECK_FN() IMPLEMENT_DYNAMIC_BIND_FN(bind_fn) #endif /* ENGINE_DYNAMIC_SUPPORT */ @@ -219,37 +225,42 @@ IMPLEMENT_DYNAMIC_BIND_FN(bind_fn) */ #include <openssl/rc4.h> #define TEST_RC4_KEY_SIZE 16 -static int test_cipher_nids[] = {NID_rc4,NID_rc4_40}; +static int test_cipher_nids[] = {NID_rc4, NID_rc4_40}; static int test_cipher_nids_number = 2; + typedef struct { unsigned char key[TEST_RC4_KEY_SIZE]; RC4_KEY ks; - } TEST_RC4_KEY; +} TEST_RC4_KEY; + #define test(ctx) ((TEST_RC4_KEY *)(ctx)->cipher_data) -static int test_rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, - const unsigned char *iv, int enc) - { +static int +test_rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, + const unsigned char *iv, int enc) +{ #ifdef TEST_ENG_OPENSSL_RC4_P_INIT fprintf(stderr, "(TEST_ENG_OPENSSL_RC4) test_init_key() called\n"); #endif - memcpy(&test(ctx)->key[0],key,EVP_CIPHER_CTX_key_length(ctx)); - RC4_set_key(&test(ctx)->ks,EVP_CIPHER_CTX_key_length(ctx), - test(ctx)->key); + memcpy(&test(ctx)->key[0], key, EVP_CIPHER_CTX_key_length(ctx)); + RC4_set_key(&test(ctx)->ks, EVP_CIPHER_CTX_key_length(ctx), + test(ctx)->key); return 1; - } -static int test_rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, - const unsigned char *in, size_t inl) - { +} + +static int +test_rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inl) +{ #ifdef TEST_ENG_OPENSSL_RC4_P_CIPHER fprintf(stderr, "(TEST_ENG_OPENSSL_RC4) test_cipher() called\n"); #endif - RC4(&test(ctx)->ks,inl,in,out); + RC4(&test(ctx)->ks, inl, in, out); return 1; - } -static const EVP_CIPHER test_r4_cipher= - { +} + +static const EVP_CIPHER test_r4_cipher = { NID_rc4, - 1,TEST_RC4_KEY_SIZE,0, + 1, TEST_RC4_KEY_SIZE, 0, EVP_CIPH_VARIABLE_LENGTH, test_rc4_init_key, test_rc4_cipher, @@ -259,9 +270,9 @@ static const EVP_CIPHER test_r4_cipher= NULL, NULL, NULL - }; -static const EVP_CIPHER test_r4_40_cipher= - { +}; + +static const EVP_CIPHER test_r4_40_cipher = { NID_rc4_40, 1,5 /* 40 bit */,0, EVP_CIPH_VARIABLE_LENGTH, @@ -269,36 +280,35 @@ static const EVP_CIPHER test_r4_40_cipher= test_rc4_cipher, NULL, sizeof(TEST_RC4_KEY), - NULL, + NULL, NULL, NULL, NULL - }; -static int openssl_ciphers(ENGINE *e, const EVP_CIPHER **cipher, - const int **nids, int nid) - { - if(!cipher) - { +}; + +static int +openssl_ciphers(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid) +{ + if (!cipher) { /* We are returning a list of supported nids */ *nids = test_cipher_nids; return test_cipher_nids_number; - } + } /* We are being asked for a specific cipher */ - if(nid == NID_rc4) + if (nid == NID_rc4) *cipher = &test_r4_cipher; - else if(nid == NID_rc4_40) + else if (nid == NID_rc4_40) *cipher = &test_r4_40_cipher; - else - { + else { #ifdef TEST_ENG_OPENSSL_RC4_OTHERS fprintf(stderr, "(TEST_ENG_OPENSSL_RC4) returning NULL for " - "nid %d\n", nid); + "nid %d\n", nid); #endif *cipher = NULL; return 0; - } - return 1; } + return 1; +} #endif #ifdef TEST_ENG_OPENSSL_SHA @@ -306,29 +316,35 @@ static int openssl_ciphers(ENGINE *e, const EVP_CIPHER **cipher, #include <openssl/sha.h> static int test_digest_nids[] = {NID_sha1}; static int test_digest_nids_number = 1; -static int test_sha1_init(EVP_MD_CTX *ctx) - { + +static int +test_sha1_init(EVP_MD_CTX *ctx) +{ #ifdef TEST_ENG_OPENSSL_SHA_P_INIT fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_init() called\n"); #endif return SHA1_Init(ctx->md_data); - } -static int test_sha1_update(EVP_MD_CTX *ctx,const void *data,size_t count) - { +} + +static int +test_sha1_update(EVP_MD_CTX *ctx, const void *data, size_t count) +{ #ifdef TEST_ENG_OPENSSL_SHA_P_UPDATE fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_update() called\n"); #endif - return SHA1_Update(ctx->md_data,data,count); - } -static int test_sha1_final(EVP_MD_CTX *ctx,unsigned char *md) - { + return SHA1_Update(ctx->md_data, data, count); +} + +static int +test_sha1_final(EVP_MD_CTX *ctx, unsigned char *md) +{ #ifdef TEST_ENG_OPENSSL_SHA_P_FINAL fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_final() called\n"); #endif - return SHA1_Final(md,ctx->md_data); - } -static const EVP_MD test_sha_md= - { + return SHA1_Final(md, ctx->md_data); +} + +static const EVP_MD test_sha_md = { NID_sha1, NID_sha1WithRSAEncryption, SHA_DIGEST_LENGTH, @@ -340,45 +356,47 @@ static const EVP_MD test_sha_md= NULL, EVP_PKEY_RSA_method, SHA_CBLOCK, - sizeof(EVP_MD *)+sizeof(SHA_CTX), - }; -static int openssl_digests(ENGINE *e, const EVP_MD **digest, - const int **nids, int nid) - { - if(!digest) - { + sizeof(EVP_MD *) + sizeof(SHA_CTX), +}; + +static int +openssl_digests(ENGINE *e, const EVP_MD **digest, const int **nids, int nid) +{ + if (!digest) { /* We are returning a list of supported nids */ *nids = test_digest_nids; return test_digest_nids_number; - } + } /* We are being asked for a specific digest */ - if(nid == NID_sha1) + if (nid == NID_sha1) *digest = &test_sha_md; - else - { + else { #ifdef TEST_ENG_OPENSSL_SHA_OTHERS fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) returning NULL for " - "nid %d\n", nid); + "nid %d\n", nid); #endif *digest = NULL; return 0; - } - return 1; } + return 1; +} #endif #ifdef TEST_ENG_OPENSSL_PKEY -static EVP_PKEY *openssl_load_privkey(ENGINE *eng, const char *key_id, - UI_METHOD *ui_method, void *callback_data) - { +static EVP_PKEY * +openssl_load_privkey(ENGINE *eng, const char *key_id, UI_METHOD *ui_method, + void *callback_data) +{ BIO *in; EVP_PKEY *key; - fprintf(stderr, "(TEST_ENG_OPENSSL_PKEY)Loading Private key %s\n", key_id); + + fprintf(stderr, "(TEST_ENG_OPENSSL_PKEY)Loading Private key %s\n", + key_id); in = BIO_new_file(key_id, "r"); if (!in) return NULL; key = PEM_read_bio_PrivateKey(in, NULL, 0, NULL); BIO_free(in); return key; - } +} #endif diff --git a/lib/libcrypto/engine/eng_padlock.c b/lib/libcrypto/engine/eng_padlock.c index 0245f44de60..936a440b1a8 100644 --- a/lib/libcrypto/engine/eng_padlock.c +++ b/lib/libcrypto/engine/eng_padlock.c @@ -1,11 +1,11 @@ -/* $OpenBSD: eng_padlock.c,v 1.10 2014/06/12 15:49:29 deraadt Exp $ */ -/* +/* $OpenBSD: eng_padlock.c,v 1.11 2014/06/22 12:05:09 jsing Exp $ */ +/* * Support for VIA PadLock Advanced Cryptography Engine (ACE) * Written by Michal Ludvig <michal@logix.cz> * http://www.logix.cz/michal * - * Big thanks to Andy Polyakov for a help with optimization, - * assembler fixes, port to MS Windows and a lot of other + * Big thanks to Andy Polyakov for a help with optimization, + * assembler fixes, port to MS Windows and a lot of other * valuable work on this engine! */ @@ -97,7 +97,7 @@ /* VIA PadLock AES is available *ONLY* on some x86 CPUs. Not only that it doesn't exist elsewhere, but it even can't be compiled on other platforms! - + In addition, because of the heavy use of inline assembler, compiler choice is limited to GCC and Microsoft C. */ #undef COMPILE_HW_PADLOCK @@ -117,7 +117,8 @@ void ENGINE_load_padlock (void) /* On non-x86 CPUs it just returns. */ #ifdef COMPILE_HW_PADLOCK ENGINE *toadd = ENGINE_padlock (); - if (!toadd) return; + if (!toadd) + return; ENGINE_add (toadd); ENGINE_free (toadd); ERR_clear_error (); @@ -169,19 +170,18 @@ padlock_bind_helper(ENGINE *e) padlock_available(); #if 1 /* disable RNG for now, see commentary in vicinity of RNG code */ - padlock_use_rng=0; + padlock_use_rng = 0; #endif /* Generate a nice engine name with available features */ (void) snprintf(padlock_name, sizeof(padlock_name), - "VIA PadLock (%s, %s)", - padlock_use_rng ? "RNG" : "no-RNG", - padlock_use_ace ? "ACE" : "no-ACE"); + "VIA PadLock (%s, %s)", + padlock_use_rng ? "RNG" : "no-RNG", + padlock_use_ace ? "ACE" : "no-ACE"); - /* Register everything or return with an error */ + /* Register everything or return with an error */ if (!ENGINE_set_id(e, padlock_id) || !ENGINE_set_name(e, padlock_name) || - !ENGINE_set_init_function(e, padlock_init) || #ifndef OPENSSL_NO_AES (padlock_use_ace && !ENGINE_set_ciphers (e, padlock_ciphers)) || @@ -254,26 +254,26 @@ IMPLEMENT_DYNAMIC_BIND_FN (padlock_bind_fn) #define AES_KEY_SIZE_192 24 #define AES_KEY_SIZE_256 32 -/* Here we store the status information relevant to the +/* Here we store the status information relevant to the current context. */ /* BIG FAT WARNING: * Inline assembler in PADLOCK_XCRYPT_ASM() * depends on the order of items in this structure. * Don't blindly modify, reorder, etc! */ -struct padlock_cipher_data -{ +struct padlock_cipher_data { unsigned char iv[AES_BLOCK_SIZE]; /* Initialization vector */ - union { unsigned int pad[4]; + union { + unsigned int pad[4]; struct { - int rounds:4; - int dgst:1; /* n/a in C3 */ - int align:1; /* n/a in C3 */ - int ciphr:1; /* n/a in C3 */ - unsigned int keygen:1; - int interm:1; - unsigned int encdec:1; - int ksize:2; + int rounds : 4; + int dgst : 1; /* n/a in C3 */ + int align : 1; /* n/a in C3 */ + int ciphr : 1; /* n/a in C3 */ + unsigned int keygen : 1; + int interm : 1; + unsigned int encdec : 1; + int ksize : 2; } b; } cword; /* Control word */ AES_KEY ks; /* Encryption key */ @@ -313,23 +313,23 @@ padlock_insn_cpuid_available(void) { int result = -1; - /* We're checking if the bit #21 of EFLAGS + /* We're checking if the bit #21 of EFLAGS can be toggled. If yes = CPUID is available. */ asm volatile ( - "pushf\n" - "popl %%eax\n" - "xorl $0x200000, %%eax\n" - "movl %%eax, %%ecx\n" - "andl $0x200000, %%ecx\n" - "pushl %%eax\n" - "popf\n" - "pushf\n" - "popl %%eax\n" - "andl $0x200000, %%eax\n" - "xorl %%eax, %%ecx\n" - "movl %%ecx, %0\n" - : "=r" (result) : : "eax", "ecx"); - + "pushf\n" + "popl %%eax\n" + "xorl $0x200000, %%eax\n" + "movl %%eax, %%ecx\n" + "andl $0x200000, %%ecx\n" + "pushl %%eax\n" + "popf\n" + "pushf\n" + "popl %%eax\n" + "andl $0x200000, %%eax\n" + "xorl %%eax, %%ecx\n" + "movl %%ecx, %0\n" + : "=r" (result) : : "eax", "ecx"); + return (result == 0); } @@ -349,31 +349,31 @@ padlock_available(void) eax = 0x00000000; vendor_string[12] = 0; asm volatile ( - "pushl %%ebx\n" - "cpuid\n" - "movl %%ebx,(%%edi)\n" - "movl %%edx,4(%%edi)\n" - "movl %%ecx,8(%%edi)\n" - "popl %%ebx" - : "+a"(eax) : "D"(vendor_string) : "ecx", "edx"); + "pushl %%ebx\n" + "cpuid\n" + "movl %%ebx,(%%edi)\n" + "movl %%edx,4(%%edi)\n" + "movl %%ecx,8(%%edi)\n" + "popl %%ebx" + : "+a"(eax) : "D"(vendor_string) : "ecx", "edx"); if (strcmp(vendor_string, "CentaurHauls") != 0) return 0; /* Check for Centaur Extended Feature Flags presence */ eax = 0xC0000000; asm volatile ("pushl %%ebx; cpuid; popl %%ebx" - : "+a"(eax) : : "ecx", "edx"); + : "+a"(eax) : : "ecx", "edx"); if (eax < 0xC0000001) return 0; /* Read the Centaur Extended Feature Flags */ eax = 0xC0000001; asm volatile ("pushl %%ebx; cpuid; popl %%ebx" - : "+a"(eax), "=d"(edx) : : "ecx"); + : "+a"(eax), "=d"(edx) : : "ecx"); /* Fill up some flags */ - padlock_use_ace = ((edx & (0x3<<6)) == (0x3<<6)); - padlock_use_rng = ((edx & (0x3<<2)) == (0x3<<2)); + padlock_use_ace = ((edx & (0x3 << 6)) == (0x3 << 6)); + padlock_use_rng = ((edx & (0x3 << 2)) == (0x3 << 2)); return padlock_use_ace + padlock_use_rng; } @@ -394,7 +394,7 @@ padlock_bswapl(AES_KEY *ks) #endif /* Force key reload from memory to the CPU microcode. - Loading EFLAGS from the stack clears EFLAGS[30] + Loading EFLAGS from the stack clears EFLAGS[30] which does the trick. */ static inline void padlock_reload_key(void) @@ -416,21 +416,21 @@ static inline void padlock_verify_context(struct padlock_cipher_data *cdata) { asm volatile ( - "pushfl\n" -" btl $30,(%%esp)\n" -" jnc 1f\n" -" cmpl %2,%1\n" -" je 1f\n" -" popfl\n" -" subl $4,%%esp\n" -"1: addl $4,%%esp\n" -" movl %2,%0" - :"+m"(padlock_saved_context) + "pushfl\n" + " btl $30,(%%esp)\n" + " jnc 1f\n" + " cmpl %2,%1\n" + " je 1f\n" + " popfl\n" + " subl $4,%%esp\n" + "1: addl $4,%%esp\n" + " movl %2,%0" + :"+m"(padlock_saved_context) : "r"(padlock_saved_context), "r"(cdata) : "cc"); } /* Template for padlock_xcrypt_* modes */ -/* BIG FAT WARNING: +/* BIG FAT WARNING: * The offsets used with 'leal' instructions * describe items of the 'padlock_cipher_data' * structure. @@ -465,9 +465,9 @@ padlock_xstore(void *addr, unsigned int edx_in) unsigned int eax_out; asm volatile (".byte 0x0f,0xa7,0xc0" /* xstore */ - : "=a"(eax_out),"=m"(*(unsigned *)addr) - : "D"(addr), "d" (edx_in) - ); + : "=a"(eax_out),"=m"(*(unsigned *)addr) + : "D"(addr), "d" (edx_in) + ); return eax_out; } @@ -482,15 +482,16 @@ padlock_xstore(void *addr, unsigned int edx_in) * In case you wonder 'rep xcrypt*' instructions above are *not* * affected by the Direction Flag and pointers advance toward * larger addresses unconditionally. - */ + */ static inline unsigned char * -padlock_memcpy(void *dst,const void *src,size_t n) +padlock_memcpy(void *dst, const void *src, size_t n) { - long *d=dst; - const long *s=src; + long *d = dst; + const long *s = src; n /= sizeof(*d); - do { *d++ = *s++; } while (--n); + do { *d++ = *s++; + } while (--n); return dst; } @@ -541,13 +542,13 @@ static int padlock_cipher_nids[] = { NID_aes_256_ofb, }; static int padlock_cipher_nids_num = (sizeof(padlock_cipher_nids)/ - sizeof(padlock_cipher_nids[0])); +sizeof(padlock_cipher_nids[0])); /* Function prototypes ... */ static int padlock_aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, - const unsigned char *iv, int enc); + const unsigned char *iv, int enc); static int padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, - const unsigned char *in, size_t nbytes); + const unsigned char *in, size_t nbytes); #define NEAREST_ALIGNED(ptr) ( (unsigned char *)(ptr) + \ ( (0x10 - ((size_t)(ptr) & 0x0F)) & 0x0F ) ) @@ -578,23 +579,23 @@ static const EVP_CIPHER padlock_aes_##ksize##_##lmode = { \ NULL \ } -DECLARE_AES_EVP(128,ecb,ECB); -DECLARE_AES_EVP(128,cbc,CBC); -DECLARE_AES_EVP(128,cfb,CFB); -DECLARE_AES_EVP(128,ofb,OFB); +DECLARE_AES_EVP(128, ecb, ECB); +DECLARE_AES_EVP(128, cbc, CBC); +DECLARE_AES_EVP(128, cfb, CFB); +DECLARE_AES_EVP(128, ofb, OFB); -DECLARE_AES_EVP(192,ecb,ECB); -DECLARE_AES_EVP(192,cbc,CBC); -DECLARE_AES_EVP(192,cfb,CFB); -DECLARE_AES_EVP(192,ofb,OFB); +DECLARE_AES_EVP(192, ecb, ECB); +DECLARE_AES_EVP(192, cbc, CBC); +DECLARE_AES_EVP(192, cfb, CFB); +DECLARE_AES_EVP(192, ofb, OFB); -DECLARE_AES_EVP(256,ecb,ECB); -DECLARE_AES_EVP(256,cbc,CBC); -DECLARE_AES_EVP(256,cfb,CFB); -DECLARE_AES_EVP(256,ofb,OFB); +DECLARE_AES_EVP(256, ecb, ECB); +DECLARE_AES_EVP(256, cbc, CBC); +DECLARE_AES_EVP(256, cfb, CFB); +DECLARE_AES_EVP(256, ofb, OFB); static int -padlock_ciphers (ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid) +padlock_ciphers(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid) { /* No specific cipher => return a list of supported nids ... */ if (!cipher) { @@ -604,49 +605,46 @@ padlock_ciphers (ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid /* ... or the requested "cipher" otherwise */ switch (nid) { - case NID_aes_128_ecb: - *cipher = &padlock_aes_128_ecb; - break; - case NID_aes_128_cbc: - *cipher = &padlock_aes_128_cbc; - break; - case NID_aes_128_cfb: - *cipher = &padlock_aes_128_cfb; - break; - case NID_aes_128_ofb: - *cipher = &padlock_aes_128_ofb; - break; - - case NID_aes_192_ecb: - *cipher = &padlock_aes_192_ecb; - break; - case NID_aes_192_cbc: - *cipher = &padlock_aes_192_cbc; - break; - case NID_aes_192_cfb: - *cipher = &padlock_aes_192_cfb; - break; - case NID_aes_192_ofb: - *cipher = &padlock_aes_192_ofb; - break; - - case NID_aes_256_ecb: - *cipher = &padlock_aes_256_ecb; - break; - case NID_aes_256_cbc: - *cipher = &padlock_aes_256_cbc; - break; - case NID_aes_256_cfb: - *cipher = &padlock_aes_256_cfb; - break; - case NID_aes_256_ofb: - *cipher = &padlock_aes_256_ofb; - break; - - default: - /* Sorry, we don't support this NID */ - *cipher = NULL; - return 0; + case NID_aes_128_ecb: + *cipher = &padlock_aes_128_ecb; + break; + case NID_aes_128_cbc: + *cipher = &padlock_aes_128_cbc; + break; + case NID_aes_128_cfb: + *cipher = &padlock_aes_128_cfb; + break; + case NID_aes_128_ofb: + *cipher = &padlock_aes_128_ofb; + break; + case NID_aes_192_ecb: + *cipher = &padlock_aes_192_ecb; + break; + case NID_aes_192_cbc: + *cipher = &padlock_aes_192_cbc; + break; + case NID_aes_192_cfb: + *cipher = &padlock_aes_192_cfb; + break; + case NID_aes_192_ofb: + *cipher = &padlock_aes_192_ofb; + break; + case NID_aes_256_ecb: + *cipher = &padlock_aes_256_ecb; + break; + case NID_aes_256_cbc: + *cipher = &padlock_aes_256_cbc; + break; + case NID_aes_256_cfb: + *cipher = &padlock_aes_256_cfb; + break; + case NID_aes_256_ofb: + *cipher = &padlock_aes_256_ofb; + break; + default: + /* Sorry, we don't support this NID */ + *cipher = NULL; + return 0; } return 1; @@ -655,12 +653,13 @@ padlock_ciphers (ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid /* Prepare the encryption key for PadLock usage */ static int padlock_aes_init_key (EVP_CIPHER_CTX *ctx, const unsigned char *key, - const unsigned char *iv, int enc) + const unsigned char *iv, int enc) { struct padlock_cipher_data *cdata; int key_len = EVP_CIPHER_CTX_key_length(ctx) * 8; - if (key==NULL) return 0; /* ERROR */ + if (key == NULL) + return 0; /* ERROR */ cdata = ALIGNED_CIPHER_DATA(ctx); memset(cdata, 0, sizeof(struct padlock_cipher_data)); @@ -673,38 +672,38 @@ padlock_aes_init_key (EVP_CIPHER_CTX *ctx, const unsigned char *key, cdata->cword.b.rounds = 10 + (key_len - 128) / 32; cdata->cword.b.ksize = (key_len - 128) / 64; - switch(key_len) { - case 128: - /* PadLock can generate an extended key for - AES128 in hardware */ - memcpy(cdata->ks.rd_key, key, AES_KEY_SIZE_128); - cdata->cword.b.keygen = 0; - break; + switch (key_len) { + case 128: + /* PadLock can generate an extended key for + AES128 in hardware */ + memcpy(cdata->ks.rd_key, key, AES_KEY_SIZE_128); + cdata->cword.b.keygen = 0; + break; - case 192: - case 256: - /* Generate an extended AES key in software. - Needed for AES192/AES256 */ - /* Well, the above applies to Stepping 8 CPUs - and is listed as hardware errata. They most - likely will fix it at some point and then - a check for stepping would be due here. */ - if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_CFB_MODE || - EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_OFB_MODE || - enc) - AES_set_encrypt_key(key, key_len, &cdata->ks); - else - AES_set_decrypt_key(key, key_len, &cdata->ks); + case 192: + case 256: + /* Generate an extended AES key in software. + Needed for AES192/AES256 */ + /* Well, the above applies to Stepping 8 CPUs + and is listed as hardware errata. They most + likely will fix it at some point and then + a check for stepping would be due here. */ + if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_CFB_MODE || + EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_OFB_MODE || + enc) + AES_set_encrypt_key(key, key_len, &cdata->ks); + else + AES_set_decrypt_key(key, key_len, &cdata->ks); #ifndef AES_ASM - /* OpenSSL C functions use byte-swapped extended key. */ - padlock_bswapl(&cdata->ks); + /* OpenSSL C functions use byte-swapped extended key. */ + padlock_bswapl(&cdata->ks); #endif - cdata->cword.b.keygen = 1; - break; + cdata->cword.b.keygen = 1; + break; - default: - /* ERROR */ - return 0; + default: + /* ERROR */ + return 0; } /* @@ -717,7 +716,7 @@ padlock_aes_init_key (EVP_CIPHER_CTX *ctx, const unsigned char *key, return 1; } -/* +/* * Simplified version of padlock_aes_cipher() used when * 1) both input and output buffers are at aligned addresses. * or when @@ -725,7 +724,7 @@ padlock_aes_init_key (EVP_CIPHER_CTX *ctx, const unsigned char *key, */ static int padlock_aes_cipher_omnivorous(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, - const unsigned char *in_arg, size_t nbytes) + const unsigned char *in_arg, size_t nbytes) { struct padlock_cipher_data *cdata; void *iv; @@ -735,24 +734,28 @@ padlock_aes_cipher_omnivorous(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, switch (EVP_CIPHER_CTX_mode(ctx)) { case EVP_CIPH_ECB_MODE: - padlock_xcrypt_ecb(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg); + padlock_xcrypt_ecb(nbytes / AES_BLOCK_SIZE, cdata, + out_arg, in_arg); break; case EVP_CIPH_CBC_MODE: memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE); - iv = padlock_xcrypt_cbc(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg); + iv = padlock_xcrypt_cbc(nbytes / AES_BLOCK_SIZE, cdata, + out_arg, in_arg); memcpy(ctx->iv, iv, AES_BLOCK_SIZE); break; case EVP_CIPH_CFB_MODE: memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE); - iv = padlock_xcrypt_cfb(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg); + iv = padlock_xcrypt_cfb(nbytes / AES_BLOCK_SIZE, cdata, + out_arg, in_arg); memcpy(ctx->iv, iv, AES_BLOCK_SIZE); break; case EVP_CIPH_OFB_MODE: memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE); - padlock_xcrypt_ofb(nbytes/AES_BLOCK_SIZE, cdata, out_arg, in_arg); + padlock_xcrypt_ofb(nbytes / AES_BLOCK_SIZE, cdata, + out_arg, in_arg); memcpy(ctx->iv, cdata->iv, AES_BLOCK_SIZE); break; @@ -772,23 +775,24 @@ padlock_aes_cipher_omnivorous(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, # error "insane PADLOCK_CHUNK..." #endif -/* Re-align the arguments to 16-Bytes boundaries and run the +/* Re-align the arguments to 16-Bytes boundaries and run the encryption function itself. This function is not AES-specific. */ static int padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, - const unsigned char *in_arg, size_t nbytes) + const unsigned char *in_arg, size_t nbytes) { struct padlock_cipher_data *cdata; const void *inp; unsigned char *out; void *iv; int inp_misaligned, out_misaligned, realign_in_loop; - size_t chunk, allocated=0; + size_t chunk, allocated = 0; /* ctx->num is maintained in byte-oriented modes, such as CFB and OFB... */ - if ((chunk = ctx->num)) { /* borrow chunk variable */ - unsigned char *ivp=ctx->iv; + if ((chunk = ctx->num)) { + /* borrow chunk variable */ + unsigned char *ivp = ctx->iv; switch (EVP_CIPHER_CTX_mode(ctx)) { case EVP_CIPH_CFB_MODE: @@ -796,28 +800,29 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, return 0; /* bogus value */ if (ctx->encrypt) - while (chunk<AES_BLOCK_SIZE && nbytes!=0) { + while (chunk < AES_BLOCK_SIZE && nbytes != 0) { ivp[chunk] = *(out_arg++) = *(in_arg++) ^ ivp[chunk]; chunk++, nbytes--; } - else while (chunk<AES_BLOCK_SIZE && nbytes!=0) { + else + while (chunk < AES_BLOCK_SIZE && nbytes != 0) { unsigned char c = *(in_arg++); *(out_arg++) = c ^ ivp[chunk]; ivp[chunk++] = c, nbytes--; } - ctx->num = chunk%AES_BLOCK_SIZE; + ctx->num = chunk % AES_BLOCK_SIZE; break; case EVP_CIPH_OFB_MODE: if (chunk >= AES_BLOCK_SIZE) return 0; /* bogus value */ - while (chunk<AES_BLOCK_SIZE && nbytes!=0) { + while (chunk < AES_BLOCK_SIZE && nbytes != 0) { *(out_arg++) = *(in_arg++) ^ ivp[chunk]; chunk++, nbytes--; } - ctx->num = chunk%AES_BLOCK_SIZE; + ctx->num = chunk % AES_BLOCK_SIZE; break; } } @@ -841,8 +846,9 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, same as for software alignment below or ~3x. They promise to improve it in the future, but for now we can just as well pretend that it can only handle aligned input... */ - if (!padlock_aes_align_required && (nbytes%AES_BLOCK_SIZE)==0) - return padlock_aes_cipher_omnivorous(ctx, out_arg, in_arg, nbytes); + if (!padlock_aes_align_required && (nbytes % AES_BLOCK_SIZE) == 0) + return padlock_aes_cipher_omnivorous(ctx, out_arg, in_arg, + nbytes); inp_misaligned = (((size_t)in_arg) & 0x0F); out_misaligned = (((size_t)out_arg) & 0x0F); @@ -853,21 +859,22 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, * in order to improve L1 cache utilization... */ realign_in_loop = out_misaligned|inp_misaligned; - if (!realign_in_loop && (nbytes%AES_BLOCK_SIZE)==0) - return padlock_aes_cipher_omnivorous(ctx, out_arg, in_arg, nbytes); + if (!realign_in_loop && (nbytes % AES_BLOCK_SIZE) == 0) + return padlock_aes_cipher_omnivorous(ctx, out_arg, in_arg, + nbytes); /* this takes one "if" out of the loops */ - chunk = nbytes; + chunk = nbytes; chunk %= PADLOCK_CHUNK; - if (chunk==0) chunk = PADLOCK_CHUNK; + if (chunk == 0) + chunk = PADLOCK_CHUNK; if (out_misaligned) { /* optmize for small input */ - allocated = (chunk<nbytes?PADLOCK_CHUNK:nbytes); + allocated = (chunk < nbytes ? PADLOCK_CHUNK : nbytes); out = alloca(0x10 + allocated); out = NEAREST_ALIGNED(out); - } - else + } else out = out_arg; cdata = ALIGNED_CIPHER_DATA(ctx); @@ -875,77 +882,84 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, switch (EVP_CIPHER_CTX_mode(ctx)) { case EVP_CIPH_ECB_MODE: - do { + do { if (inp_misaligned) inp = padlock_memcpy(out, in_arg, chunk); else inp = in_arg; in_arg += chunk; - padlock_xcrypt_ecb(chunk/AES_BLOCK_SIZE, cdata, out, inp); + padlock_xcrypt_ecb(chunk / AES_BLOCK_SIZE, cdata, + out, inp); if (out_misaligned) - out_arg = padlock_memcpy(out_arg, out, chunk) + chunk; + out_arg = padlock_memcpy(out_arg, out, chunk) + + chunk; else - out = out_arg+=chunk; + out = out_arg += chunk; nbytes -= chunk; - chunk = PADLOCK_CHUNK; + chunk = PADLOCK_CHUNK; } while (nbytes); break; case EVP_CIPH_CBC_MODE: memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE); goto cbc_shortcut; - do { + do { if (iv != cdata->iv) memcpy(cdata->iv, iv, AES_BLOCK_SIZE); chunk = PADLOCK_CHUNK; - cbc_shortcut: /* optimize for small input */ + cbc_shortcut: /* optimize for small input */ if (inp_misaligned) inp = padlock_memcpy(out, in_arg, chunk); else inp = in_arg; in_arg += chunk; - iv = padlock_xcrypt_cbc(chunk/AES_BLOCK_SIZE, cdata, out, inp); + iv = padlock_xcrypt_cbc(chunk / AES_BLOCK_SIZE, cdata, + out, inp); if (out_misaligned) - out_arg = padlock_memcpy(out_arg, out, chunk) + chunk; + out_arg = padlock_memcpy(out_arg, out, chunk) + + chunk; else - out = out_arg+=chunk; - + out = out_arg += chunk; } while (nbytes -= chunk); memcpy(ctx->iv, iv, AES_BLOCK_SIZE); break; case EVP_CIPH_CFB_MODE: memcpy (iv = cdata->iv, ctx->iv, AES_BLOCK_SIZE); - chunk &= ~(AES_BLOCK_SIZE-1); - if (chunk) goto cfb_shortcut; - else goto cfb_skiploop; - do { + chunk &= ~(AES_BLOCK_SIZE - 1); + if (chunk) + goto cfb_shortcut; + else + goto cfb_skiploop; + do { if (iv != cdata->iv) memcpy(cdata->iv, iv, AES_BLOCK_SIZE); chunk = PADLOCK_CHUNK; - cfb_shortcut: /* optimize for small input */ + cfb_shortcut: /* optimize for small input */ if (inp_misaligned) inp = padlock_memcpy(out, in_arg, chunk); else inp = in_arg; in_arg += chunk; - iv = padlock_xcrypt_cfb(chunk/AES_BLOCK_SIZE, cdata, out, inp); + iv = padlock_xcrypt_cfb(chunk / AES_BLOCK_SIZE, cdata, + out, inp); if (out_misaligned) - out_arg = padlock_memcpy(out_arg, out, chunk) + chunk; + out_arg = padlock_memcpy(out_arg, out, chunk) + + chunk; else - out = out_arg+=chunk; + out = out_arg += chunk; nbytes -= chunk; } while (nbytes >= AES_BLOCK_SIZE); - cfb_skiploop: +cfb_skiploop: if (nbytes) { unsigned char *ivp = cdata->iv; @@ -955,19 +969,19 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, } ctx->num = nbytes; if (cdata->cword.b.encdec) { - cdata->cword.b.encdec=0; + cdata->cword.b.encdec = 0; padlock_reload_key(); - padlock_xcrypt_ecb(1,cdata,ivp,ivp); - cdata->cword.b.encdec=1; + padlock_xcrypt_ecb(1, cdata, ivp, ivp); + cdata->cword.b.encdec = 1; padlock_reload_key(); - while(nbytes) { + while (nbytes) { unsigned char c = *(in_arg++); *(out_arg++) = c ^ *ivp; *(ivp++) = c, nbytes--; } - } - else { padlock_reload_key(); - padlock_xcrypt_ecb(1,cdata,ivp,ivp); + } else { + padlock_reload_key(); + padlock_xcrypt_ecb(1, cdata, ivp, ivp); padlock_reload_key(); while (nbytes) { *ivp = *(out_arg++) = *(in_arg++) ^ *ivp; @@ -981,7 +995,7 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, case EVP_CIPH_OFB_MODE: memcpy(cdata->iv, ctx->iv, AES_BLOCK_SIZE); - chunk &= ~(AES_BLOCK_SIZE-1); + chunk &= ~(AES_BLOCK_SIZE - 1); if (chunk) do { if (inp_misaligned) inp = padlock_memcpy(out, in_arg, chunk); @@ -989,15 +1003,17 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, inp = in_arg; in_arg += chunk; - padlock_xcrypt_ofb(chunk/AES_BLOCK_SIZE, cdata, out, inp); + padlock_xcrypt_ofb(chunk / AES_BLOCK_SIZE, cdata, + out, inp); if (out_misaligned) - out_arg = padlock_memcpy(out_arg, out, chunk) + chunk; + out_arg = padlock_memcpy(out_arg, out, chunk) + + chunk; else - out = out_arg+=chunk; + out = out_arg += chunk; nbytes -= chunk; - chunk = PADLOCK_CHUNK; + chunk = PADLOCK_CHUNK; } while (nbytes >= AES_BLOCK_SIZE); if (nbytes) { @@ -1005,7 +1021,7 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, ctx->num = nbytes; padlock_reload_key(); /* empirically found */ - padlock_xcrypt_ecb(1,cdata,ivp,ivp); + padlock_xcrypt_ecb(1, cdata, ivp, ivp); padlock_reload_key(); /* empirically found */ while (nbytes) { *(out_arg++) = *(in_arg++) ^ *ivp; @@ -1022,9 +1038,10 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, /* Clean the realign buffer if it was used */ if (out_misaligned) { - volatile unsigned long *p=(void *)out; - size_t n = allocated/sizeof(*p); - while (n--) *p++=0; + volatile unsigned long *p = (void *)out; + size_t n = allocated/sizeof(*p); + while (n--) + *p++ = 0; } memset(cdata->iv, 0, AES_BLOCK_SIZE); @@ -1041,7 +1058,7 @@ padlock_aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out_arg, * (posted at http://www.via.com.tw/en/viac3/c3.jsp) nor does it * provide meaningful error control... */ -/* Wrapper that provides an interface between the API and +/* Wrapper that provides an interface between the API and the raw PadLock RNG */ static int padlock_rand_bytes(unsigned char *output, int count) @@ -1050,25 +1067,33 @@ padlock_rand_bytes(unsigned char *output, int count) while (count >= 8) { eax = padlock_xstore(output, 0); - if (!(eax&(1<<6))) return 0; /* RNG disabled */ + if (!(eax & (1 << 6))) + return 0; /* RNG disabled */ /* this ---vv--- covers DC bias, Raw Bits and String Filter */ - if (eax&(0x1F<<10)) return 0; - if ((eax&0x1F)==0) continue; /* no data, retry... */ - if ((eax&0x1F)!=8) return 0; /* fatal failure... */ + if (eax & (0x1F << 10)) + return 0; + if ((eax & 0x1F) == 0) + continue; /* no data, retry... */ + if ((eax & 0x1F) != 8) + return 0; /* fatal failure... */ output += 8; - count -= 8; + count -= 8; } while (count > 0) { eax = padlock_xstore(&buf, 3); - if (!(eax&(1<<6))) return 0; /* RNG disabled */ + if (!(eax & (1 << 6))) + return 0; /* RNG disabled */ /* this ---vv--- covers DC bias, Raw Bits and String Filter */ - if (eax&(0x1F<<10)) return 0; - if ((eax&0x1F)==0) continue; /* no data, retry... */ - if ((eax&0x1F)!=1) return 0; /* fatal failure... */ + if (eax & (0x1F << 10)) + return 0; + if ((eax & 0x1F) == 0) + continue; /* no data, retry... */ + if ((eax & 0x1F) != 1) + return 0; /* fatal failure... */ *output++ = (unsigned char)buf; count--; } - *(volatile unsigned int *)&buf=0; + *(volatile unsigned int *)&buf = 0; return 1; } @@ -1089,10 +1114,11 @@ static RAND_METHOD padlock_rand = { #else /* !COMPILE_HW_PADLOCK */ #ifndef OPENSSL_NO_DYNAMIC_ENGINE -extern -int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); -extern -int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { return 0; } +extern int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); +extern int +bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { + return 0; +} IMPLEMENT_DYNAMIC_CHECK_FN() #endif #endif /* COMPILE_HW_PADLOCK */ diff --git a/lib/libcrypto/engine/eng_pkey.c b/lib/libcrypto/engine/eng_pkey.c index 410a9c3373a..dc832450a68 100644 --- a/lib/libcrypto/engine/eng_pkey.c +++ b/lib/libcrypto/engine/eng_pkey.c @@ -1,4 +1,4 @@ -/* $OpenBSD: eng_pkey.c,v 1.4 2014/06/12 15:49:29 deraadt Exp $ */ +/* $OpenBSD: eng_pkey.c,v 1.5 2014/06/22 12:05:09 jsing Exp $ */ /* ==================================================================== * Copyright (c) 1999-2001 The OpenSSL Project. All rights reserved. * @@ -7,7 +7,7 @@ * are met: * * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in @@ -57,140 +57,137 @@ /* Basic get/set stuff */ -int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f) - { +int +ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f) +{ e->load_privkey = loadpriv_f; return 1; - } +} -int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f) - { +int +ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f) +{ e->load_pubkey = loadpub_f; return 1; - } +} -int ENGINE_set_load_ssl_client_cert_function(ENGINE *e, - ENGINE_SSL_CLIENT_CERT_PTR loadssl_f) - { +int +ENGINE_set_load_ssl_client_cert_function(ENGINE *e, + ENGINE_SSL_CLIENT_CERT_PTR loadssl_f) +{ e->load_ssl_client_cert = loadssl_f; return 1; - } +} -ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e) - { +ENGINE_LOAD_KEY_PTR +ENGINE_get_load_privkey_function(const ENGINE *e) +{ return e->load_privkey; - } +} -ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e) - { +ENGINE_LOAD_KEY_PTR +ENGINE_get_load_pubkey_function(const ENGINE *e) +{ return e->load_pubkey; - } +} -ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE *e) - { +ENGINE_SSL_CLIENT_CERT_PTR +ENGINE_get_ssl_client_cert_function(const ENGINE *e) +{ return e->load_ssl_client_cert; - } +} /* API functions to load public/private keys */ -EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id, - UI_METHOD *ui_method, void *callback_data) - { +EVP_PKEY * +ENGINE_load_private_key(ENGINE *e, const char *key_id, UI_METHOD *ui_method, + void *callback_data) +{ EVP_PKEY *pkey; - if(e == NULL) - { + if (e == NULL) { ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY, - ERR_R_PASSED_NULL_PARAMETER); + ERR_R_PASSED_NULL_PARAMETER); return 0; - } + } CRYPTO_w_lock(CRYPTO_LOCK_ENGINE); - if(e->funct_ref == 0) - { + if (e->funct_ref == 0) { CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY, - ENGINE_R_NOT_INITIALISED); + ENGINE_R_NOT_INITIALISED); return 0; - } + } CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); - if (!e->load_privkey) - { + if (!e->load_privkey) { ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY, - ENGINE_R_NO_LOAD_FUNCTION); + ENGINE_R_NO_LOAD_FUNCTION); return 0; - } + } pkey = e->load_privkey(e, key_id, ui_method, callback_data); - if (!pkey) - { + if (!pkey) { ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY, - ENGINE_R_FAILED_LOADING_PRIVATE_KEY); + ENGINE_R_FAILED_LOADING_PRIVATE_KEY); return 0; - } - return pkey; } + return pkey; +} -EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id, - UI_METHOD *ui_method, void *callback_data) - { +EVP_PKEY * +ENGINE_load_public_key(ENGINE *e, const char *key_id, UI_METHOD *ui_method, + void *callback_data) +{ EVP_PKEY *pkey; - if(e == NULL) - { + if (e == NULL) { ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY, - ERR_R_PASSED_NULL_PARAMETER); + ERR_R_PASSED_NULL_PARAMETER); return 0; - } + } CRYPTO_w_lock(CRYPTO_LOCK_ENGINE); - if(e->funct_ref == 0) - { + if (e->funct_ref == 0) { CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY, - ENGINE_R_NOT_INITIALISED); + ENGINE_R_NOT_INITIALISED); return 0; - } + } CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); - if (!e->load_pubkey) - { + if (!e->load_pubkey) { ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY, - ENGINE_R_NO_LOAD_FUNCTION); + ENGINE_R_NO_LOAD_FUNCTION); return 0; - } + } pkey = e->load_pubkey(e, key_id, ui_method, callback_data); - if (!pkey) - { + if (!pkey) { ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY, - ENGINE_R_FAILED_LOADING_PUBLIC_KEY); + ENGINE_R_FAILED_LOADING_PUBLIC_KEY); return 0; - } - return pkey; } + return pkey; +} -int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, - STACK_OF(X509_NAME) *ca_dn, X509 **pcert, EVP_PKEY **ppkey, - STACK_OF(X509) **pother, UI_METHOD *ui_method, void *callback_data) - { - - if(e == NULL) - { +int +ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, STACK_OF(X509_NAME) *ca_dn, + X509 **pcert, EVP_PKEY **ppkey, STACK_OF(X509) **pother, + UI_METHOD *ui_method, void *callback_data) +{ + if (e == NULL) { ENGINEerr(ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT, - ERR_R_PASSED_NULL_PARAMETER); + ERR_R_PASSED_NULL_PARAMETER); return 0; - } + } CRYPTO_w_lock(CRYPTO_LOCK_ENGINE); - if(e->funct_ref == 0) - { + if (e->funct_ref == 0) { CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); ENGINEerr(ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT, - ENGINE_R_NOT_INITIALISED); + ENGINE_R_NOT_INITIALISED); return 0; - } + } CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); - if (!e->load_ssl_client_cert) - { + if (!e->load_ssl_client_cert) { ENGINEerr(ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT, - ENGINE_R_NO_LOAD_FUNCTION); + ENGINE_R_NO_LOAD_FUNCTION); return 0; - } - return e->load_ssl_client_cert(e, s, ca_dn, pcert, ppkey, pother, - ui_method, callback_data); } + return e->load_ssl_client_cert(e, s, ca_dn, pcert, ppkey, pother, + ui_method, callback_data); +} diff --git a/lib/libcrypto/engine/eng_rsax.c b/lib/libcrypto/engine/eng_rsax.c index f7b38b11560..ee184390702 100644 --- a/lib/libcrypto/engine/eng_rsax.c +++ b/lib/libcrypto/engine/eng_rsax.c @@ -1,4 +1,4 @@ -/* $OpenBSD: eng_rsax.c,v 1.6 2014/06/12 15:49:29 deraadt Exp $ */ +/* $OpenBSD: eng_rsax.c,v 1.7 2014/06/22 12:05:09 jsing Exp $ */ /* Copyright (c) 2010-2010 Intel Corp. * Author: Vinodh.Gopal@intel.com * Jim Guilford @@ -85,16 +85,17 @@ static ENGINE *ENGINE_rsax (void); #endif void ENGINE_load_rsax (void) - { +{ /* On non-x86 CPUs it just returns. */ #ifdef COMPILE_RSAX ENGINE *toadd = ENGINE_rsax(); - if(!toadd) return; + if (!toadd) + return; ENGINE_add(toadd); ENGINE_free(toadd); ERR_clear_error(); #endif - } +} #ifdef COMPILE_RSAX #define E_RSAX_LIB_NAME "rsax engine" @@ -106,13 +107,14 @@ static int e_rsax_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void)); #ifndef OPENSSL_NO_RSA /* RSA stuff */ -static int e_rsax_rsa_mod_exp(BIGNUM *r, const BIGNUM *I, RSA *rsa, BN_CTX *ctx); +static int e_rsax_rsa_mod_exp(BIGNUM *r, const BIGNUM *I, RSA *rsa, + BN_CTX *ctx); static int e_rsax_rsa_finish(RSA *r); #endif static const ENGINE_CMD_DEFN e_rsax_cmd_defns[] = { {0, NULL, NULL, 0} - }; +}; #ifndef OPENSSL_NO_RSA /* Our internal RSA_METHOD that we provide pointers to */ @@ -129,21 +131,22 @@ static const char *engine_e_rsax_id = "rsax"; static const char *engine_e_rsax_name = "RSAX engine support"; /* This internal function is used by ENGINE_rsax() */ -static int bind_helper(ENGINE *e) - { +static int +bind_helper(ENGINE *e) +{ #ifndef OPENSSL_NO_RSA const RSA_METHOD *meth1; #endif - if(!ENGINE_set_id(e, engine_e_rsax_id) || - !ENGINE_set_name(e, engine_e_rsax_name) || + if (!ENGINE_set_id(e, engine_e_rsax_id) || + !ENGINE_set_name(e, engine_e_rsax_name) || #ifndef OPENSSL_NO_RSA - !ENGINE_set_RSA(e, &e_rsax_rsa) || + !ENGINE_set_RSA(e, &e_rsax_rsa) || #endif - !ENGINE_set_destroy_function(e, e_rsax_destroy) || - !ENGINE_set_init_function(e, e_rsax_init) || - !ENGINE_set_finish_function(e, e_rsax_finish) || - !ENGINE_set_ctrl_function(e, e_rsax_ctrl) || - !ENGINE_set_cmd_defns(e, e_rsax_cmd_defns)) + !ENGINE_set_destroy_function(e, e_rsax_destroy) || + !ENGINE_set_init_function(e, e_rsax_init) || + !ENGINE_set_finish_function(e, e_rsax_finish) || + !ENGINE_set_ctrl_function(e, e_rsax_ctrl) || + !ENGINE_set_cmd_defns(e, e_rsax_cmd_defns)) return 0; #ifndef OPENSSL_NO_RSA @@ -155,64 +158,67 @@ static int bind_helper(ENGINE *e) e_rsax_rsa.bn_mod_exp = meth1->bn_mod_exp; #endif return 1; - } +} -static ENGINE *ENGINE_rsax(void) - { +static ENGINE * +ENGINE_rsax(void) +{ ENGINE *ret = ENGINE_new(); - if(!ret) + + if (!ret) return NULL; - if(!bind_helper(ret)) - { + if (!bind_helper(ret)) { ENGINE_free(ret); return NULL; - } - return ret; } + return ret; +} #ifndef OPENSSL_NO_RSA /* Used to attach our own key-data to an RSA structure */ static int rsax_ex_data_idx = -1; #endif -static int e_rsax_destroy(ENGINE *e) - { +static int +e_rsax_destroy(ENGINE *e) +{ return 1; - } +} /* (de)initialisation functions. */ -static int e_rsax_init(ENGINE *e) - { +static int +e_rsax_init(ENGINE *e) +{ #ifndef OPENSSL_NO_RSA if (rsax_ex_data_idx == -1) - rsax_ex_data_idx = RSA_get_ex_new_index(0, - NULL, - NULL, NULL, NULL); + rsax_ex_data_idx = RSA_get_ex_new_index(0, NULL, NULL, + NULL, NULL); #endif if (rsax_ex_data_idx == -1) return 0; return 1; - } +} -static int e_rsax_finish(ENGINE *e) - { +static int +e_rsax_finish(ENGINE *e) +{ return 1; - } +} -static int e_rsax_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void)) - { +static int +e_rsax_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void)) +{ int to_return = 1; - switch(cmd) - { - /* The command isn't understood by this engine */ + switch (cmd) { + /* The command isn't understood by this engine */ default: to_return = 0; break; - } + } return to_return; - } +} #ifndef OPENSSL_NO_RSA @@ -233,69 +239,71 @@ static int interleaved_array_to_bn_512(BIGNUM* b, UINT64 *array); /* Extract array elements from BIGNUM b * To set the whole array from b, call with n=8 */ -static int bn_extract_to_array_512(const BIGNUM* b, unsigned int n, UINT64 *array); +static int bn_extract_to_array_512(const BIGNUM* b, unsigned int n, + UINT64 *array); struct mod_ctx_512 { - UINT64 t[8][8]; - UINT64 m[8]; - UINT64 m1[8]; /* 2^278 % m */ - UINT64 m2[8]; /* 2^640 % m */ - UINT64 k1[2]; /* (- 1/m) % 2^128 */ + UINT64 t[8][8]; + UINT64 m[8]; + UINT64 m1[8]; /* 2^278 % m */ + UINT64 m2[8]; /* 2^640 % m */ + UINT64 k1[2]; /* (- 1/m) % 2^128 */ }; static int mod_exp_pre_compute_data_512(UINT64 *m, struct mod_ctx_512 *data); void mod_exp_512(UINT64 *result, /* 512 bits, 8 qwords */ - UINT64 *g, /* 512 bits, 8 qwords */ - UINT64 *exp, /* 512 bits, 8 qwords */ - struct mod_ctx_512 *data); - -typedef struct st_e_rsax_mod_ctx -{ - UINT64 type; - union { - struct mod_ctx_512 b512; - } ctx; - +UINT64 *g, /* 512 bits, 8 qwords */ +UINT64 *exp, /* 512 bits, 8 qwords */ +struct mod_ctx_512 *data); + +typedef struct st_e_rsax_mod_ctx { + UINT64 type; + union { + struct mod_ctx_512 b512; + } ctx; } E_RSAX_MOD_CTX; -static E_RSAX_MOD_CTX *e_rsax_get_ctx(RSA *rsa, int idx, BIGNUM* m) +static E_RSAX_MOD_CTX * +e_rsax_get_ctx(RSA *rsa, int idx, BIGNUM* m) { E_RSAX_MOD_CTX *hptr; - if (idx < 0 || idx > 2) - return NULL; + if (idx < 0 || idx > 2) + return NULL; hptr = RSA_get_ex_data(rsa, rsax_ex_data_idx); if (!hptr) { - hptr = reallocarray(NULL, 3, sizeof(E_RSAX_MOD_CTX)); - if (!hptr) return NULL; - hptr[2].type = hptr[1].type= hptr[0].type = 0; - RSA_set_ex_data(rsa, rsax_ex_data_idx, hptr); - } - - if (hptr[idx].type == (UINT64)BN_num_bits(m)) - return hptr+idx; - - if (BN_num_bits(m) == 512) { - UINT64 _m[8]; - bn_extract_to_array_512(m, 8, _m); - memset( &hptr[idx].ctx.b512, 0, sizeof(struct mod_ctx_512)); - mod_exp_pre_compute_data_512(_m, &hptr[idx].ctx.b512); + hptr = reallocarray(NULL, 3, sizeof(E_RSAX_MOD_CTX)); + if (!hptr) + return NULL; + hptr[2].type = hptr[1].type = hptr[0].type = 0; + RSA_set_ex_data(rsa, rsax_ex_data_idx, hptr); + } + + if (hptr[idx].type == (UINT64)BN_num_bits(m)) + return hptr + idx; + + if (BN_num_bits(m) == 512) { + UINT64 _m[8]; + bn_extract_to_array_512(m, 8, _m); + memset( &hptr[idx].ctx.b512, 0, sizeof(struct mod_ctx_512)); + mod_exp_pre_compute_data_512(_m, &hptr[idx].ctx.b512); } - hptr[idx].type = BN_num_bits(m); - return hptr+idx; + hptr[idx].type = BN_num_bits(m); + return hptr + idx; } -static int e_rsax_rsa_finish(RSA *rsa) - { +static int +e_rsax_rsa_finish(RSA *rsa) +{ E_RSAX_MOD_CTX *hptr = RSA_get_ex_data(rsa, rsax_ex_data_idx); - if(hptr) - { + + if (hptr) { free(hptr); RSA_set_ex_data(rsa, rsax_ex_data_idx, NULL); - } + } if (rsa->_method_mod_n) BN_MONT_CTX_free(rsa->_method_mod_n); if (rsa->_method_mod_p) @@ -303,28 +311,28 @@ static int e_rsax_rsa_finish(RSA *rsa) if (rsa->_method_mod_q) BN_MONT_CTX_free(rsa->_method_mod_q); return 1; - } - +} -static int e_rsax_bn_mod_exp(BIGNUM *r, const BIGNUM *g, const BIGNUM *e, - const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont, E_RSAX_MOD_CTX* rsax_mod_ctx ) +static int +e_rsax_bn_mod_exp(BIGNUM *r, const BIGNUM *g, const BIGNUM *e, const BIGNUM *m, + BN_CTX *ctx, BN_MONT_CTX *in_mont, E_RSAX_MOD_CTX* rsax_mod_ctx) { if (rsax_mod_ctx && BN_get_flags(e, BN_FLG_CONSTTIME) != 0) { - if (BN_num_bits(m) == 512) { - UINT64 _r[8]; - UINT64 _g[8]; - UINT64 _e[8]; - - /* Init the arrays from the BIGNUMs */ - bn_extract_to_array_512(g, 8, _g); - bn_extract_to_array_512(e, 8, _e); - - mod_exp_512(_r, _g, _e, &rsax_mod_ctx->ctx.b512); - /* Return the result in the BIGNUM */ - interleaved_array_to_bn_512(r, _r); - return 1; - } - } + if (BN_num_bits(m) == 512) { + UINT64 _r[8]; + UINT64 _g[8]; + UINT64 _e[8]; + + /* Init the arrays from the BIGNUMs */ + bn_extract_to_array_512(g, 8, _g); + bn_extract_to_array_512(e, 8, _e); + + mod_exp_512(_r, _g, _e, &rsax_mod_ctx->ctx.b512); + /* Return the result in the BIGNUM */ + interleaved_array_to_bn_512(r, _r); + return 1; + } + } return BN_mod_exp_mont(r, g, e, m, ctx, in_mont); } @@ -339,146 +347,177 @@ static int e_rsax_bn_mod_exp(BIGNUM *r, const BIGNUM *g, const BIGNUM *e, * Local method: extracts a piece from a BIGNUM, to fit it into * an array. Call with n=8 to extract an entire 512-bit BIGNUM */ -static int bn_extract_to_array_512(const BIGNUM* b, unsigned int n, UINT64 *array) +static int +bn_extract_to_array_512(const BIGNUM* b, unsigned int n, UINT64 *array) { int i; UINT64 tmp; unsigned char bn_buff[64]; + memset(bn_buff, 0, 64); if (BN_num_bytes(b) > 64) { printf ("Can't support this byte size\n"); - return 0; } - if (BN_num_bytes(b)!=0) { - if (!BN_bn2bin(b, bn_buff+(64-BN_num_bytes(b)))) { + return 0; + } + if (BN_num_bytes(b) != 0) { + if (!BN_bn2bin(b, bn_buff + (64 - BN_num_bytes(b)))) { printf ("Error's in bn2bin\n"); /* We have to error, here */ - return 0; } } + return 0; + } + } while (n-- > 0) { array[n] = 0; - for (i=7; i>=0; i--) { - tmp = bn_buff[63-(n*8+i)]; - array[n] |= tmp << (8*i); } } + for (i = 7; i >= 0; i--) { + tmp = bn_buff[63 - (n*8 + i)]; + array[n] |= tmp << (8*i); + } + } return 1; } /* Init a 512-bit BIGNUM from the UINT64*_ (8 * 64) interleaved array */ -static int interleaved_array_to_bn_512(BIGNUM* b, UINT64 *array) +static int +interleaved_array_to_bn_512(BIGNUM* b, UINT64 *array) { unsigned char tmp[64]; - int n=8; + int n = 8; int i; + while (n-- > 0) { - for (i = 7; i>=0; i--) { - tmp[63-(n*8+i)] = (unsigned char)(array[n]>>(8*i)); } } + for (i = 7; i >= 0; i--) { + tmp[63 - (n * 8 + i)] = + (unsigned char)(array[n] >> (8 * i)); + } + } BN_bin2bn(tmp, 64, b); - return 0; + return 0; } - /* The main 512bit precompute call */ -static int mod_exp_pre_compute_data_512(UINT64 *m, struct mod_ctx_512 *data) - { - BIGNUM two_768, two_640, two_128, two_512, tmp, _m, tmp2; - - /* We need a BN_CTX for the modulo functions */ - BN_CTX* ctx; - /* Some tmps */ - UINT64 _t[8]; - int i, j, ret = 0; - - /* Init _m with m */ - BN_init(&_m); - interleaved_array_to_bn_512(&_m, m); - memset(_t, 0, 64); - - /* Inits */ - BN_init(&two_768); - BN_init(&two_640); - BN_init(&two_128); - BN_init(&two_512); - BN_init(&tmp); - BN_init(&tmp2); - - /* Create our context */ - if ((ctx=BN_CTX_new()) == NULL) { goto err; } +static int +mod_exp_pre_compute_data_512(UINT64 *m, struct mod_ctx_512 *data) +{ + BIGNUM two_768, two_640, two_128, two_512, tmp, _m, tmp2; + + /* We need a BN_CTX for the modulo functions */ + BN_CTX* ctx; + /* Some tmps */ + UINT64 _t[8]; + int i, j, ret = 0; + + /* Init _m with m */ + BN_init(&_m); + interleaved_array_to_bn_512(&_m, m); + memset(_t, 0, 64); + + /* Inits */ + BN_init(&two_768); + BN_init(&two_640); + BN_init(&two_128); + BN_init(&two_512); + BN_init(&tmp); + BN_init(&tmp2); + + /* Create our context */ + if ((ctx = BN_CTX_new()) == NULL) { + goto err; + } BN_CTX_start(ctx); - /* - * For production, if you care, these only need to be set once, - * and may be made constants. - */ - BN_lshift(&two_768, BN_value_one(), 768); - BN_lshift(&two_640, BN_value_one(), 640); - BN_lshift(&two_128, BN_value_one(), 128); - BN_lshift(&two_512, BN_value_one(), 512); - - if (0 == (m[7] & 0x8000000000000000)) { - exit(1); - } - if (0 == (m[0] & 0x1)) { /* Odd modulus required for Mont */ - exit(1); - } - - /* Precompute m1 */ - BN_mod(&tmp, &two_768, &_m, ctx); - if (!bn_extract_to_array_512(&tmp, 8, &data->m1[0])) { - goto err; } - - /* Precompute m2 */ - BN_mod(&tmp, &two_640, &_m, ctx); - if (!bn_extract_to_array_512(&tmp, 8, &data->m2[0])) { - goto err; - } - - /* - * Precompute k1, a 128b number = ((-1)* m-1 ) mod 2128; k1 should - * be non-negative. - */ - BN_mod_inverse(&tmp, &_m, &two_128, ctx); - if (!BN_is_zero(&tmp)) { BN_sub(&tmp, &two_128, &tmp); } - if (!bn_extract_to_array_512(&tmp, 2, &data->k1[0])) { - goto err; } - - /* Precompute t */ - for (i=0; i<8; i++) { - BN_zero(&tmp); - if (i & 1) { BN_add(&tmp, &two_512, &tmp); } - if (i & 2) { BN_add(&tmp, &two_512, &tmp); } - if (i & 4) { BN_add(&tmp, &two_640, &tmp); } - - BN_nnmod(&tmp2, &tmp, &_m, ctx); - if (!bn_extract_to_array_512(&tmp2, 8, _t)) { - goto err; } - for (j=0; j<8; j++) data->t[j][i] = _t[j]; } - - /* Precompute m */ - for (i=0; i<8; i++) { - data->m[i] = m[i]; } - - ret = 1; + /* + * For production, if you care, these only need to be set once, + * and may be made constants. + */ + BN_lshift(&two_768, BN_value_one(), 768); + BN_lshift(&two_640, BN_value_one(), 640); + BN_lshift(&two_128, BN_value_one(), 128); + BN_lshift(&two_512, BN_value_one(), 512); + + if (0 == (m[7] & 0x8000000000000000)) { + exit(1); + } + if (0 == (m[0] & 0x1)) { + /* Odd modulus required for Mont */ + exit(1); + } + + /* Precompute m1 */ + BN_mod(&tmp, &two_768, &_m, ctx); + if (!bn_extract_to_array_512(&tmp, 8, &data->m1[0])) { + goto err; + } + + /* Precompute m2 */ + BN_mod(&tmp, &two_640, &_m, ctx); + if (!bn_extract_to_array_512(&tmp, 8, &data->m2[0])) { + goto err; + } + + /* + * Precompute k1, a 128b number = ((-1)* m-1 ) mod 2128; k1 should + * be non-negative. + */ + BN_mod_inverse(&tmp, &_m, &two_128, ctx); + if (!BN_is_zero(&tmp)) { + BN_sub(&tmp, &two_128, &tmp); + } + if (!bn_extract_to_array_512(&tmp, 2, &data->k1[0])) { + goto err; + } + + /* Precompute t */ + for (i = 0; i < 8; i++) { + BN_zero(&tmp); + if (i & 1) { + BN_add(&tmp, &two_512, &tmp); + } + if (i & 2) { + BN_add(&tmp, &two_512, &tmp); + } + if (i & 4) { + BN_add(&tmp, &two_640, &tmp); + } + + BN_nnmod(&tmp2, &tmp, &_m, ctx); + if (!bn_extract_to_array_512(&tmp2, 8, _t)) { + goto err; + } + for (j = 0; j < 8; j++) + data->t[j][i] = _t[j]; + } + + /* Precompute m */ + for (i = 0; i < 8; i++) { + data->m[i] = m[i]; + } + + ret = 1; err: - /* Cleanup */ + /* Cleanup */ if (ctx != NULL) { - BN_CTX_end(ctx); BN_CTX_free(ctx); } - BN_free(&two_768); - BN_free(&two_640); - BN_free(&two_128); - BN_free(&two_512); - BN_free(&tmp); - BN_free(&tmp2); - BN_free(&_m); - - return ret; -} + BN_CTX_end(ctx); + BN_CTX_free(ctx); + } + BN_free(&two_768); + BN_free(&two_640); + BN_free(&two_128); + BN_free(&two_512); + BN_free(&tmp); + BN_free(&tmp2); + BN_free(&_m); + return ret; +} -static int e_rsax_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx) - { - BIGNUM *r1,*m1,*vrfy; - BIGNUM local_dmp1,local_dmq1,local_c,local_r1; - BIGNUM *dmp1,*dmq1,*c,*pr1; - int ret=0; +static int +e_rsax_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx) +{ + BIGNUM *r1, *m1, *vrfy; + BIGNUM local_dmp1, local_dmq1, local_c, local_r1; + BIGNUM *dmp1, *dmq1, *c, *pr1; + int ret = 0; BN_CTX_start(ctx); r1 = BN_CTX_get(ctx); @@ -494,8 +533,7 @@ static int e_rsax_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx * intialization uses the BN_FLG_CONSTTIME flag * (unless RSA_FLAG_NO_CONSTTIME is set) */ - if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) - { + if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) { BN_init(&local_p); p = &local_p; BN_with_flags(p, rsa->p, BN_FLG_CONSTTIME); @@ -503,100 +541,97 @@ static int e_rsax_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx BN_init(&local_q); q = &local_q; BN_with_flags(q, rsa->q, BN_FLG_CONSTTIME); - } - else - { + } else { p = rsa->p; q = rsa->q; - } + } - if (rsa->flags & RSA_FLAG_CACHE_PRIVATE) - { - if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_p, CRYPTO_LOCK_RSA, p, ctx)) + if (rsa->flags & RSA_FLAG_CACHE_PRIVATE) { + if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_p, + CRYPTO_LOCK_RSA, p, ctx)) error = 1; - if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_q, CRYPTO_LOCK_RSA, q, ctx)) + if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_q, + CRYPTO_LOCK_RSA, q, ctx)) error = 1; - } + } /* clean up */ - if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) - { + if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) { BN_free(&local_p); BN_free(&local_q); - } - if ( error ) + } + if (error ) goto err; } if (rsa->flags & RSA_FLAG_CACHE_PUBLIC) - if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx)) + if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, + CRYPTO_LOCK_RSA, rsa->n, ctx)) goto err; /* compute I mod q */ - if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) - { + if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) { c = &local_c; BN_with_flags(c, I, BN_FLG_CONSTTIME); - if (!BN_mod(r1,c,rsa->q,ctx)) goto err; - } - else - { - if (!BN_mod(r1,I,rsa->q,ctx)) goto err; - } + if (!BN_mod(r1, c,rsa->q, ctx)) + goto err; + } else { + if (!BN_mod(r1, I,rsa->q, ctx)) + goto err; + } /* compute r1^dmq1 mod q */ - if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) - { + if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) { dmq1 = &local_dmq1; BN_with_flags(dmq1, rsa->dmq1, BN_FLG_CONSTTIME); - } - else + } else dmq1 = rsa->dmq1; - if (!e_rsax_bn_mod_exp(m1,r1,dmq1,rsa->q,ctx, - rsa->_method_mod_q, e_rsax_get_ctx(rsa, 0, rsa->q) )) goto err; + if (!e_rsax_bn_mod_exp(m1, r1, dmq1, rsa->q, ctx, rsa->_method_mod_q, + e_rsax_get_ctx(rsa, 0, rsa->q))) + goto err; /* compute I mod p */ - if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) - { + if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) { c = &local_c; BN_with_flags(c, I, BN_FLG_CONSTTIME); - if (!BN_mod(r1,c,rsa->p,ctx)) goto err; - } - else - { - if (!BN_mod(r1,I,rsa->p,ctx)) goto err; - } + if (!BN_mod(r1, c,rsa->p, ctx)) + goto err; + } else { + if (!BN_mod(r1, I,rsa->p, ctx)) + goto err; + } /* compute r1^dmp1 mod p */ - if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) - { + if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) { dmp1 = &local_dmp1; BN_with_flags(dmp1, rsa->dmp1, BN_FLG_CONSTTIME); - } - else + } else dmp1 = rsa->dmp1; - if (!e_rsax_bn_mod_exp(r0,r1,dmp1,rsa->p,ctx, - rsa->_method_mod_p, e_rsax_get_ctx(rsa, 1, rsa->p) )) goto err; + if (!e_rsax_bn_mod_exp(r0, r1, dmp1, rsa->p, ctx, rsa->_method_mod_p, + e_rsax_get_ctx(rsa, 1, rsa->p))) + goto err; - if (!BN_sub(r0,r0,m1)) goto err; + if (!BN_sub(r0, r0, m1)) + goto err; /* This will help stop the size of r0 increasing, which does * affect the multiply if it optimised for a power of 2 size */ if (BN_is_negative(r0)) - if (!BN_add(r0,r0,rsa->p)) goto err; + if (!BN_add(r0, r0, rsa->p)) + goto err; - if (!BN_mul(r1,r0,rsa->iqmp,ctx)) goto err; + if (!BN_mul(r1, r0, rsa->iqmp, ctx)) + goto err; /* Turn BN_FLG_CONSTTIME flag on before division operation */ - if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) - { + if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) { pr1 = &local_r1; BN_with_flags(pr1, r1, BN_FLG_CONSTTIME); - } - else + } else pr1 = r1; - if (!BN_mod(r0,pr1,rsa->p,ctx)) goto err; + if (!BN_mod(r0, pr1, rsa->p, ctx)) + goto err; /* If p < q it is occasionally possible for the correction of * adding 'p' if r0 is negative above to leave the result still @@ -606,25 +641,30 @@ static int e_rsax_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx * they ensure p > q [steve] */ if (BN_is_negative(r0)) - if (!BN_add(r0,r0,rsa->p)) goto err; - if (!BN_mul(r1,r0,rsa->q,ctx)) goto err; - if (!BN_add(r0,r1,m1)) goto err; - - if (rsa->e && rsa->n) - { - if (!e_rsax_bn_mod_exp(vrfy,r0,rsa->e,rsa->n,ctx,rsa->_method_mod_n, e_rsax_get_ctx(rsa, 2, rsa->n) )) - goto err; + if (!BN_add(r0, r0, rsa->p)) + goto err; + if (!BN_mul(r1, r0, rsa->q, ctx)) + goto err; + if (!BN_add(r0, r1, m1)) + goto err; + + if (rsa->e && rsa->n) { + if (!e_rsax_bn_mod_exp(vrfy, r0, rsa->e, rsa->n, ctx, + rsa->_method_mod_n, e_rsax_get_ctx(rsa, 2, rsa->n))) + goto err; /* If 'I' was greater than (or equal to) rsa->n, the operation * will be equivalent to using 'I mod n'. However, the result of * the verify will *always* be less than 'n' so we don't check * for absolute equality, just congruency. */ - if (!BN_sub(vrfy, vrfy, I)) goto err; - if (!BN_mod(vrfy, vrfy, rsa->n, ctx)) goto err; + if (!BN_sub(vrfy, vrfy, I)) + goto err; + if (!BN_mod(vrfy, vrfy, rsa->n, ctx)) + goto err; if (BN_is_negative(vrfy)) - if (!BN_add(vrfy, vrfy, rsa->n)) goto err; - if (!BN_is_zero(vrfy)) - { + if (!BN_add(vrfy, vrfy, rsa->n)) + goto err; + if (!BN_is_zero(vrfy)) { /* 'I' and 'vrfy' aren't congruent mod n. Don't leak * miscalculated CRT output, just do a raw (slower) * mod_exp and return that instead. */ @@ -632,23 +672,22 @@ static int e_rsax_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx BIGNUM local_d; BIGNUM *d = NULL; - if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) - { + if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME)) { d = &local_d; BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME); - } - else + } else d = rsa->d; - if (!e_rsax_bn_mod_exp(r0,I,d,rsa->n,ctx, - rsa->_method_mod_n, e_rsax_get_ctx(rsa, 2, rsa->n) )) goto err; - } + if (!e_rsax_bn_mod_exp(r0, I,d, rsa->n, ctx, + rsa->_method_mod_n, e_rsax_get_ctx(rsa, 2, rsa->n))) + goto err; } - ret=1; + } + ret = 1; err: BN_CTX_end(ctx); return ret; - } +} #endif /* !OPENSSL_NO_RSA */ #endif /* !COMPILE_RSAX */ diff --git a/lib/libcrypto/engine/eng_table.c b/lib/libcrypto/engine/eng_table.c index 5781af1eb93..44f3e892b80 100644 --- a/lib/libcrypto/engine/eng_table.c +++ b/lib/libcrypto/engine/eng_table.c @@ -1,4 +1,4 @@ -/* $OpenBSD: eng_table.c,v 1.5 2014/06/12 15:49:29 deraadt Exp $ */ +/* $OpenBSD: eng_table.c,v 1.6 2014/06/22 12:05:09 jsing Exp $ */ /* ==================================================================== * Copyright (c) 2001 The OpenSSL Project. All rights reserved. * @@ -7,7 +7,7 @@ * are met: * * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in @@ -59,8 +59,7 @@ #include "eng_int.h" /* The type of the items in the table */ -typedef struct st_engine_pile - { +typedef struct st_engine_pile { /* The 'nid' of this algorithm/mode */ int nid; /* ENGINEs that implement this algorithm/mode. */ @@ -69,284 +68,287 @@ typedef struct st_engine_pile ENGINE *funct; /* Zero if 'sk' is newer than the cached 'funct', non-zero otherwise */ int uptodate; - } ENGINE_PILE; +} ENGINE_PILE; DECLARE_LHASH_OF(ENGINE_PILE); /* The type exposed in eng_int.h */ -struct st_engine_table - { +struct st_engine_table { LHASH_OF(ENGINE_PILE) piles; - }; /* ENGINE_TABLE */ +}; /* ENGINE_TABLE */ - -typedef struct st_engine_pile_doall - { +typedef struct st_engine_pile_doall { engine_table_doall_cb *cb; void *arg; - } ENGINE_PILE_DOALL; - +} ENGINE_PILE_DOALL; /* Global flags (ENGINE_TABLE_FLAG_***). */ static unsigned int table_flags = 0; /* API function manipulating 'table_flags' */ -unsigned int ENGINE_get_table_flags(void) - { +unsigned int +ENGINE_get_table_flags(void) +{ return table_flags; - } +} -void ENGINE_set_table_flags(unsigned int flags) - { +void +ENGINE_set_table_flags(unsigned int flags) +{ table_flags = flags; - } +} /* Internal functions for the "piles" hash table */ -static unsigned long engine_pile_hash(const ENGINE_PILE *c) - { +static unsigned long +engine_pile_hash(const ENGINE_PILE *c) +{ return c->nid; - } +} -static int engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b) - { +static int +engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b) +{ return a->nid - b->nid; - } +} static IMPLEMENT_LHASH_HASH_FN(engine_pile, ENGINE_PILE) static IMPLEMENT_LHASH_COMP_FN(engine_pile, ENGINE_PILE) -static int int_table_check(ENGINE_TABLE **t, int create) - { +static int +int_table_check(ENGINE_TABLE **t, int create) +{ LHASH_OF(ENGINE_PILE) *lh; - if(*t) return 1; - if(!create) return 0; - if((lh = lh_ENGINE_PILE_new()) == NULL) + if (*t) + return 1; + if (!create) + return 0; + if ((lh = lh_ENGINE_PILE_new()) == NULL) return 0; *t = (ENGINE_TABLE *)lh; return 1; - } +} /* Privately exposed (via eng_int.h) functions for adding and/or removing * ENGINEs from the implementation table */ -int engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup, - ENGINE *e, const int *nids, int num_nids, int setdefault) - { +int +engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup, + ENGINE *e, const int *nids, int num_nids, int setdefault) +{ int ret = 0, added = 0; ENGINE_PILE tmplate, *fnd; + CRYPTO_w_lock(CRYPTO_LOCK_ENGINE); - if(!(*table)) + if (!(*table)) added = 1; - if(!int_table_check(table, 1)) + if (!int_table_check(table, 1)) goto end; - if(added) + if (added) /* The cleanup callback needs to be added */ engine_cleanup_add_first(cleanup); - while(num_nids--) - { + while (num_nids--) { tmplate.nid = *nids; fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate); - if(!fnd) - { + if (!fnd) { fnd = malloc(sizeof(ENGINE_PILE)); - if(!fnd) goto end; + if (!fnd) + goto end; fnd->uptodate = 1; fnd->nid = *nids; fnd->sk = sk_ENGINE_new_null(); - if(!fnd->sk) - { + if (!fnd->sk) { free(fnd); goto end; - } + } fnd->funct = NULL; (void)lh_ENGINE_PILE_insert(&(*table)->piles, fnd); - } + } /* A registration shouldn't add duplciate entries */ (void)sk_ENGINE_delete_ptr(fnd->sk, e); /* if 'setdefault', this ENGINE goes to the head of the list */ - if(!sk_ENGINE_push(fnd->sk, e)) + if (!sk_ENGINE_push(fnd->sk, e)) goto end; /* "touch" this ENGINE_PILE */ fnd->uptodate = 0; - if(setdefault) - { - if(!engine_unlocked_init(e)) - { + if (setdefault) { + if (!engine_unlocked_init(e)) { ENGINEerr(ENGINE_F_ENGINE_TABLE_REGISTER, - ENGINE_R_INIT_FAILED); + ENGINE_R_INIT_FAILED); goto end; - } - if(fnd->funct) + } + if (fnd->funct) engine_unlocked_finish(fnd->funct, 0); fnd->funct = e; fnd->uptodate = 1; - } - nids++; } + nids++; + } ret = 1; end: CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); return ret; - } -static void int_unregister_cb_doall_arg(ENGINE_PILE *pile, ENGINE *e) - { +} + +static void +int_unregister_cb_doall_arg(ENGINE_PILE *pile, ENGINE *e) +{ int n; + /* Iterate the 'c->sk' stack removing any occurance of 'e' */ - while((n = sk_ENGINE_find(pile->sk, e)) >= 0) - { + while ((n = sk_ENGINE_find(pile->sk, e)) >= 0) { (void)sk_ENGINE_delete(pile->sk, n); pile->uptodate = 0; - } - if(pile->funct == e) - { + } + if (pile->funct == e) { engine_unlocked_finish(e, 0); pile->funct = NULL; - } } +} static IMPLEMENT_LHASH_DOALL_ARG_FN(int_unregister_cb, ENGINE_PILE, ENGINE) -void engine_table_unregister(ENGINE_TABLE **table, ENGINE *e) - { +void +engine_table_unregister(ENGINE_TABLE **table, ENGINE *e) +{ CRYPTO_w_lock(CRYPTO_LOCK_ENGINE); - if(int_table_check(table, 0)) + if (int_table_check(table, 0)) lh_ENGINE_PILE_doall_arg(&(*table)->piles, - LHASH_DOALL_ARG_FN(int_unregister_cb), - ENGINE, e); + LHASH_DOALL_ARG_FN(int_unregister_cb), ENGINE, e); CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); - } +} -static void int_cleanup_cb_doall(ENGINE_PILE *p) - { +static void +int_cleanup_cb_doall(ENGINE_PILE *p) +{ sk_ENGINE_free(p->sk); - if(p->funct) + if (p->funct) engine_unlocked_finish(p->funct, 0); free(p); - } +} static IMPLEMENT_LHASH_DOALL_FN(int_cleanup_cb, ENGINE_PILE) -void engine_table_cleanup(ENGINE_TABLE **table) - { +void +engine_table_cleanup(ENGINE_TABLE **table) +{ CRYPTO_w_lock(CRYPTO_LOCK_ENGINE); - if(*table) - { + if (*table) { lh_ENGINE_PILE_doall(&(*table)->piles, - LHASH_DOALL_FN(int_cleanup_cb)); + LHASH_DOALL_FN(int_cleanup_cb)); lh_ENGINE_PILE_free(&(*table)->piles); *table = NULL; - } - CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); } + CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); +} /* return a functional reference for a given 'nid' */ #ifndef ENGINE_TABLE_DEBUG -ENGINE *engine_table_select(ENGINE_TABLE **table, int nid) +ENGINE * +engine_table_select(ENGINE_TABLE **table, int nid) #else -ENGINE *engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f, int l) +ENGINE * +engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f, int l) #endif - { +{ ENGINE *ret = NULL; - ENGINE_PILE tmplate, *fnd=NULL; + ENGINE_PILE tmplate, *fnd = NULL; int initres, loop = 0; - if(!(*table)) - { + if (!(*table)) { #ifdef ENGINE_TABLE_DEBUG fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, nothing " - "registered!\n", f, l, nid); + "registered!\n", f, l, nid); #endif return NULL; - } + } ERR_set_mark(); CRYPTO_w_lock(CRYPTO_LOCK_ENGINE); /* Check again inside the lock otherwise we could race against cleanup * operations. But don't worry about a fprintf(stderr). */ - if(!int_table_check(table, 0)) goto end; + if (!int_table_check(table, 0)) + goto end; tmplate.nid = nid; fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate); - if(!fnd) goto end; - if(fnd->funct && engine_unlocked_init(fnd->funct)) - { + if (!fnd) + goto end; + if (fnd->funct && engine_unlocked_init(fnd->funct)) { #ifdef ENGINE_TABLE_DEBUG fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, using " - "ENGINE '%s' cached\n", f, l, nid, fnd->funct->id); + "ENGINE '%s' cached\n", f, l, nid, fnd->funct->id); #endif ret = fnd->funct; goto end; - } - if(fnd->uptodate) - { + } + if (fnd->uptodate) { ret = fnd->funct; goto end; - } + } trynext: ret = sk_ENGINE_value(fnd->sk, loop++); - if(!ret) - { + if (!ret) { #ifdef ENGINE_TABLE_DEBUG fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, no " - "registered implementations would initialise\n", - f, l, nid); + "registered implementations would initialise\n", f, l, nid); #endif goto end; - } + } /* Try to initialise the ENGINE? */ - if((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT)) + if ((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT)) initres = engine_unlocked_init(ret); else initres = 0; - if(initres) - { + if (initres) { /* Update 'funct' */ - if((fnd->funct != ret) && engine_unlocked_init(ret)) - { + if ((fnd->funct != ret) && engine_unlocked_init(ret)) { /* If there was a previous default we release it. */ - if(fnd->funct) + if (fnd->funct) engine_unlocked_finish(fnd->funct, 0); fnd->funct = ret; #ifdef ENGINE_TABLE_DEBUG fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, " - "setting default to '%s'\n", f, l, nid, ret->id); + "setting default to '%s'\n", f, l, nid, ret->id); #endif - } + } #ifdef ENGINE_TABLE_DEBUG fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, using " - "newly initialised '%s'\n", f, l, nid, ret->id); + "newly initialised '%s'\n", f, l, nid, ret->id); #endif goto end; - } + } goto trynext; end: /* If it failed, it is unlikely to succeed again until some future * registrations have taken place. In all cases, we cache. */ - if(fnd) fnd->uptodate = 1; + if (fnd) + fnd->uptodate = 1; #ifdef ENGINE_TABLE_DEBUG - if(ret) + if (ret) fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, caching " - "ENGINE '%s'\n", f, l, nid, ret->id); + "ENGINE '%s'\n", f, l, nid, ret->id); else fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, caching " - "'no matching ENGINE'\n", f, l, nid); + "'no matching ENGINE'\n", f, l, nid); #endif CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE); /* Whatever happened, any failed init()s are not failures in this * context, so clear our error state. */ ERR_pop_to_mark(); return ret; - } +} /* Table enumeration */ -static void int_cb_doall_arg(ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall) - { +static void +int_cb_doall_arg(ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall) +{ dall->cb(pile->nid, pile->sk, pile->funct, dall->arg); - } -static IMPLEMENT_LHASH_DOALL_ARG_FN(int_cb, ENGINE_PILE,ENGINE_PILE_DOALL) +} +static IMPLEMENT_LHASH_DOALL_ARG_FN(int_cb, ENGINE_PILE, ENGINE_PILE_DOALL) -void engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb, - void *arg) - { +void +engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb, void *arg) +{ ENGINE_PILE_DOALL dall; + dall.cb = cb; dall.arg = arg; lh_ENGINE_PILE_doall_arg(&table->piles, LHASH_DOALL_ARG_FN(int_cb), - ENGINE_PILE_DOALL, &dall); - } + ENGINE_PILE_DOALL, &dall); +} |