/* * Copyright 2015-2022 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* We need to use some engine deprecated APIs */ #define OPENSSL_SUPPRESS_DEPRECATED /* * SHA-1 low level APIs are deprecated for public use, but still ok for * internal use. Note, that due to symbols not being exported, only the * #defines and strucures can be accessed, in this case SHA_CBLOCK and * sizeof(SHA_CTX). */ #include "internal/deprecated.h" #include #if defined(_WIN32) # include #endif #include #include #include #include #include #include #include #include #include #include #include #include #if defined(OPENSSL_SYS_UNIX) && defined(OPENSSL_THREADS) # undef ASYNC_POSIX # define ASYNC_POSIX # include #elif defined(_WIN32) # undef ASYNC_WIN # define ASYNC_WIN #endif #include "e_dasync_err.c" /* Engine Id and Name */ static const char *engine_dasync_id = "dasync"; static const char *engine_dasync_name = "Dummy Async engine support"; /* Engine Lifetime functions */ static int dasync_destroy(ENGINE *e); static int dasync_init(ENGINE *e); static int dasync_finish(ENGINE *e); void engine_load_dasync_int(void); /* Set up digests. Just SHA1 for now */ static int dasync_digests(ENGINE *e, const EVP_MD **digest, const int **nids, int nid); static void dummy_pause_job(void); /* SHA1 */ static int dasync_sha1_init(EVP_MD_CTX *ctx); static int dasync_sha1_update(EVP_MD_CTX *ctx, const void *data, size_t count); static int dasync_sha1_final(EVP_MD_CTX *ctx, unsigned char *md); /* * Holds the EVP_MD object for sha1 in this engine. Set up once only during * engine bind and can then be reused many times. */ static EVP_MD *_hidden_sha1_md = NULL; static const EVP_MD *dasync_sha1(void) { return _hidden_sha1_md; } static void destroy_digests(void) { EVP_MD_meth_free(_hidden_sha1_md); _hidden_sha1_md = NULL; } static int dasync_digest_nids(const int **nids) { static int digest_nids[2] = { 0, 0 }; static int pos = 0; static int init = 0; if (!init) { const EVP_MD *md; if ((md = dasync_sha1()) != NULL) digest_nids[pos++] = EVP_MD_get_type(md); digest_nids[pos] = 0; init = 1; } *nids = digest_nids; return pos; } /* RSA */ static int dasync_pkey(ENGINE *e, EVP_PKEY_METHOD **pmeth, const int **pnids, int nid); static int dasync_rsa_init(EVP_PKEY_CTX *ctx); static void dasync_rsa_cleanup(EVP_PKEY_CTX *ctx); static int dasync_rsa_paramgen_init(EVP_PKEY_CTX *ctx); static int dasync_rsa_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey); static int dasync_rsa_keygen_init(EVP_PKEY_CTX *ctx); static int dasync_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey); static int dasync_rsa_encrypt_init(EVP_PKEY_CTX *ctx); static int dasync_rsa_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen); static int dasync_rsa_decrypt_init(EVP_PKEY_CTX *ctx); static int dasync_rsa_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen); static int dasync_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2); static int dasync_rsa_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value); static EVP_PKEY_METHOD *dasync_rsa; static const EVP_PKEY_METHOD *dasync_rsa_orig; /* AES */ static int dasync_aes128_cbc_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); static int dasync_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc); static int dasync_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl); static int dasync_aes128_cbc_cleanup(EVP_CIPHER_CTX *ctx); static int dasync_aes128_cbc_hmac_sha1_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); static int dasync_aes128_cbc_hmac_sha1_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc); static int dasync_aes128_cbc_hmac_sha1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl); static int dasync_aes128_cbc_hmac_sha1_cleanup(EVP_CIPHER_CTX *ctx); struct dasync_pipeline_ctx { void *inner_cipher_data; unsigned int numpipes; unsigned char **inbufs; unsigned char **outbufs; size_t *lens; unsigned char tlsaad[SSL_MAX_PIPELINES][EVP_AEAD_TLS1_AAD_LEN]; unsigned int aadctr; }; /* * Holds the EVP_CIPHER object for aes_128_cbc in this engine. Set up once only * during engine bind and can then be reused many times. */ static EVP_CIPHER *_hidden_aes_128_cbc = NULL; static const EVP_CIPHER *dasync_aes_128_cbc(void) { return _hidden_aes_128_cbc; } /* * Holds the EVP_CIPHER object for aes_128_cbc_hmac_sha1 in this engine. Set up * once only during engine bind and can then be reused many times. * * This 'stitched' cipher depends on the EVP_aes_128_cbc_hmac_sha1() cipher, * which is implemented only if the AES-NI instruction set extension is available * (see OPENSSL_IA32CAP(3)). If that's not the case, then this cipher will not * be available either. * * Note: Since it is a legacy mac-then-encrypt cipher, modern TLS peers (which * negotiate the encrypt-then-mac extension) won't negotiate it anyway. */ static EVP_CIPHER *_hidden_aes_128_cbc_hmac_sha1 = NULL; static const EVP_CIPHER *dasync_aes_128_cbc_hmac_sha1(void) { return _hidden_aes_128_cbc_hmac_sha1; } static void destroy_ciphers(void) { EVP_CIPHER_meth_free(_hidden_aes_128_cbc); EVP_CIPHER_meth_free(_hidden_aes_128_cbc_hmac_sha1); _hidden_aes_128_cbc = NULL; _hidden_aes_128_cbc_hmac_sha1 = NULL; } static int dasync_ciphers(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid); static int dasync_cipher_nids[] = { NID_aes_128_cbc, NID_aes_128_cbc_hmac_sha1, 0 }; static int bind_dasync(ENGINE *e) { /* Setup RSA */ if ((dasync_rsa_orig = EVP_PKEY_meth_find(EVP_PKEY_RSA)) == NULL || (dasync_rsa = EVP_PKEY_meth_new(EVP_PKEY_RSA, EVP_PKEY_FLAG_AUTOARGLEN)) == NULL) return 0; EVP_PKEY_meth_set_init(dasync_rsa, dasync_rsa_init); EVP_PKEY_meth_set_cleanup(dasync_rsa, dasync_rsa_cleanup); EVP_PKEY_meth_set_paramgen(dasync_rsa, dasync_rsa_paramgen_init, dasync_rsa_paramgen); EVP_PKEY_meth_set_keygen(dasync_rsa, dasync_rsa_keygen_init, dasync_rsa_keygen); EVP_PKEY_meth_set_encrypt(dasync_rsa, dasync_rsa_encrypt_init, dasync_rsa_encrypt); EVP_PKEY_meth_set_decrypt(dasync_rsa, dasync_rsa_decrypt_init, dasync_rsa_decrypt); EVP_PKEY_meth_set_ctrl(dasync_rsa, dasync_rsa_ctrl, dasync_rsa_ctrl_str); /* Ensure the dasync error handling is set up */ ERR_load_DASYNC_strings(); if (!ENGINE_set_id(e, engine_dasync_id) || !ENGINE_set_name(e, engine_dasync_name) || !ENGINE_set_pkey_meths(e, dasync_pkey) || !ENGINE_set_digests(e, dasync_digests) || !ENGINE_set_ciphers(e, dasync_ciphers) || !ENGINE_set_destroy_function(e, dasync_destroy) || !ENGINE_set_init_function(e, dasync_init) || !ENGINE_set_finish_function(e, dasync_finish)) { DASYNCerr(DASYNC_F_BIND_DASYNC, DASYNC_R_INIT_FAILED); return 0; } /* * Set up the EVP_CIPHER and EVP_MD objects for the ciphers/digests * supplied by this engine */ _hidden_sha1_md = EVP_MD_meth_new(NID_sha1, NID_sha1WithRSAEncryption); if (_hidden_sha1_md == NULL || !EVP_MD_meth_set_result_size(_hidden_sha1_md, SHA_DIGEST_LENGTH) || !EVP_MD_meth_set_input_blocksize(_hidden_sha1_md, SHA_CBLOCK) || !EVP_MD_meth_set_app_datasize(_hidden_sha1_md, sizeof(EVP_MD *) + sizeof(SHA_CTX)) || !EVP_MD_meth_set_flags(_hidden_sha1_md, EVP_MD_FLAG_DIGALGID_ABSENT) || !EVP_MD_meth_set_init(_hidden_sha1_md, dasync_sha1_init) || !EVP_MD_meth_set_update(_hidden_sha1_md, dasync_sha1_update) || !EVP_MD_meth_set_final(_hidden_sha1_md, dasync_sha1_final)) { EVP_MD_meth_free(_hidden_sha1_md); _hidden_sha1_md = NULL; } _hidden_aes_128_cbc = EVP_CIPHER_meth_new(NID_aes_128_cbc, 16 /* block size */, 16 /* key len */); if (_hidden_aes_128_cbc == NULL || !EVP_CIPHER_meth_set_iv_length(_hidden_aes_128_cbc,16) || !EVP_CIPHER_meth_set_flags(_hidden_aes_128_cbc, EVP_CIPH_FLAG_DEFAULT_ASN1 | EVP_CIPH_CBC_MODE | EVP_CIPH_FLAG_PIPELINE | EVP_CIPH_CUSTOM_COPY) || !EVP_CIPHER_meth_set_init(_hidden_aes_128_cbc, dasync_aes128_init_key) || !EVP_CIPHER_meth_set_do_cipher(_hidden_aes_128_cbc, dasync_aes128_cbc_cipher) || !EVP_CIPHER_meth_set_cleanup(_hidden_aes_128_cbc, dasync_aes128_cbc_cleanup) || !EVP_CIPHER_meth_set_ctrl(_hidden_aes_128_cbc, dasync_aes128_cbc_ctrl) || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_aes_128_cbc, sizeof(struct dasync_pipeline_ctx))) { EVP_CIPHER_meth_free(_hidden_aes_128_cbc); _hidden_aes_128_cbc = NULL; } _hidden_aes_128_cbc_hmac_sha1 = EVP_CIPHER_meth_new( NID_aes_128_cbc_hmac_sha1, 16 /* block size */, 16 /* key len */); if (_hidden_aes_128_cbc_hmac_sha1 == NULL || !EVP_CIPHER_meth_set_iv_length(_hidden_aes_128_cbc_hmac_sha1,16) || !EVP_CIPHER_meth_set_flags(_hidden_aes_128_cbc_hmac_sha1, EVP_CIPH_CBC_MODE | EVP_CIPH_FLAG_DEFAULT_ASN1 | EVP_CIPH_FLAG_AEAD_CIPHER | EVP_CIPH_FLAG_PIPELINE | EVP_CIPH_CUSTOM_COPY) || !EVP_CIPHER_meth_set_init(_hidden_aes_128_cbc_hmac_sha1, dasync_aes128_cbc_hmac_sha1_init_key) || !EVP_CIPHER_meth_set_do_cipher(_hidden_aes_128_cbc_hmac_sha1, dasync_aes128_cbc_hmac_sha1_cipher) || !EVP_CIPHER_meth_set_cleanup(_hidden_aes_128_cbc_hmac_sha1, dasync_aes128_cbc_hmac_sha1_cleanup) || !EVP_CIPHER_meth_set_ctrl(_hidden_aes_128_cbc_hmac_sha1, dasync_aes128_cbc_hmac_sha1_ctrl) || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_aes_128_cbc_hmac_sha1, sizeof(struct dasync_pipeline_ctx))) { EVP_CIPHER_meth_free(_hidden_aes_128_cbc_hmac_sha1); _hidden_aes_128_cbc_hmac_sha1 = NULL; } return 1; } static void destroy_pkey(void) { /* * We don't actually need to free the dasync_rsa method since this is * automatically freed for us by libcrypto. */ dasync_rsa_orig = NULL; dasync_rsa = NULL; } # ifndef OPENSSL_NO_DYNAMIC_ENGINE static int bind_helper(ENGINE *e, const char *id) { if (id && (strcmp(id, engine_dasync_id) != 0)) return 0; if (!bind_dasync(e)) return 0; return 1; } IMPLEMENT_DYNAMIC_CHECK_FN() IMPLEMENT_DYNAMIC_BIND_FN(bind_helper) # endif static ENGINE *engine_dasync(void) { ENGINE *ret = ENGINE_new(); if (!ret) return NULL; if (!bind_dasync(ret)) { ENGINE_free(ret); return NULL; } return ret; } void engine_load_dasync_int(void) { ENGINE *toadd = engine_dasync(); if (!toadd) return; ERR_set_mark(); ENGINE_add(toadd); /* * If the "add" worked, it gets a structural reference. So either way, we * release our just-created reference. */ ENGINE_free(toadd); /* * If the "add" didn't work, it was probably a conflict because it was * already added (eg. someone calling ENGINE_load_blah then calling * ENGINE_load_builtin_engines() perhaps). */ ERR_pop_to_mark(); } static int dasync_init(ENGINE *e) { return 1; } static int dasync_finish(ENGINE *e) { return 1; } static int dasync_destroy(ENGINE *e) { destroy_digests(); destroy_ciphers(); destroy_pkey(); ERR_unload_DASYNC_strings(); return 1; } static int dasync_pkey(ENGINE *e, EVP_PKEY_METHOD **pmeth, const int **pnids, int nid) { static const int rnid = EVP_PKEY_RSA; if (pmeth == NULL) { *pnids = &rnid; return 1; } if (nid == EVP_PKEY_RSA) { *pmeth = dasync_rsa; return 1; } *pmeth = NULL; return 0; } static int dasync_digests(ENGINE *e, const EVP_MD **digest, const int **nids, int nid) { int ok = 1; if (!digest) { /* We are returning a list of supported nids */ return dasync_digest_nids(nids); } /* We are being asked for a specific digest */ switch (nid) { case NID_sha1: *digest = dasync_sha1(); break; default: ok = 0; *digest = NULL; break; } return ok; } static int dasync_ciphers(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid) { int ok = 1; if (cipher == NULL) { /* We are returning a list of supported nids */ *nids = dasync_cipher_nids; return (sizeof(dasync_cipher_nids) - 1) / sizeof(dasync_cipher_nids[0]); } /* We are being asked for a specific cipher */ switch (nid) { case NID_aes_128_cbc: *cipher = dasync_aes_128_cbc(); break; case NID_aes_128_cbc_hmac_sha1: *cipher = dasync_aes_128_cbc_hmac_sha1(); break; default: ok = 0; *cipher = NULL; break; } return ok; } static void wait_cleanup(ASYNC_WAIT_CTX *ctx, const void *key, OSSL_ASYNC_FD readfd, void *pvwritefd) { OSSL_ASYNC_FD *pwritefd = (OSSL_ASYNC_FD *)pvwritefd; #if defined(ASYNC_WIN) CloseHandle(readfd); CloseHandle(*pwritefd); #elif defined(ASYNC_POSIX) close(readfd); close(*pwritefd); #endif OPENSSL_free(pwritefd); } #define DUMMY_CHAR 'X' static void dummy_pause_job(void) { ASYNC_JOB *job; ASYNC_WAIT_CTX *waitctx; ASYNC_callback_fn callback; void * callback_arg; OSSL_ASYNC_FD pipefds[2] = {0, 0}; OSSL_ASYNC_FD *writefd; #if defined(ASYNC_WIN) DWORD numwritten, numread; char buf = DUMMY_CHAR; #elif defined(ASYNC_POSIX) char buf = DUMMY_CHAR; #endif if ((job = ASYNC_get_current_job()) == NULL) return; waitctx = ASYNC_get_wait_ctx(job); if (ASYNC_WAIT_CTX_get_callback(waitctx, &callback, &callback_arg) && callback != NULL) { /* * In the Dummy async engine we are cheating. We call the callback that the job * is complete before the call to ASYNC_pause_job(). A real * async engine would only call the callback when the job was actually complete */ (*callback)(callback_arg); ASYNC_pause_job(); return; } if (ASYNC_WAIT_CTX_get_fd(waitctx, engine_dasync_id, &pipefds[0], (void **)&writefd)) { pipefds[1] = *writefd; } else { writefd = OPENSSL_malloc(sizeof(*writefd)); if (writefd == NULL) return; #if defined(ASYNC_WIN) if (CreatePipe(&pipefds[0], &pipefds[1], NULL, 256) == 0) { OPENSSL_free(writefd); return; } #elif defined(ASYNC_POSIX) if (pipe(pipefds) != 0) { OPENSSL_free(writefd); return; } #endif *writefd = pipefds[1]; if (!ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_dasync_id, pipefds[0], writefd, wait_cleanup)) { wait_cleanup(waitctx, engine_dasync_id, pipefds[0], writefd); return; } } /* * In the Dummy async engine we are cheating. We signal that the job * is complete by waking it before the call to ASYNC_pause_job(). A real * async engine would only wake when the job was actually complete */ #if defined(ASYNC_WIN) WriteFile(pipefds[1], &buf, 1, &numwritten, NULL); #elif defined(ASYNC_POSIX) if (write(pipefds[1], &buf, 1) < 0) return; #endif /* Ignore errors - we carry on anyway */ ASYNC_pause_job(); /* Clear the wake signal */ #if defined(ASYNC_WIN) ReadFile(pipefds[0], &buf, 1, &numread, NULL); #elif defined(ASYNC_POSIX) if (read(pipefds[0], &buf, 1) < 0) return; #endif } /* * SHA1 implementation. At the moment we just defer to the standard * implementation */ static int dasync_sha1_init(EVP_MD_CTX *ctx) { dummy_pause_job(); return EVP_MD_meth_get_init(EVP_sha1())(ctx); } static int dasync_sha1_update(EVP_MD_CTX *ctx, const void *data, size_t count) { dummy_pause_job(); return EVP_MD_meth_get_update(EVP_sha1())(ctx, data, count); } static int dasync_sha1_final(EVP_MD_CTX *ctx, unsigned char *md) { dummy_pause_job(); return EVP_MD_meth_get_final(EVP_sha1())(ctx, md); } /* Cipher helper functions */ static int dasync_cipher_ctrl_helper(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr, int aeadcapable, const EVP_CIPHER *ciph) { int ret; struct dasync_pipeline_ctx *pipe_ctx = (struct dasync_pipeline_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); if (pipe_ctx == NULL) return 0; switch (type) { case EVP_CTRL_COPY: { size_t sz = EVP_CIPHER_impl_ctx_size(ciph); void *inner_cipher_data = OPENSSL_malloc(sz); if (inner_cipher_data == NULL) return -1; memcpy(inner_cipher_data, pipe_ctx->inner_cipher_data, sz); pipe_ctx->inner_cipher_data = inner_cipher_data; } break; case EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS: pipe_ctx->numpipes = arg; pipe_ctx->outbufs = (unsigned char **)ptr; break; case EVP_CTRL_SET_PIPELINE_INPUT_BUFS: pipe_ctx->numpipes = arg; pipe_ctx->inbufs = (unsigned char **)ptr; break; case EVP_CTRL_SET_PIPELINE_INPUT_LENS: pipe_ctx->numpipes = arg; pipe_ctx->lens = (size_t *)ptr; break; case EVP_CTRL_AEAD_SET_MAC_KEY: if (!aeadcapable) return -1; EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx->inner_cipher_data); ret = EVP_CIPHER_meth_get_ctrl(EVP_aes_128_cbc_hmac_sha1()) (ctx, type, arg, ptr); EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx); return ret; case EVP_CTRL_AEAD_TLS1_AAD: { unsigned char *p = ptr; unsigned int len; if (!aeadcapable || arg != EVP_AEAD_TLS1_AAD_LEN) return -1; if (pipe_ctx->aadctr >= SSL_MAX_PIPELINES) return -1; memcpy(pipe_ctx->tlsaad[pipe_ctx->aadctr], ptr, EVP_AEAD_TLS1_AAD_LEN); pipe_ctx->aadctr++; len = p[arg - 2] << 8 | p[arg - 1]; if (EVP_CIPHER_CTX_is_encrypting(ctx)) { if ((p[arg - 4] << 8 | p[arg - 3]) >= TLS1_1_VERSION) { if (len < AES_BLOCK_SIZE) return 0; len -= AES_BLOCK_SIZE; } return ((len + SHA_DIGEST_LENGTH + AES_BLOCK_SIZE) & -AES_BLOCK_SIZE) - len; } else { return SHA_DIGEST_LENGTH; } } default: return 0; } return 1; } static int dasync_cipher_init_key_helper(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc, const EVP_CIPHER *cipher) { int ret; struct dasync_pipeline_ctx *pipe_ctx = (struct dasync_pipeline_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); if (pipe_ctx->inner_cipher_data == NULL && EVP_CIPHER_impl_ctx_size(cipher) != 0) { pipe_ctx->inner_cipher_data = OPENSSL_zalloc( EVP_CIPHER_impl_ctx_size(cipher)); if (pipe_ctx->inner_cipher_data == NULL) { DASYNCerr(DASYNC_F_DASYNC_CIPHER_INIT_KEY_HELPER, ERR_R_MALLOC_FAILURE); return 0; } } pipe_ctx->numpipes = 0; pipe_ctx->aadctr = 0; EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx->inner_cipher_data); ret = EVP_CIPHER_meth_get_init(cipher)(ctx, key, iv, enc); EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx); return ret; } static int dasync_cipher_helper(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl, const EVP_CIPHER *cipher) { int ret = 1; unsigned int i, pipes; struct dasync_pipeline_ctx *pipe_ctx = (struct dasync_pipeline_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); pipes = pipe_ctx->numpipes; EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx->inner_cipher_data); if (pipes == 0) { if (pipe_ctx->aadctr != 0) { if (pipe_ctx->aadctr != 1) return -1; EVP_CIPHER_meth_get_ctrl(cipher) (ctx, EVP_CTRL_AEAD_TLS1_AAD, EVP_AEAD_TLS1_AAD_LEN, pipe_ctx->tlsaad[0]); } ret = EVP_CIPHER_meth_get_do_cipher(cipher) (ctx, out, in, inl); } else { if (pipe_ctx->aadctr > 0 && pipe_ctx->aadctr != pipes) return -1; for (i = 0; i < pipes; i++) { if (pipe_ctx->aadctr > 0) { EVP_CIPHER_meth_get_ctrl(cipher) (ctx, EVP_CTRL_AEAD_TLS1_AAD, EVP_AEAD_TLS1_AAD_LEN, pipe_ctx->tlsaad[i]); } ret = ret && EVP_CIPHER_meth_get_do_cipher(cipher) (ctx, pipe_ctx->outbufs[i], pipe_ctx->inbufs[i], pipe_ctx->lens[i]); } pipe_ctx->numpipes = 0; } pipe_ctx->aadctr = 0; EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx); return ret; } static int dasync_cipher_cleanup_helper(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher) { struct dasync_pipeline_ctx *pipe_ctx = (struct dasync_pipeline_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); OPENSSL_clear_free(pipe_ctx->inner_cipher_data, EVP_CIPHER_impl_ctx_size(cipher)); return 1; } /* * AES128 CBC Implementation */ static int dasync_aes128_cbc_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) { return dasync_cipher_ctrl_helper(ctx, type, arg, ptr, 0, EVP_aes_128_cbc()); } static int dasync_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) { return dasync_cipher_init_key_helper(ctx, key, iv, enc, EVP_aes_128_cbc()); } static int dasync_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) { return dasync_cipher_helper(ctx, out, in, inl, EVP_aes_128_cbc()); } static int dasync_aes128_cbc_cleanup(EVP_CIPHER_CTX *ctx) { return dasync_cipher_cleanup_helper(ctx, EVP_aes_128_cbc()); } /* * AES128 CBC HMAC SHA1 Implementation */ static int dasync_aes128_cbc_hmac_sha1_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) { return dasync_cipher_ctrl_helper(ctx, type, arg, ptr, 1, EVP_aes_128_cbc_hmac_sha1()); } static int dasync_aes128_cbc_hmac_sha1_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) { /* * We can safely assume that EVP_aes_128_cbc_hmac_sha1() != NULL, * see comment before the definition of dasync_aes_128_cbc_hmac_sha1(). */ return dasync_cipher_init_key_helper(ctx, key, iv, enc, EVP_aes_128_cbc_hmac_sha1()); } static int dasync_aes128_cbc_hmac_sha1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) { return dasync_cipher_helper(ctx, out, in, inl, EVP_aes_128_cbc_hmac_sha1()); } static int dasync_aes128_cbc_hmac_sha1_cleanup(EVP_CIPHER_CTX *ctx) { /* * We can safely assume that EVP_aes_128_cbc_hmac_sha1() != NULL, * see comment before the definition of dasync_aes_128_cbc_hmac_sha1(). */ return dasync_cipher_cleanup_helper(ctx, EVP_aes_128_cbc_hmac_sha1()); } /* * RSA implementation */ static int dasync_rsa_init(EVP_PKEY_CTX *ctx) { static int (*pinit)(EVP_PKEY_CTX *ctx); if (pinit == NULL) EVP_PKEY_meth_get_init(dasync_rsa_orig, &pinit); return pinit(ctx); } static void dasync_rsa_cleanup(EVP_PKEY_CTX *ctx) { static void (*pcleanup)(EVP_PKEY_CTX *ctx); if (pcleanup == NULL) EVP_PKEY_meth_get_cleanup(dasync_rsa_orig, &pcleanup); pcleanup(ctx); } static int dasync_rsa_paramgen_init(EVP_PKEY_CTX *ctx) { static int (*pparamgen_init)(EVP_PKEY_CTX *ctx); if (pparamgen_init == NULL) EVP_PKEY_meth_get_paramgen(dasync_rsa_orig, &pparamgen_init, NULL); return pparamgen_init != NULL ? pparamgen_init(ctx) : 1; } static int dasync_rsa_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) { static int (*pparamgen)(EVP_PKEY_CTX *c, EVP_PKEY *pkey); if (pparamgen == NULL) EVP_PKEY_meth_get_paramgen(dasync_rsa_orig, NULL, &pparamgen); return pparamgen != NULL ? pparamgen(ctx, pkey) : 1; } static int dasync_rsa_keygen_init(EVP_PKEY_CTX *ctx) { static int (*pkeygen_init)(EVP_PKEY_CTX *ctx); if (pkeygen_init == NULL) EVP_PKEY_meth_get_keygen(dasync_rsa_orig, &pkeygen_init, NULL); return pkeygen_init != NULL ? pkeygen_init(ctx) : 1; } static int dasync_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) { static int (*pkeygen)(EVP_PKEY_CTX *c, EVP_PKEY *pkey); if (pkeygen == NULL) EVP_PKEY_meth_get_keygen(dasync_rsa_orig, NULL, &pkeygen); return pkeygen(ctx, pkey); } static int dasync_rsa_encrypt_init(EVP_PKEY_CTX *ctx) { static int (*pencrypt_init)(EVP_PKEY_CTX *ctx); if (pencrypt_init == NULL) EVP_PKEY_meth_get_encrypt(dasync_rsa_orig, &pencrypt_init, NULL); return pencrypt_init != NULL ? pencrypt_init(ctx) : 1; } static int dasync_rsa_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen) { static int (*pencryptfn)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen); if (pencryptfn == NULL) EVP_PKEY_meth_get_encrypt(dasync_rsa_orig, NULL, &pencryptfn); return pencryptfn(ctx, out, outlen, in, inlen); } static int dasync_rsa_decrypt_init(EVP_PKEY_CTX *ctx) { static int (*pdecrypt_init)(EVP_PKEY_CTX *ctx); if (pdecrypt_init == NULL) EVP_PKEY_meth_get_decrypt(dasync_rsa_orig, &pdecrypt_init, NULL); return pdecrypt_init != NULL ? pdecrypt_init(ctx) : 1; } static int dasync_rsa_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen) { static int (*pdecrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen); if (pdecrypt == NULL) EVP_PKEY_meth_get_encrypt(dasync_rsa_orig, NULL, &pdecrypt); return pdecrypt(ctx, out, outlen, in, inlen); } static int dasync_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) { static int (*pctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2); if (pctrl == NULL) EVP_PKEY_meth_get_ctrl(dasync_rsa_orig, &pctrl, NULL); return pctrl(ctx, type, p1, p2); } static int dasync_rsa_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value) { static int (*pctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value); if (pctrl_str == NULL) EVP_PKEY_meth_get_ctrl(dasync_rsa_orig, NULL, &pctrl_str); return pctrl_str(ctx, type, value); }