/* ssl.c * * Copyright (C) 2006-2020 wolfSSL Inc. * * This file is part of wolfSSL. * * wolfSSL is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * wolfSSL is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA */ #ifdef HAVE_CONFIG_H #include #endif #include #if defined(OPENSSL_EXTRA) && !defined(_WIN32) /* turn on GNU extensions for XVASPRINTF with wolfSSL_BIO_printf */ #undef _GNU_SOURCE #define _GNU_SOURCE #endif #if !defined(WOLFCRYPT_ONLY) || defined(OPENSSL_EXTRA) || \ defined(OPENSSL_EXTRA_X509_SMALL) #ifdef HAVE_ERRNO_H #include #endif #include #include #include #ifdef NO_INLINE #include #else #define WOLFSSL_MISC_INCLUDED #include #endif #if !defined(WOLFSSL_ALLOW_NO_SUITES) && !defined(WOLFCRYPT_ONLY) #if defined(NO_DH) && !defined(HAVE_ECC) && !defined(WOLFSSL_STATIC_RSA) \ && !defined(WOLFSSL_STATIC_DH) && !defined(WOLFSSL_STATIC_PSK) \ && !defined(HAVE_ED25519) && !defined(HAVE_ED448) #error "No cipher suites defined because DH disabled, ECC disabled, and no static suites defined. Please see top of README" #endif #ifdef WOLFSSL_CERT_GEN /* need access to Cert struct for creating certificate */ #include #endif #endif #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) || \ defined(HAVE_WEBSERVER) || defined(WOLFSSL_KEY_GEN) #include /* openssl headers end, wolfssl internal headers next */ #endif #include #ifndef NO_RSA #include #endif #ifdef OPENSSL_EXTRA /* openssl headers begin */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* openssl headers end, wolfssl internal headers next */ #include #include #include #include #include #include #include #include #include #include #if defined(OPENSSL_ALL) || defined(HAVE_STUNNEL) #include #endif /* WITH_STUNNEL */ #if defined(WOLFSSL_SHA512) || defined(WOLFSSL_SHA384) #include #endif #if defined(WOLFCRYPT_HAVE_SRP) && !defined(NO_SHA256) \ && !defined(WC_NO_RNG) #include #endif #if defined(HAVE_FIPS) || defined(HAVE_SELFTEST) #include #endif #if defined(OPENSSL_ALL) && defined(HAVE_PKCS7) #include #endif /* OPENSSL_ALL && HAVE_PKCS7 */ #endif #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) int SetIndividualInternal(WOLFSSL_BIGNUM* bn, mp_int* mpi); int SetIndividualExternal(WOLFSSL_BIGNUM** bn, mp_int* mpi); int oid2nid(word32 oid, int grp); #endif #if defined(WOLFSSL_QT) #include #endif #ifdef NO_ASN #include #endif #endif /* !WOLFCRYPT_ONLY || OPENSSL_EXTRA */ #define WOLFSSL_EVP_INCLUDED #include "wolfcrypt/src/evp.c" #ifdef OPENSSL_EXTRA /* Global pointer to constant BN on */ static WOLFSSL_BIGNUM* bn_one = NULL; #endif #ifndef WOLFCRYPT_ONLY #if defined(OPENSSL_EXTRA) && defined(HAVE_ECC) const WOLF_EC_NIST_NAME kNistCurves[] = { {XSTR_SIZEOF("P-192"), "P-192", NID_X9_62_prime192v1}, {XSTR_SIZEOF("P-256"), "P-256", NID_X9_62_prime256v1}, {XSTR_SIZEOF("P-112"), "P-112", NID_secp112r1}, {XSTR_SIZEOF("P-112-2"), "P-112-2", NID_secp112r2}, {XSTR_SIZEOF("P-128"), "P-128", NID_secp128r1}, {XSTR_SIZEOF("P-128-2"), "P-128-2", NID_secp128r2}, {XSTR_SIZEOF("P-160"), "P-160", NID_secp160r1}, {XSTR_SIZEOF("P-160-2"), "P-160-2", NID_secp160r2}, {XSTR_SIZEOF("P-224"), "P-224", NID_secp224r1}, {XSTR_SIZEOF("P-384"), "P-384", NID_secp384r1}, {XSTR_SIZEOF("P-521"), "P-521", NID_secp521r1}, {XSTR_SIZEOF("K-160"), "K-160", NID_secp160k1}, {XSTR_SIZEOF("K-192"), "K-192", NID_secp192k1}, {XSTR_SIZEOF("K-224"), "K-224", NID_secp224k1}, {XSTR_SIZEOF("K-256"), "K-256", NID_secp256k1}, {XSTR_SIZEOF("B-160"), "B-160", NID_brainpoolP160r1}, {XSTR_SIZEOF("B-192"), "B-192", NID_brainpoolP192r1}, {XSTR_SIZEOF("B-224"), "B-224", NID_brainpoolP224r1}, {XSTR_SIZEOF("B-256"), "B-256", NID_brainpoolP256r1}, {XSTR_SIZEOF("B-320"), "B-320", NID_brainpoolP320r1}, {XSTR_SIZEOF("B-384"), "B-384", NID_brainpoolP384r1}, {XSTR_SIZEOF("B-512"), "B-512", NID_brainpoolP512r1}, {0, NULL, 0}, }; #endif #if defined(WOLFSSL_RENESAS_TSIP_TLS) /* for root ca verification */ int tsip_tls_RootCertVerify(const byte *cert, word32 cert_len, word32 key_n_start, word32 key_n_len, word32 key_e_start, word32 key_e_len, word32 cm_row); byte tsip_rootCAverified( ); #endif #ifdef WOLFSSL_SESSION_EXPORT #ifdef WOLFSSL_DTLS int wolfSSL_dtls_import(WOLFSSL* ssl, unsigned char* buf, unsigned int sz) { WOLFSSL_ENTER("wolfSSL_session_import"); if (ssl == NULL || buf == NULL) { return BAD_FUNC_ARG; } /* sanity checks on buffer and protocol are done in internal function */ return wolfSSL_dtls_import_internal(ssl, buf, sz); } /* Sets the function to call for serializing the session. This function is * called right after the handshake is completed. */ int wolfSSL_CTX_dtls_set_export(WOLFSSL_CTX* ctx, wc_dtls_export func) { WOLFSSL_ENTER("wolfSSL_CTX_dtls_set_export"); /* purposefully allow func to be NULL */ if (ctx == NULL) { return BAD_FUNC_ARG; } ctx->dtls_export = func; return WOLFSSL_SUCCESS; } /* Sets the function in WOLFSSL struct to call for serializing the session. This * function is called right after the handshake is completed. */ int wolfSSL_dtls_set_export(WOLFSSL* ssl, wc_dtls_export func) { WOLFSSL_ENTER("wolfSSL_dtls_set_export"); /* purposefully allow func to be NULL */ if (ssl == NULL) { return BAD_FUNC_ARG; } ssl->dtls_export = func; return WOLFSSL_SUCCESS; } /* This function allows for directly serializing a session rather than using * callbacks. It has less overhead by removing a temporary buffer and gives * control over when the session gets serialized. When using callbacks the * session is always serialized immediately after the handshake is finished. * * buf is the argument to contain the serialized session * sz is the size of the buffer passed in * ssl is the WOLFSSL struct to serialize * returns the size of serialized session on success, 0 on no action, and * negative value on error */ int wolfSSL_dtls_export(WOLFSSL* ssl, unsigned char* buf, unsigned int* sz) { WOLFSSL_ENTER("wolfSSL_dtls_export"); if (ssl == NULL || sz == NULL) { return BAD_FUNC_ARG; } if (buf == NULL) { *sz = MAX_EXPORT_BUFFER; return 0; } /* if not DTLS do nothing */ if (!ssl->options.dtls) { WOLFSSL_MSG("Currently only DTLS export is supported"); return 0; } /* copy over keys, options, and dtls state struct */ return wolfSSL_dtls_export_internal(ssl, buf, *sz); } /* This function is similar to wolfSSL_dtls_export but only exports the portion * of the WOLFSSL structure related to the state of the connection, i.e. peer * sequence number, epoch, AEAD state etc. * * buf is the argument to contain the serialized state, if null then set "sz" to * buffer size required * sz is the size of the buffer passed in * ssl is the WOLFSSL struct to serialize * returns the size of serialized session on success, 0 on no action, and * negative value on error */ int wolfSSL_dtls_export_state_only(WOLFSSL* ssl, unsigned char* buf, unsigned int* sz) { WOLFSSL_ENTER("wolfSSL_dtls_export_state_only"); if (ssl == NULL || sz == NULL) { return BAD_FUNC_ARG; } if (buf == NULL) { *sz = MAX_EXPORT_STATE_BUFFER; return 0; } /* if not DTLS do nothing */ if (!ssl->options.dtls) { WOLFSSL_MSG("Currently only DTLS export state is supported"); return 0; } /* copy over keys, options, and dtls state struct */ return wolfSSL_dtls_export_state_internal(ssl, buf, *sz); } /* returns 0 on success */ int wolfSSL_send_session(WOLFSSL* ssl) { int ret; byte* buf; word16 bufSz = MAX_EXPORT_BUFFER; WOLFSSL_ENTER("wolfSSL_send_session"); if (ssl == NULL) { return BAD_FUNC_ARG; } buf = (byte*)XMALLOC(bufSz, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER); if (buf == NULL) { return MEMORY_E; } /* if not DTLS do nothing */ if (!ssl->options.dtls) { XFREE(buf, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER); WOLFSSL_MSG("Currently only DTLS export is supported"); return 0; } /* copy over keys, options, and dtls state struct */ ret = wolfSSL_dtls_export_internal(ssl, buf, bufSz); if (ret < 0) { XFREE(buf, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER); return ret; } /* if no error ret has size of buffer */ ret = ssl->dtls_export(ssl, buf, ret, NULL); if (ret != WOLFSSL_SUCCESS) { XFREE(buf, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER); return ret; } XFREE(buf, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER); return 0; } #endif /* WOLFSSL_DTLS */ #endif /* WOLFSSL_SESSION_EXPORT */ /* prevent multiple mutex initializations */ static volatile WOLFSSL_GLOBAL int initRefCount = 0; static WOLFSSL_GLOBAL wolfSSL_Mutex count_mutex; /* init ref count mutex */ /* Create a new WOLFSSL_CTX struct and return the pointer to created struct. WOLFSSL_METHOD pointer passed in is given to ctx to manage. This function frees the passed in WOLFSSL_METHOD struct on failure and on success is freed when ctx is freed. */ WOLFSSL_CTX* wolfSSL_CTX_new_ex(WOLFSSL_METHOD* method, void* heap) { WOLFSSL_CTX* ctx = NULL; WOLFSSL_ENTER("wolfSSL_CTX_new_ex"); if (initRefCount == 0) { /* user no longer forced to call Init themselves */ int ret = wolfSSL_Init(); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("wolfSSL_Init failed"); WOLFSSL_LEAVE("WOLFSSL_CTX_new", 0); if (method != NULL) { XFREE(method, heap, DYNAMIC_TYPE_METHOD); } return NULL; } } if (method == NULL) return ctx; ctx = (WOLFSSL_CTX*) XMALLOC(sizeof(WOLFSSL_CTX), heap, DYNAMIC_TYPE_CTX); if (ctx) { int ret; ret = InitSSL_Ctx(ctx, method, heap); #ifdef WOLFSSL_STATIC_MEMORY if (heap != NULL) { ctx->onHeap = 1; /* free the memory back to heap when done */ } #endif if (ret < 0) { WOLFSSL_MSG("Init CTX failed"); wolfSSL_CTX_free(ctx); ctx = NULL; } #if defined(OPENSSL_EXTRA) && defined(WOLFCRYPT_HAVE_SRP) \ && !defined(NO_SHA256) && !defined(WC_NO_RNG) else { ctx->srp = (Srp*) XMALLOC(sizeof(Srp), heap, DYNAMIC_TYPE_SRP); if (ctx->srp == NULL){ WOLFSSL_MSG("Init CTX failed"); wolfSSL_CTX_free(ctx); return NULL; } XMEMSET(ctx->srp, 0, sizeof(Srp)); } #endif } else { WOLFSSL_MSG("Alloc CTX failed, method freed"); XFREE(method, heap, DYNAMIC_TYPE_METHOD); } WOLFSSL_LEAVE("WOLFSSL_CTX_new", 0); return ctx; } WOLFSSL_ABI WOLFSSL_CTX* wolfSSL_CTX_new(WOLFSSL_METHOD* method) { #ifdef WOLFSSL_HEAP_TEST /* if testing the heap hint then set top level CTX to have test value */ return wolfSSL_CTX_new_ex(method, (void*)WOLFSSL_HEAP_TEST); #else return wolfSSL_CTX_new_ex(method, NULL); #endif } #ifdef OPENSSL_EXTRA /* increases CTX reference count to track proper time to "free" */ int wolfSSL_CTX_up_ref(WOLFSSL_CTX* ctx) { int refCount = SSL_CTX_RefCount(ctx, 1); return ((refCount > 1) ? 1 : 0); } #endif WOLFSSL_ABI void wolfSSL_CTX_free(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("SSL_CTX_free"); if (ctx) { #if defined(OPENSSL_EXTRA) && defined(WOLFCRYPT_HAVE_SRP) \ && !defined(NO_SHA256) && !defined(WC_NO_RNG) if (ctx->srp != NULL){ if (ctx->srp_password != NULL){ XFREE(ctx->srp_password, ctx->heap, DYNAMIC_TYPE_SRP); ctx->srp_password = NULL; } wc_SrpTerm(ctx->srp); XFREE(ctx->srp, ctx->heap, DYNAMIC_TYPE_SRP); ctx->srp = NULL; } #endif FreeSSL_Ctx(ctx); } WOLFSSL_LEAVE("SSL_CTX_free", 0); } #ifdef HAVE_ENCRYPT_THEN_MAC /** * Sets whether Encrypt-Then-MAC extension can be negotiated against context. * The default value: enabled. * * ctx SSL/TLS context. * set Whether to allow or not: 1 is allow and 0 is disallow. * returns WOLFSSL_SUCCESS */ int wolfSSL_CTX_AllowEncryptThenMac(WOLFSSL_CTX *ctx, int set) { ctx->disallowEncThenMac = !set; return WOLFSSL_SUCCESS; } /** * Sets whether Encrypt-Then-MAC extension can be negotiated against context. * The default value comes from context. * * ctx SSL/TLS context. * set Whether to allow or not: 1 is allow and 0 is disallow. * returns WOLFSSL_SUCCESS */ int wolfSSL_AllowEncryptThenMac(WOLFSSL *ssl, int set) { ssl->options.disallowEncThenMac = !set; return WOLFSSL_SUCCESS; } #endif #ifdef SINGLE_THREADED /* no locking in single threaded mode, allow a CTX level rng to be shared with * WOLFSSL objects, WOLFSSL_SUCCESS on ok */ int wolfSSL_CTX_new_rng(WOLFSSL_CTX* ctx) { WC_RNG* rng; int ret; if (ctx == NULL) { return BAD_FUNC_ARG; } rng = (WC_RNG*)XMALLOC(sizeof(WC_RNG), ctx->heap, DYNAMIC_TYPE_RNG); if (rng == NULL) { return MEMORY_E; } #ifndef HAVE_FIPS ret = wc_InitRng_ex(rng, ctx->heap, ctx->devId); #else ret = wc_InitRng(rng); #endif if (ret != 0) { XFREE(rng, ctx->heap, DYNAMIC_TYPE_RNG); return ret; } ctx->rng = rng; return WOLFSSL_SUCCESS; } #endif WOLFSSL_ABI WOLFSSL* wolfSSL_new(WOLFSSL_CTX* ctx) { WOLFSSL* ssl = NULL; int ret = 0; (void)ret; WOLFSSL_ENTER("SSL_new"); if (ctx == NULL) return ssl; ssl = (WOLFSSL*) XMALLOC(sizeof(WOLFSSL), ctx->heap, DYNAMIC_TYPE_SSL); if (ssl) if ( (ret = InitSSL(ssl, ctx, 0)) < 0) { FreeSSL(ssl, ctx->heap); ssl = 0; } WOLFSSL_LEAVE("SSL_new", ret); return ssl; } WOLFSSL_ABI void wolfSSL_free(WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_free"); if (ssl) FreeSSL(ssl, ssl->ctx->heap); WOLFSSL_LEAVE("SSL_free", 0); } int wolfSSL_is_server(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; return ssl->options.side == WOLFSSL_SERVER_END; } #ifdef HAVE_WRITE_DUP /* * Release resources around WriteDup object * * ssl WOLFSSL object * * no return, destruction so make best attempt */ void FreeWriteDup(WOLFSSL* ssl) { int doFree = 0; WOLFSSL_ENTER("FreeWriteDup"); if (ssl->dupWrite) { if (wc_LockMutex(&ssl->dupWrite->dupMutex) == 0) { ssl->dupWrite->dupCount--; if (ssl->dupWrite->dupCount == 0) { doFree = 1; } else { WOLFSSL_MSG("WriteDup count not zero, no full free"); } wc_UnLockMutex(&ssl->dupWrite->dupMutex); } } if (doFree) { WOLFSSL_MSG("Doing WriteDup full free, count to zero"); wc_FreeMutex(&ssl->dupWrite->dupMutex); XFREE(ssl->dupWrite, ssl->heap, DYNAMIC_TYPE_WRITEDUP); } } /* * duplicate existing ssl members into dup needed for writing * * dup write only WOLFSSL * ssl existing WOLFSSL * * 0 on success */ static int DupSSL(WOLFSSL* dup, WOLFSSL* ssl) { /* shared dupWrite setup */ ssl->dupWrite = (WriteDup*)XMALLOC(sizeof(WriteDup), ssl->heap, DYNAMIC_TYPE_WRITEDUP); if (ssl->dupWrite == NULL) { return MEMORY_E; } XMEMSET(ssl->dupWrite, 0, sizeof(WriteDup)); if (wc_InitMutex(&ssl->dupWrite->dupMutex) != 0) { XFREE(ssl->dupWrite, ssl->heap, DYNAMIC_TYPE_WRITEDUP); ssl->dupWrite = NULL; return BAD_MUTEX_E; } ssl->dupWrite->dupCount = 2; /* both sides have a count to start */ dup->dupWrite = ssl->dupWrite; /* each side uses */ /* copy write parts over to dup writer */ XMEMCPY(&dup->specs, &ssl->specs, sizeof(CipherSpecs)); XMEMCPY(&dup->options, &ssl->options, sizeof(Options)); XMEMCPY(&dup->keys, &ssl->keys, sizeof(Keys)); XMEMCPY(&dup->encrypt, &ssl->encrypt, sizeof(Ciphers)); /* dup side now owns encrypt/write ciphers */ XMEMSET(&ssl->encrypt, 0, sizeof(Ciphers)); dup->IOCB_WriteCtx = ssl->IOCB_WriteCtx; dup->wfd = ssl->wfd; dup->wflags = ssl->wflags; dup->hmac = ssl->hmac; #ifdef HAVE_TRUNCATED_HMAC dup->truncated_hmac = ssl->truncated_hmac; #endif /* unique side dup setup */ dup->dupSide = WRITE_DUP_SIDE; ssl->dupSide = READ_DUP_SIDE; return 0; } /* * duplicate a WOLFSSL object post handshake for writing only * turn existing object into read only. Allows concurrent access from two * different threads. * * ssl existing WOLFSSL object * * return dup'd WOLFSSL object on success */ WOLFSSL* wolfSSL_write_dup(WOLFSSL* ssl) { WOLFSSL* dup = NULL; int ret = 0; (void)ret; WOLFSSL_ENTER("wolfSSL_write_dup"); if (ssl == NULL) { return ssl; } if (ssl->options.handShakeDone == 0) { WOLFSSL_MSG("wolfSSL_write_dup called before handshake complete"); return NULL; } if (ssl->dupWrite) { WOLFSSL_MSG("wolfSSL_write_dup already called once"); return NULL; } dup = (WOLFSSL*) XMALLOC(sizeof(WOLFSSL), ssl->ctx->heap, DYNAMIC_TYPE_SSL); if (dup) { if ( (ret = InitSSL(dup, ssl->ctx, 1)) < 0) { FreeSSL(dup, ssl->ctx->heap); dup = NULL; } else if ( (ret = DupSSL(dup, ssl)) < 0) { FreeSSL(dup, ssl->ctx->heap); dup = NULL; } } WOLFSSL_LEAVE("wolfSSL_write_dup", ret); return dup; } /* * Notify write dup side of fatal error or close notify * * ssl WOLFSSL object * err Notify err * * 0 on success */ int NotifyWriteSide(WOLFSSL* ssl, int err) { int ret; WOLFSSL_ENTER("NotifyWriteSide"); ret = wc_LockMutex(&ssl->dupWrite->dupMutex); if (ret == 0) { ssl->dupWrite->dupErr = err; ret = wc_UnLockMutex(&ssl->dupWrite->dupMutex); } return ret; } #endif /* HAVE_WRITE_DUP */ #ifdef HAVE_POLY1305 /* set if to use old poly 1 for yes 0 to use new poly */ int wolfSSL_use_old_poly(WOLFSSL* ssl, int value) { (void)ssl; (void)value; #ifndef WOLFSSL_NO_TLS12 WOLFSSL_ENTER("SSL_use_old_poly"); WOLFSSL_MSG("Warning SSL connection auto detects old/new and this function" "is depreciated"); ssl->options.oldPoly = (word16)value; WOLFSSL_LEAVE("SSL_use_old_poly", 0); #endif return 0; } #endif WOLFSSL_ABI int wolfSSL_set_fd(WOLFSSL* ssl, int fd) { int ret; WOLFSSL_ENTER("SSL_set_fd"); if (ssl == NULL) { return BAD_FUNC_ARG; } ret = wolfSSL_set_read_fd(ssl, fd); if (ret == WOLFSSL_SUCCESS) { ret = wolfSSL_set_write_fd(ssl, fd); } return ret; } int wolfSSL_set_read_fd(WOLFSSL* ssl, int fd) { WOLFSSL_ENTER("SSL_set_read_fd"); if (ssl == NULL) { return BAD_FUNC_ARG; } ssl->rfd = fd; /* not used directly to allow IO callbacks */ ssl->IOCB_ReadCtx = &ssl->rfd; #ifdef WOLFSSL_DTLS if (ssl->options.dtls) { ssl->IOCB_ReadCtx = &ssl->buffers.dtlsCtx; ssl->buffers.dtlsCtx.rfd = fd; } #endif WOLFSSL_LEAVE("SSL_set_read_fd", WOLFSSL_SUCCESS); return WOLFSSL_SUCCESS; } int wolfSSL_set_write_fd(WOLFSSL* ssl, int fd) { WOLFSSL_ENTER("SSL_set_write_fd"); if (ssl == NULL) { return BAD_FUNC_ARG; } ssl->wfd = fd; /* not used directly to allow IO callbacks */ ssl->IOCB_WriteCtx = &ssl->wfd; #ifdef WOLFSSL_DTLS if (ssl->options.dtls) { ssl->IOCB_WriteCtx = &ssl->buffers.dtlsCtx; ssl->buffers.dtlsCtx.wfd = fd; } #endif WOLFSSL_LEAVE("SSL_set_write_fd", WOLFSSL_SUCCESS); return WOLFSSL_SUCCESS; } /** * Get the name of cipher at priority level passed in. */ char* wolfSSL_get_cipher_list(int priority) { const CipherSuiteInfo* ciphers = GetCipherNames(); if (priority >= GetCipherNamesSize() || priority < 0) { return 0; } return (char*)ciphers[priority].name; } /** * Get the name of cipher at priority level passed in. */ char* wolfSSL_get_cipher_list_ex(WOLFSSL* ssl, int priority) { if (ssl == NULL) { return NULL; } else { const char* cipher; if ((cipher = wolfSSL_get_cipher_name_internal(ssl)) != NULL) { if (priority == 0) { return (char*)cipher; } else { return NULL; } } else { return wolfSSL_get_cipher_list(priority); } } } int wolfSSL_get_ciphers(char* buf, int len) { const CipherSuiteInfo* ciphers = GetCipherNames(); int ciphersSz = GetCipherNamesSize(); int i; int cipherNameSz; if (buf == NULL || len <= 0) return BAD_FUNC_ARG; /* Add each member to the buffer delimited by a : */ for (i = 0; i < ciphersSz; i++) { cipherNameSz = (int)XSTRLEN(ciphers[i].name); if (cipherNameSz + 1 < len) { XSTRNCPY(buf, ciphers[i].name, len); buf += cipherNameSz; if (i < ciphersSz - 1) *buf++ = ':'; *buf = 0; len -= cipherNameSz + 1; } else return BUFFER_E; } return WOLFSSL_SUCCESS; } #ifndef NO_ERROR_STRINGS /* places a list of all supported cipher suites in TLS_* format into "buf" * return WOLFSSL_SUCCESS on success */ int wolfSSL_get_ciphers_iana(char* buf, int len) { const CipherSuiteInfo* ciphers = GetCipherNames(); int ciphersSz = GetCipherNamesSize(); int i; int cipherNameSz; if (buf == NULL || len <= 0) return BAD_FUNC_ARG; /* Add each member to the buffer delimited by a : */ for (i = 0; i < ciphersSz; i++) { cipherNameSz = (int)XSTRLEN(ciphers[i].name_iana); if (cipherNameSz + 1 < len) { XSTRNCPY(buf, ciphers[i].name_iana, len); buf += cipherNameSz; if (i < ciphersSz - 1) *buf++ = ':'; *buf = 0; len -= cipherNameSz + 1; } else return BUFFER_E; } return WOLFSSL_SUCCESS; } #endif /* NO_ERROR_STRINGS */ const char* wolfSSL_get_shared_ciphers(WOLFSSL* ssl, char* buf, int len) { const char* cipher; if (ssl == NULL) return NULL; cipher = wolfSSL_get_cipher_name_iana(ssl); len = min(len, (int)(XSTRLEN(cipher) + 1)); XMEMCPY(buf, cipher, len); return buf; } int wolfSSL_get_fd(const WOLFSSL* ssl) { int fd = -1; WOLFSSL_ENTER("SSL_get_fd"); if (ssl) { fd = ssl->rfd; } WOLFSSL_LEAVE("SSL_get_fd", fd); return fd; } int wolfSSL_dtls(WOLFSSL* ssl) { int dtlsOpt = 0; if (ssl) dtlsOpt = ssl->options.dtls; return dtlsOpt; } #if !defined(NO_CERTS) /* Set whether mutual authentication is required for connections. * Server side only. * * ctx The SSL/TLS CTX object. * req 1 to indicate required and 0 when not. * returns BAD_FUNC_ARG when ctx is NULL, SIDE_ERROR when not a server and * 0 on success. */ int wolfSSL_CTX_mutual_auth(WOLFSSL_CTX* ctx, int req) { if (ctx == NULL) return BAD_FUNC_ARG; if (ctx->method->side == WOLFSSL_CLIENT_END) return SIDE_ERROR; ctx->mutualAuth = (byte)req; return 0; } /* Set whether mutual authentication is required for the connection. * Server side only. * * ssl The SSL/TLS object. * req 1 to indicate required and 0 when not. * returns BAD_FUNC_ARG when ssl is NULL, or not using TLS v1.3, * SIDE_ERROR when not a client and 0 on success. */ int wolfSSL_mutual_auth(WOLFSSL* ssl, int req) { if (ssl == NULL) return BAD_FUNC_ARG; if (ssl->options.side == WOLFSSL_SERVER_END) return SIDE_ERROR; ssl->options.mutualAuth = (word16)req; return 0; } #endif /* NO_CERTS */ #ifndef WOLFSSL_LEANPSK int wolfSSL_dtls_set_peer(WOLFSSL* ssl, void* peer, unsigned int peerSz) { #ifdef WOLFSSL_DTLS void* sa; if (ssl == NULL) return WOLFSSL_FAILURE; sa = (void*)XMALLOC(peerSz, ssl->heap, DYNAMIC_TYPE_SOCKADDR); if (sa != NULL) { if (ssl->buffers.dtlsCtx.peer.sa != NULL) { XFREE(ssl->buffers.dtlsCtx.peer.sa,ssl->heap,DYNAMIC_TYPE_SOCKADDR); ssl->buffers.dtlsCtx.peer.sa = NULL; } XMEMCPY(sa, peer, peerSz); ssl->buffers.dtlsCtx.peer.sa = sa; ssl->buffers.dtlsCtx.peer.sz = peerSz; return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; #else (void)ssl; (void)peer; (void)peerSz; return WOLFSSL_NOT_IMPLEMENTED; #endif } int wolfSSL_dtls_get_peer(WOLFSSL* ssl, void* peer, unsigned int* peerSz) { #ifdef WOLFSSL_DTLS if (ssl == NULL) { return WOLFSSL_FAILURE; } if (peer != NULL && peerSz != NULL && *peerSz >= ssl->buffers.dtlsCtx.peer.sz && ssl->buffers.dtlsCtx.peer.sa != NULL) { *peerSz = ssl->buffers.dtlsCtx.peer.sz; XMEMCPY(peer, ssl->buffers.dtlsCtx.peer.sa, *peerSz); return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; #else (void)ssl; (void)peer; (void)peerSz; return WOLFSSL_NOT_IMPLEMENTED; #endif } #if defined(WOLFSSL_SCTP) && defined(WOLFSSL_DTLS) int wolfSSL_CTX_dtls_set_sctp(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_dtls_set_sctp()"); if (ctx == NULL) return BAD_FUNC_ARG; ctx->dtlsSctp = 1; return WOLFSSL_SUCCESS; } int wolfSSL_dtls_set_sctp(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_dtls_set_sctp()"); if (ssl == NULL) return BAD_FUNC_ARG; ssl->options.dtlsSctp = 1; return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_DTLS && WOLFSSL_SCTP */ #if (defined(WOLFSSL_SCTP) || defined(WOLFSSL_DTLS_MTU)) && \ defined(WOLFSSL_DTLS) int wolfSSL_CTX_dtls_set_mtu(WOLFSSL_CTX* ctx, word16 newMtu) { if (ctx == NULL || newMtu > MAX_RECORD_SIZE) return BAD_FUNC_ARG; ctx->dtlsMtuSz = newMtu; return WOLFSSL_SUCCESS; } int wolfSSL_dtls_set_mtu(WOLFSSL* ssl, word16 newMtu) { if (ssl == NULL) return BAD_FUNC_ARG; if (newMtu > MAX_RECORD_SIZE) { ssl->error = BAD_FUNC_ARG; return WOLFSSL_FAILURE; } ssl->dtlsMtuSz = newMtu; return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_DTLS && (WOLFSSL_SCTP || WOLFSSL_DTLS_MTU) */ #ifdef WOLFSSL_DTLS_DROP_STATS int wolfSSL_dtls_get_drop_stats(WOLFSSL* ssl, word32* macDropCount, word32* replayDropCount) { int ret; WOLFSSL_ENTER("wolfSSL_dtls_get_drop_stats()"); if (ssl == NULL) ret = BAD_FUNC_ARG; else { ret = WOLFSSL_SUCCESS; if (macDropCount != NULL) *macDropCount = ssl->macDropCount; if (replayDropCount != NULL) *replayDropCount = ssl->replayDropCount; } WOLFSSL_LEAVE("wolfSSL_dtls_get_drop_stats()", ret); return ret; } #endif /* WOLFSSL_DTLS_DROP_STATS */ #if defined(WOLFSSL_MULTICAST) int wolfSSL_CTX_mcast_set_member_id(WOLFSSL_CTX* ctx, word16 id) { int ret = 0; WOLFSSL_ENTER("wolfSSL_CTX_mcast_set_member_id()"); if (ctx == NULL || id > 255) ret = BAD_FUNC_ARG; if (ret == 0) { ctx->haveEMS = 0; ctx->haveMcast = 1; ctx->mcastID = (byte)id; #ifndef WOLFSSL_USER_IO ctx->CBIORecv = EmbedReceiveFromMcast; #endif /* WOLFSSL_USER_IO */ ret = WOLFSSL_SUCCESS; } WOLFSSL_LEAVE("wolfSSL_CTX_mcast_set_member_id()", ret); return ret; } int wolfSSL_mcast_get_max_peers(void) { return WOLFSSL_MULTICAST_PEERS; } #ifdef WOLFSSL_DTLS static WC_INLINE word32 UpdateHighwaterMark(word32 cur, word32 first, word32 second, word32 max) { word32 newCur = 0; if (cur < first) newCur = first; else if (cur < second) newCur = second; else if (cur < max) newCur = max; return newCur; } #endif /* WOLFSSL_DTLS */ int wolfSSL_set_secret(WOLFSSL* ssl, word16 epoch, const byte* preMasterSecret, word32 preMasterSz, const byte* clientRandom, const byte* serverRandom, const byte* suite) { int ret = 0; WOLFSSL_ENTER("wolfSSL_set_secret()"); if (ssl == NULL || preMasterSecret == NULL || preMasterSz == 0 || preMasterSz > ENCRYPT_LEN || clientRandom == NULL || serverRandom == NULL || suite == NULL) { ret = BAD_FUNC_ARG; } if (ret == 0) { XMEMCPY(ssl->arrays->preMasterSecret, preMasterSecret, preMasterSz); ssl->arrays->preMasterSz = preMasterSz; XMEMCPY(ssl->arrays->clientRandom, clientRandom, RAN_LEN); XMEMCPY(ssl->arrays->serverRandom, serverRandom, RAN_LEN); ssl->options.cipherSuite0 = suite[0]; ssl->options.cipherSuite = suite[1]; ret = SetCipherSpecs(ssl); } if (ret == 0) ret = MakeTlsMasterSecret(ssl); if (ret == 0) { ssl->keys.encryptionOn = 1; ret = SetKeysSide(ssl, ENCRYPT_AND_DECRYPT_SIDE); } if (ret == 0) { if (ssl->options.dtls) { #ifdef WOLFSSL_DTLS WOLFSSL_DTLS_PEERSEQ* peerSeq; int i; ssl->keys.dtls_epoch = epoch; for (i = 0, peerSeq = ssl->keys.peerSeq; i < WOLFSSL_DTLS_PEERSEQ_SZ; i++, peerSeq++) { peerSeq->nextEpoch = epoch; peerSeq->prevSeq_lo = peerSeq->nextSeq_lo; peerSeq->prevSeq_hi = peerSeq->nextSeq_hi; peerSeq->nextSeq_lo = 0; peerSeq->nextSeq_hi = 0; XMEMCPY(peerSeq->prevWindow, peerSeq->window, DTLS_SEQ_SZ); XMEMSET(peerSeq->window, 0, DTLS_SEQ_SZ); peerSeq->highwaterMark = UpdateHighwaterMark(0, ssl->ctx->mcastFirstSeq, ssl->ctx->mcastSecondSeq, ssl->ctx->mcastMaxSeq); } #else (void)epoch; #endif } FreeHandshakeResources(ssl); ret = WOLFSSL_SUCCESS; } else { if (ssl) ssl->error = ret; ret = WOLFSSL_FATAL_ERROR; } WOLFSSL_LEAVE("wolfSSL_set_secret()", ret); return ret; } #ifdef WOLFSSL_DTLS int wolfSSL_mcast_peer_add(WOLFSSL* ssl, word16 peerId, int remove) { WOLFSSL_DTLS_PEERSEQ* p = NULL; int ret = WOLFSSL_SUCCESS; int i; WOLFSSL_ENTER("wolfSSL_mcast_peer_add()"); if (ssl == NULL || peerId > 255) return BAD_FUNC_ARG; if (!remove) { /* Make sure it isn't already present, while keeping the first * open spot. */ for (i = 0; i < WOLFSSL_DTLS_PEERSEQ_SZ; i++) { if (ssl->keys.peerSeq[i].peerId == INVALID_PEER_ID) p = &ssl->keys.peerSeq[i]; if (ssl->keys.peerSeq[i].peerId == peerId) { WOLFSSL_MSG("Peer ID already in multicast peer list."); p = NULL; } } if (p != NULL) { XMEMSET(p, 0, sizeof(WOLFSSL_DTLS_PEERSEQ)); p->peerId = peerId; p->highwaterMark = UpdateHighwaterMark(0, ssl->ctx->mcastFirstSeq, ssl->ctx->mcastSecondSeq, ssl->ctx->mcastMaxSeq); } else { WOLFSSL_MSG("No room in peer list."); ret = -1; } } else { for (i = 0; i < WOLFSSL_DTLS_PEERSEQ_SZ; i++) { if (ssl->keys.peerSeq[i].peerId == peerId) p = &ssl->keys.peerSeq[i]; } if (p != NULL) { p->peerId = INVALID_PEER_ID; } else { WOLFSSL_MSG("Peer not found in list."); } } WOLFSSL_LEAVE("wolfSSL_mcast_peer_add()", ret); return ret; } /* If peerId is in the list of peers and its last sequence number is non-zero, * return 1, otherwise return 0. */ int wolfSSL_mcast_peer_known(WOLFSSL* ssl, unsigned short peerId) { int known = 0; int i; WOLFSSL_ENTER("wolfSSL_mcast_peer_known()"); if (ssl == NULL || peerId > 255) { return BAD_FUNC_ARG; } for (i = 0; i < WOLFSSL_DTLS_PEERSEQ_SZ; i++) { if (ssl->keys.peerSeq[i].peerId == peerId) { if (ssl->keys.peerSeq[i].nextSeq_hi || ssl->keys.peerSeq[i].nextSeq_lo) { known = 1; } break; } } WOLFSSL_LEAVE("wolfSSL_mcast_peer_known()", known); return known; } int wolfSSL_CTX_mcast_set_highwater_cb(WOLFSSL_CTX* ctx, word32 maxSeq, word32 first, word32 second, CallbackMcastHighwater cb) { if (ctx == NULL || (second && first > second) || first > maxSeq || second > maxSeq || cb == NULL) { return BAD_FUNC_ARG; } ctx->mcastHwCb = cb; ctx->mcastFirstSeq = first; ctx->mcastSecondSeq = second; ctx->mcastMaxSeq = maxSeq; return WOLFSSL_SUCCESS; } int wolfSSL_mcast_set_highwater_ctx(WOLFSSL* ssl, void* ctx) { if (ssl == NULL || ctx == NULL) return BAD_FUNC_ARG; ssl->mcastHwCbCtx = ctx; return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_DTLS */ #endif /* WOLFSSL_MULTICAST */ #endif /* WOLFSSL_LEANPSK */ /* return underlying connect or accept, WOLFSSL_SUCCESS on ok */ int wolfSSL_negotiate(WOLFSSL* ssl) { int err = WOLFSSL_FATAL_ERROR; WOLFSSL_ENTER("wolfSSL_negotiate"); #ifndef NO_WOLFSSL_SERVER if (ssl->options.side == WOLFSSL_SERVER_END) { #ifdef WOLFSSL_TLS13 if (IsAtLeastTLSv1_3(ssl->version)) err = wolfSSL_accept_TLSv13(ssl); else #endif err = wolfSSL_accept(ssl); } #endif #ifndef NO_WOLFSSL_CLIENT if (ssl->options.side == WOLFSSL_CLIENT_END) { #ifdef WOLFSSL_TLS13 if (IsAtLeastTLSv1_3(ssl->version)) err = wolfSSL_connect_TLSv13(ssl); else #endif err = wolfSSL_connect(ssl); } #endif (void)ssl; WOLFSSL_LEAVE("wolfSSL_negotiate", err); return err; } WOLFSSL_ABI WC_RNG* wolfSSL_GetRNG(WOLFSSL* ssl) { if (ssl) { return ssl->rng; } return NULL; } #ifndef WOLFSSL_LEANPSK /* object size based on build */ int wolfSSL_GetObjectSize(void) { #ifdef SHOW_SIZES printf("sizeof suites = %lu\n", (unsigned long)sizeof(Suites)); printf("sizeof ciphers(2) = %lu\n", (unsigned long)sizeof(Ciphers)); #ifndef NO_RC4 printf("\tsizeof arc4 = %lu\n", (unsigned long)sizeof(Arc4)); #endif printf("\tsizeof aes = %lu\n", (unsigned long)sizeof(Aes)); #ifndef NO_DES3 printf("\tsizeof des3 = %lu\n", (unsigned long)sizeof(Des3)); #endif #ifndef NO_RABBIT printf("\tsizeof rabbit = %lu\n", (unsigned long)sizeof(Rabbit)); #endif #ifdef HAVE_CHACHA printf("\tsizeof chacha = %lu\n", (unsigned long)sizeof(ChaCha)); #endif printf("sizeof cipher specs = %lu\n", (unsigned long)sizeof(CipherSpecs)); printf("sizeof keys = %lu\n", (unsigned long)sizeof(Keys)); printf("sizeof Hashes(2) = %lu\n", (unsigned long)sizeof(Hashes)); #ifndef NO_MD5 printf("\tsizeof MD5 = %lu\n", (unsigned long)sizeof(wc_Md5)); #endif #ifndef NO_SHA printf("\tsizeof SHA = %lu\n", (unsigned long)sizeof(wc_Sha)); #endif #ifdef WOLFSSL_SHA224 printf("\tsizeof SHA224 = %lu\n", (unsigned long)sizeof(wc_Sha224)); #endif #ifndef NO_SHA256 printf("\tsizeof SHA256 = %lu\n", (unsigned long)sizeof(wc_Sha256)); #endif #ifdef WOLFSSL_SHA384 printf("\tsizeof SHA384 = %lu\n", (unsigned long)sizeof(wc_Sha384)); #endif #ifdef WOLFSSL_SHA384 printf("\tsizeof SHA512 = %lu\n", (unsigned long)sizeof(wc_Sha512)); #endif printf("sizeof Buffers = %lu\n", (unsigned long)sizeof(Buffers)); printf("sizeof Options = %lu\n", (unsigned long)sizeof(Options)); printf("sizeof Arrays = %lu\n", (unsigned long)sizeof(Arrays)); #ifndef NO_RSA printf("sizeof RsaKey = %lu\n", (unsigned long)sizeof(RsaKey)); #endif #ifdef HAVE_ECC printf("sizeof ecc_key = %lu\n", (unsigned long)sizeof(ecc_key)); #endif printf("sizeof WOLFSSL_CIPHER = %lu\n", (unsigned long)sizeof(WOLFSSL_CIPHER)); printf("sizeof WOLFSSL_SESSION = %lu\n", (unsigned long)sizeof(WOLFSSL_SESSION)); printf("sizeof WOLFSSL = %lu\n", (unsigned long)sizeof(WOLFSSL)); printf("sizeof WOLFSSL_CTX = %lu\n", (unsigned long)sizeof(WOLFSSL_CTX)); #endif return sizeof(WOLFSSL); } int wolfSSL_CTX_GetObjectSize(void) { return sizeof(WOLFSSL_CTX); } int wolfSSL_METHOD_GetObjectSize(void) { return sizeof(WOLFSSL_METHOD); } #endif #ifdef WOLFSSL_STATIC_MEMORY int wolfSSL_CTX_load_static_memory(WOLFSSL_CTX** ctx, wolfSSL_method_func method, unsigned char* buf, unsigned int sz, int flag, int max) { WOLFSSL_HEAP* heap; WOLFSSL_HEAP_HINT* hint; word32 idx = 0; if (ctx == NULL || buf == NULL) { return BAD_FUNC_ARG; } if (*ctx == NULL && method == NULL) { return BAD_FUNC_ARG; } if (*ctx == NULL || (*ctx)->heap == NULL) { if (sizeof(WOLFSSL_HEAP) + sizeof(WOLFSSL_HEAP_HINT) > sz - idx) { return BUFFER_E; /* not enough memory for structures */ } heap = (WOLFSSL_HEAP*)buf; idx += sizeof(WOLFSSL_HEAP); if (wolfSSL_init_memory_heap(heap) != 0) { return WOLFSSL_FAILURE; } hint = (WOLFSSL_HEAP_HINT*)(buf + idx); idx += sizeof(WOLFSSL_HEAP_HINT); XMEMSET(hint, 0, sizeof(WOLFSSL_HEAP_HINT)); hint->memory = heap; if (*ctx && (*ctx)->heap == NULL) { (*ctx)->heap = (void*)hint; } } else { #ifdef WOLFSSL_HEAP_TEST /* do not load in memory if test has been set */ if ((*ctx)->heap == (void*)WOLFSSL_HEAP_TEST) { return WOLFSSL_SUCCESS; } #endif hint = (WOLFSSL_HEAP_HINT*)((*ctx)->heap); heap = hint->memory; } if (wolfSSL_load_static_memory(buf + idx, sz - idx, flag, heap) != 1) { WOLFSSL_MSG("Error partitioning memory"); return WOLFSSL_FAILURE; } /* create ctx if needed */ if (*ctx == NULL) { *ctx = wolfSSL_CTX_new_ex(method(hint), hint); if (*ctx == NULL) { WOLFSSL_MSG("Error creating ctx"); return WOLFSSL_FAILURE; } } /* determine what max applies too */ if (flag & WOLFMEM_IO_POOL || flag & WOLFMEM_IO_POOL_FIXED) { heap->maxIO = max; } else { /* general memory used in handshakes */ heap->maxHa = max; } heap->flag |= flag; (void)max; (void)method; return WOLFSSL_SUCCESS; } int wolfSSL_is_static_memory(WOLFSSL* ssl, WOLFSSL_MEM_CONN_STATS* mem_stats) { if (ssl == NULL) { return BAD_FUNC_ARG; } WOLFSSL_ENTER("wolfSSL_is_static_memory"); /* fill out statistics if wanted and WOLFMEM_TRACK_STATS flag */ if (mem_stats != NULL && ssl->heap != NULL) { WOLFSSL_HEAP_HINT* hint = ((WOLFSSL_HEAP_HINT*)(ssl->heap)); WOLFSSL_HEAP* heap = hint->memory; if (heap->flag & WOLFMEM_TRACK_STATS && hint->stats != NULL) { XMEMCPY(mem_stats, hint->stats, sizeof(WOLFSSL_MEM_CONN_STATS)); } } return (ssl->heap) ? 1 : 0; } int wolfSSL_CTX_is_static_memory(WOLFSSL_CTX* ctx, WOLFSSL_MEM_STATS* mem_stats) { if (ctx == NULL) { return BAD_FUNC_ARG; } WOLFSSL_ENTER("wolfSSL_CTX_is_static_memory"); /* fill out statistics if wanted */ if (mem_stats != NULL && ctx->heap != NULL) { WOLFSSL_HEAP* heap = ((WOLFSSL_HEAP_HINT*)(ctx->heap))->memory; if (wolfSSL_GetMemStats(heap, mem_stats) != 1) { return MEMORY_E; } } return (ctx->heap) ? 1 : 0; } #endif /* WOLFSSL_STATIC_MEMORY */ /* return max record layer size plaintext input size */ int wolfSSL_GetMaxOutputSize(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_GetMaxOutputSize"); if (ssl == NULL) return BAD_FUNC_ARG; if (ssl->options.handShakeState != HANDSHAKE_DONE) { WOLFSSL_MSG("Handshake not complete yet"); return BAD_FUNC_ARG; } return wolfSSL_GetMaxRecordSize(ssl, OUTPUT_RECORD_SIZE); } /* return record layer size of plaintext input size */ int wolfSSL_GetOutputSize(WOLFSSL* ssl, int inSz) { int maxSize; WOLFSSL_ENTER("wolfSSL_GetOutputSize"); if (inSz < 0) return BAD_FUNC_ARG; maxSize = wolfSSL_GetMaxOutputSize(ssl); if (maxSize < 0) return maxSize; /* error */ if (inSz > maxSize) return INPUT_SIZE_E; return BuildMessage(ssl, NULL, 0, NULL, inSz, application_data, 0, 1, 0); } #ifdef HAVE_ECC int wolfSSL_CTX_SetMinEccKey_Sz(WOLFSSL_CTX* ctx, short keySz) { if (ctx == NULL || keySz < 0 || keySz % 8 != 0) { WOLFSSL_MSG("Key size must be divisible by 8 or ctx was null"); return BAD_FUNC_ARG; } ctx->minEccKeySz = keySz / 8; #ifndef NO_CERTS ctx->cm->minEccKeySz = keySz / 8; #endif return WOLFSSL_SUCCESS; } int wolfSSL_SetMinEccKey_Sz(WOLFSSL* ssl, short keySz) { if (ssl == NULL || keySz < 0 || keySz % 8 != 0) { WOLFSSL_MSG("Key size must be divisible by 8 or ssl was null"); return BAD_FUNC_ARG; } ssl->options.minEccKeySz = keySz / 8; return WOLFSSL_SUCCESS; } #endif /* !NO_RSA */ #ifndef NO_RSA int wolfSSL_CTX_SetMinRsaKey_Sz(WOLFSSL_CTX* ctx, short keySz) { if (ctx == NULL || keySz < 0 || keySz % 8 != 0) { WOLFSSL_MSG("Key size must be divisible by 8 or ctx was null"); return BAD_FUNC_ARG; } ctx->minRsaKeySz = keySz / 8; ctx->cm->minRsaKeySz = keySz / 8; return WOLFSSL_SUCCESS; } int wolfSSL_SetMinRsaKey_Sz(WOLFSSL* ssl, short keySz) { if (ssl == NULL || keySz < 0 || keySz % 8 != 0) { WOLFSSL_MSG("Key size must be divisible by 8 or ssl was null"); return BAD_FUNC_ARG; } ssl->options.minRsaKeySz = keySz / 8; return WOLFSSL_SUCCESS; } #endif /* !NO_RSA */ #ifndef NO_DH /* server Diffie-Hellman parameters, WOLFSSL_SUCCESS on ok */ int wolfSSL_SetTmpDH(WOLFSSL* ssl, const unsigned char* p, int pSz, const unsigned char* g, int gSz) { WOLFSSL_ENTER("wolfSSL_SetTmpDH"); if (ssl == NULL || p == NULL || g == NULL) return BAD_FUNC_ARG; if ((word16)pSz < ssl->options.minDhKeySz) return DH_KEY_SIZE_E; if ((word16)pSz > ssl->options.maxDhKeySz) return DH_KEY_SIZE_E; /* this function is for server only */ if (ssl->options.side == WOLFSSL_CLIENT_END) return SIDE_ERROR; #if !defined(WOLFSSL_OLD_PRIME_CHECK) && !defined(HAVE_FIPS) && \ !defined(HAVE_SELFTEST) ssl->options.dhKeyTested = 0; ssl->options.dhDoKeyTest = 1; #endif if (ssl->buffers.serverDH_P.buffer && ssl->buffers.weOwnDH) { XFREE(ssl->buffers.serverDH_P.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); ssl->buffers.serverDH_P.buffer = NULL; } if (ssl->buffers.serverDH_G.buffer && ssl->buffers.weOwnDH) { XFREE(ssl->buffers.serverDH_G.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); ssl->buffers.serverDH_G.buffer = NULL; } ssl->buffers.weOwnDH = 1; /* SSL owns now */ ssl->buffers.serverDH_P.buffer = (byte*)XMALLOC(pSz, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); if (ssl->buffers.serverDH_P.buffer == NULL) return MEMORY_E; ssl->buffers.serverDH_G.buffer = (byte*)XMALLOC(gSz, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); if (ssl->buffers.serverDH_G.buffer == NULL) { XFREE(ssl->buffers.serverDH_P.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); ssl->buffers.serverDH_P.buffer = NULL; return MEMORY_E; } ssl->buffers.serverDH_P.length = pSz; ssl->buffers.serverDH_G.length = gSz; XMEMCPY(ssl->buffers.serverDH_P.buffer, p, pSz); XMEMCPY(ssl->buffers.serverDH_G.buffer, g, gSz); ssl->options.haveDH = 1; if (ssl->options.side != WOLFSSL_NEITHER_END) { word16 havePSK; word16 haveRSA; int keySz = 0; #ifndef NO_PSK havePSK = ssl->options.havePSK; #else havePSK = 0; #endif #ifdef NO_RSA haveRSA = 0; #else haveRSA = 1; #endif #ifndef NO_CERTS keySz = ssl->buffers.keySz; #endif InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK, ssl->options.haveDH, ssl->options.haveNTRU, ssl->options.haveECDSAsig, ssl->options.haveECC, ssl->options.haveStaticECC, ssl->options.side); } WOLFSSL_LEAVE("wolfSSL_SetTmpDH", 0); return WOLFSSL_SUCCESS; } #if !defined(WOLFSSL_OLD_PRIME_CHECK) && !defined(HAVE_FIPS) && \ !defined(HAVE_SELFTEST) /* Enables or disables the session's DH key prime test. */ int wolfSSL_SetEnableDhKeyTest(WOLFSSL* ssl, int enable) { WOLFSSL_ENTER("wolfSSL_SetEnableDhKeyTest"); if (ssl == NULL) return BAD_FUNC_ARG; if (!enable) ssl->options.dhDoKeyTest = 0; else ssl->options.dhDoKeyTest = 1; WOLFSSL_LEAVE("wolfSSL_SetEnableDhKeyTest", WOLFSSL_SUCCESS); return WOLFSSL_SUCCESS; } #endif /* server ctx Diffie-Hellman parameters, WOLFSSL_SUCCESS on ok */ int wolfSSL_CTX_SetTmpDH(WOLFSSL_CTX* ctx, const unsigned char* p, int pSz, const unsigned char* g, int gSz) { WOLFSSL_ENTER("wolfSSL_CTX_SetTmpDH"); if (ctx == NULL || p == NULL || g == NULL) return BAD_FUNC_ARG; if ((word16)pSz < ctx->minDhKeySz) return DH_KEY_SIZE_E; if ((word16)pSz > ctx->maxDhKeySz) return DH_KEY_SIZE_E; #if !defined(WOLFSSL_OLD_PRIME_CHECK) && !defined(HAVE_FIPS) && \ !defined(HAVE_SELFTEST) { DhKey checkKey; WC_RNG rng; int error, freeKey = 0; error = wc_InitRng(&rng); if (!error) error = wc_InitDhKey(&checkKey); if (!error) { freeKey = 1; error = wc_DhSetCheckKey(&checkKey, p, pSz, g, gSz, NULL, 0, 0, &rng); } if (freeKey) wc_FreeDhKey(&checkKey); wc_FreeRng(&rng); if (error) return error; ctx->dhKeyTested = 1; } #endif XFREE(ctx->serverDH_P.buffer, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); ctx->serverDH_P.buffer = NULL; XFREE(ctx->serverDH_G.buffer, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); ctx->serverDH_G.buffer = NULL; ctx->serverDH_P.buffer = (byte*)XMALLOC(pSz, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); if (ctx->serverDH_P.buffer == NULL) return MEMORY_E; ctx->serverDH_G.buffer = (byte*)XMALLOC(gSz, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); if (ctx->serverDH_G.buffer == NULL) { XFREE(ctx->serverDH_P.buffer, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); ctx->serverDH_P.buffer = NULL; return MEMORY_E; } ctx->serverDH_P.length = pSz; ctx->serverDH_G.length = gSz; XMEMCPY(ctx->serverDH_P.buffer, p, pSz); XMEMCPY(ctx->serverDH_G.buffer, g, gSz); ctx->haveDH = 1; WOLFSSL_LEAVE("wolfSSL_CTX_SetTmpDH", 0); return WOLFSSL_SUCCESS; } int wolfSSL_CTX_SetMinDhKey_Sz(WOLFSSL_CTX* ctx, word16 keySz) { if (ctx == NULL || keySz > 16000 || keySz % 8 != 0) return BAD_FUNC_ARG; ctx->minDhKeySz = keySz / 8; return WOLFSSL_SUCCESS; } int wolfSSL_SetMinDhKey_Sz(WOLFSSL* ssl, word16 keySz) { if (ssl == NULL || keySz > 16000 || keySz % 8 != 0) return BAD_FUNC_ARG; ssl->options.minDhKeySz = keySz / 8; return WOLFSSL_SUCCESS; } int wolfSSL_CTX_SetMaxDhKey_Sz(WOLFSSL_CTX* ctx, word16 keySz) { if (ctx == NULL || keySz > 16000 || keySz % 8 != 0) return BAD_FUNC_ARG; ctx->maxDhKeySz = keySz / 8; return WOLFSSL_SUCCESS; } int wolfSSL_SetMaxDhKey_Sz(WOLFSSL* ssl, word16 keySz) { if (ssl == NULL || keySz > 16000 || keySz % 8 != 0) return BAD_FUNC_ARG; ssl->options.maxDhKeySz = keySz / 8; return WOLFSSL_SUCCESS; } int wolfSSL_GetDhKey_Sz(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; return (ssl->options.dhKeySz * 8); } #endif /* !NO_DH */ WOLFSSL_ABI int wolfSSL_write(WOLFSSL* ssl, const void* data, int sz) { int ret; WOLFSSL_ENTER("SSL_write()"); if (ssl == NULL || data == NULL || sz < 0) return BAD_FUNC_ARG; #ifdef WOLFSSL_EARLY_DATA if (ssl->earlyData != no_early_data && (ret = wolfSSL_negotiate(ssl)) < 0) { ssl->error = ret; return WOLFSSL_FATAL_ERROR; } ssl->earlyData = no_early_data; #endif #ifdef HAVE_WRITE_DUP { /* local variable scope */ int dupErr = 0; /* local copy */ ret = 0; if (ssl->dupWrite && ssl->dupSide == READ_DUP_SIDE) { WOLFSSL_MSG("Read dup side cannot write"); return WRITE_DUP_WRITE_E; } if (ssl->dupWrite) { if (wc_LockMutex(&ssl->dupWrite->dupMutex) != 0) { return BAD_MUTEX_E; } dupErr = ssl->dupWrite->dupErr; ret = wc_UnLockMutex(&ssl->dupWrite->dupMutex); } if (ret != 0) { ssl->error = ret; /* high priority fatal error */ return WOLFSSL_FATAL_ERROR; } if (dupErr != 0) { WOLFSSL_MSG("Write dup error from other side"); ssl->error = dupErr; return WOLFSSL_FATAL_ERROR; } } #endif #ifdef HAVE_ERRNO_H errno = 0; #endif #ifdef OPENSSL_EXTRA if (ssl->CBIS != NULL) { ssl->CBIS(ssl, SSL_CB_WRITE, SSL_SUCCESS); ssl->cbmode = SSL_CB_WRITE; } #endif ret = SendData(ssl, data, sz); WOLFSSL_LEAVE("SSL_write()", ret); if (ret < 0) return WOLFSSL_FATAL_ERROR; else return ret; } static int wolfSSL_read_internal(WOLFSSL* ssl, void* data, int sz, int peek) { int ret; WOLFSSL_ENTER("wolfSSL_read_internal()"); if (ssl == NULL || data == NULL || sz < 0) return BAD_FUNC_ARG; #ifdef HAVE_WRITE_DUP if (ssl->dupWrite && ssl->dupSide == WRITE_DUP_SIDE) { WOLFSSL_MSG("Write dup side cannot read"); return WRITE_DUP_READ_E; } #endif #ifdef HAVE_ERRNO_H errno = 0; #endif #ifdef WOLFSSL_DTLS if (ssl->options.dtls) { ssl->dtls_expected_rx = max(sz + 100, MAX_MTU); #ifdef WOLFSSL_SCTP if (ssl->options.dtlsSctp) #endif #if defined(WOLLSSL_SCTP) || defined(WOLFSSL_DTLS_MTU) ssl->dtls_expected_rx = max(ssl->dtls_expected_rx, ssl->dtlsMtuSz); #endif } #endif sz = wolfSSL_GetMaxRecordSize(ssl, sz); ret = ReceiveData(ssl, (byte*)data, sz, peek); #ifdef HAVE_WRITE_DUP if (ssl->dupWrite) { if (ssl->error != 0 && ssl->error != WANT_READ #ifdef WOLFSSL_ASYNC_CRYPT && ssl->error != WC_PENDING_E #endif ) { int notifyErr; WOLFSSL_MSG("Notifying write side of fatal read error"); notifyErr = NotifyWriteSide(ssl, ssl->error); if (notifyErr < 0) { ret = ssl->error = notifyErr; } } } #endif WOLFSSL_LEAVE("wolfSSL_read_internal()", ret); if (ret < 0) return WOLFSSL_FATAL_ERROR; else return ret; } int wolfSSL_peek(WOLFSSL* ssl, void* data, int sz) { WOLFSSL_ENTER("wolfSSL_peek()"); return wolfSSL_read_internal(ssl, data, sz, TRUE); } WOLFSSL_ABI int wolfSSL_read(WOLFSSL* ssl, void* data, int sz) { WOLFSSL_ENTER("wolfSSL_read()"); #ifdef OPENSSL_EXTRA if (ssl->CBIS != NULL) { ssl->CBIS(ssl, SSL_CB_READ, SSL_SUCCESS); ssl->cbmode = SSL_CB_READ; } #endif return wolfSSL_read_internal(ssl, data, sz, FALSE); } #ifdef WOLFSSL_MULTICAST int wolfSSL_mcast_read(WOLFSSL* ssl, word16* id, void* data, int sz) { int ret = 0; WOLFSSL_ENTER("wolfSSL_mcast_read()"); if (ssl == NULL) return BAD_FUNC_ARG; ret = wolfSSL_read_internal(ssl, data, sz, FALSE); if (ssl->options.dtls && ssl->options.haveMcast && id != NULL) *id = ssl->keys.curPeerId; return ret; } #endif /* WOLFSSL_MULTICAST */ /* helpers to set the device id, WOLFSSL_SUCCESS on ok */ WOLFSSL_ABI int wolfSSL_SetDevId(WOLFSSL* ssl, int devId) { if (ssl == NULL) return BAD_FUNC_ARG; ssl->devId = devId; return WOLFSSL_SUCCESS; } WOLFSSL_ABI int wolfSSL_CTX_SetDevId(WOLFSSL_CTX* ctx, int devId) { if (ctx == NULL) return BAD_FUNC_ARG; ctx->devId = devId; return WOLFSSL_SUCCESS; } /* helpers to get device id and heap */ WOLFSSL_ABI int wolfSSL_CTX_GetDevId(WOLFSSL_CTX* ctx, WOLFSSL* ssl) { int devId = INVALID_DEVID; if (ctx != NULL) devId = ctx->devId; else if (ssl != NULL) devId = ssl->devId; return devId; } void* wolfSSL_CTX_GetHeap(WOLFSSL_CTX* ctx, WOLFSSL* ssl) { void* heap = NULL; if (ctx != NULL) heap = ctx->heap; else if (ssl != NULL) heap = ssl->heap; return heap; } #ifdef HAVE_SNI WOLFSSL_ABI int wolfSSL_UseSNI(WOLFSSL* ssl, byte type, const void* data, word16 size) { if (ssl == NULL) return BAD_FUNC_ARG; return TLSX_UseSNI(&ssl->extensions, type, data, size, ssl->heap); } WOLFSSL_ABI int wolfSSL_CTX_UseSNI(WOLFSSL_CTX* ctx, byte type, const void* data, word16 size) { if (ctx == NULL) return BAD_FUNC_ARG; return TLSX_UseSNI(&ctx->extensions, type, data, size, ctx->heap); } #ifndef NO_WOLFSSL_SERVER void wolfSSL_SNI_SetOptions(WOLFSSL* ssl, byte type, byte options) { if (ssl && ssl->extensions) TLSX_SNI_SetOptions(ssl->extensions, type, options); } void wolfSSL_CTX_SNI_SetOptions(WOLFSSL_CTX* ctx, byte type, byte options) { if (ctx && ctx->extensions) TLSX_SNI_SetOptions(ctx->extensions, type, options); } byte wolfSSL_SNI_Status(WOLFSSL* ssl, byte type) { return TLSX_SNI_Status(ssl ? ssl->extensions : NULL, type); } word16 wolfSSL_SNI_GetRequest(WOLFSSL* ssl, byte type, void** data) { if (data) *data = NULL; if (ssl && ssl->extensions) return TLSX_SNI_GetRequest(ssl->extensions, type, data); return 0; } int wolfSSL_SNI_GetFromBuffer(const byte* clientHello, word32 helloSz, byte type, byte* sni, word32* inOutSz) { if (clientHello && helloSz > 0 && sni && inOutSz && *inOutSz > 0) return TLSX_SNI_GetFromBuffer(clientHello, helloSz, type, sni, inOutSz); return BAD_FUNC_ARG; } #endif /* NO_WOLFSSL_SERVER */ #endif /* HAVE_SNI */ #ifdef HAVE_TRUSTED_CA WOLFSSL_API int wolfSSL_UseTrustedCA(WOLFSSL* ssl, byte type, const byte* certId, word32 certIdSz) { if (ssl == NULL) return BAD_FUNC_ARG; if (type == WOLFSSL_TRUSTED_CA_PRE_AGREED) { if (certId != NULL || certIdSz != 0) return BAD_FUNC_ARG; } else if (type == WOLFSSL_TRUSTED_CA_X509_NAME) { if (certId == NULL || certIdSz == 0) return BAD_FUNC_ARG; } #ifndef NO_SHA else if (type == WOLFSSL_TRUSTED_CA_KEY_SHA1 || type == WOLFSSL_TRUSTED_CA_CERT_SHA1) { if (certId == NULL || certIdSz != WC_SHA_DIGEST_SIZE) return BAD_FUNC_ARG; } #endif else return BAD_FUNC_ARG; return TLSX_UseTrustedCA(&ssl->extensions, type, certId, certIdSz, ssl->heap); } #endif /* HAVE_TRUSTED_CA */ #ifdef HAVE_MAX_FRAGMENT #ifndef NO_WOLFSSL_CLIENT int wolfSSL_UseMaxFragment(WOLFSSL* ssl, byte mfl) { if (ssl == NULL) return BAD_FUNC_ARG; #ifdef WOLFSSL_ALLOW_MAX_FRAGMENT_ADJUST /* The following is a non-standard way to reconfigure the max packet size post-handshake for wolfSSL_write/woflSSL_read */ if (ssl->options.handShakeState == HANDSHAKE_DONE) { switch (mfl) { case WOLFSSL_MFL_2_8 : ssl->max_fragment = 256; break; case WOLFSSL_MFL_2_9 : ssl->max_fragment = 512; break; case WOLFSSL_MFL_2_10: ssl->max_fragment = 1024; break; case WOLFSSL_MFL_2_11: ssl->max_fragment = 2048; break; case WOLFSSL_MFL_2_12: ssl->max_fragment = 4096; break; case WOLFSSL_MFL_2_13: ssl->max_fragment = 8192; break; default: ssl->max_fragment = MAX_RECORD_SIZE; break; } return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_MAX_FRAGMENT_ADJUST */ /* This call sets the max fragment TLS extension, which gets sent to server. The server_hello response is what sets the `ssl->max_fragment` in TLSX_MFL_Parse */ return TLSX_UseMaxFragment(&ssl->extensions, mfl, ssl->heap); } int wolfSSL_CTX_UseMaxFragment(WOLFSSL_CTX* ctx, byte mfl) { if (ctx == NULL) return BAD_FUNC_ARG; return TLSX_UseMaxFragment(&ctx->extensions, mfl, ctx->heap); } #endif /* NO_WOLFSSL_CLIENT */ #endif /* HAVE_MAX_FRAGMENT */ #ifdef HAVE_TRUNCATED_HMAC #ifndef NO_WOLFSSL_CLIENT int wolfSSL_UseTruncatedHMAC(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; return TLSX_UseTruncatedHMAC(&ssl->extensions, ssl->heap); } int wolfSSL_CTX_UseTruncatedHMAC(WOLFSSL_CTX* ctx) { if (ctx == NULL) return BAD_FUNC_ARG; return TLSX_UseTruncatedHMAC(&ctx->extensions, ctx->heap); } #endif /* NO_WOLFSSL_CLIENT */ #endif /* HAVE_TRUNCATED_HMAC */ #ifdef HAVE_CERTIFICATE_STATUS_REQUEST int wolfSSL_UseOCSPStapling(WOLFSSL* ssl, byte status_type, byte options) { if (ssl == NULL || ssl->options.side != WOLFSSL_CLIENT_END) return BAD_FUNC_ARG; return TLSX_UseCertificateStatusRequest(&ssl->extensions, status_type, options, NULL, ssl->heap, ssl->devId); } int wolfSSL_CTX_UseOCSPStapling(WOLFSSL_CTX* ctx, byte status_type, byte options) { if (ctx == NULL || ctx->method->side != WOLFSSL_CLIENT_END) return BAD_FUNC_ARG; return TLSX_UseCertificateStatusRequest(&ctx->extensions, status_type, options, NULL, ctx->heap, ctx->devId); } #endif /* HAVE_CERTIFICATE_STATUS_REQUEST */ #ifdef HAVE_CERTIFICATE_STATUS_REQUEST_V2 int wolfSSL_UseOCSPStaplingV2(WOLFSSL* ssl, byte status_type, byte options) { if (ssl == NULL || ssl->options.side != WOLFSSL_CLIENT_END) return BAD_FUNC_ARG; return TLSX_UseCertificateStatusRequestV2(&ssl->extensions, status_type, options, ssl->heap, ssl->devId); } int wolfSSL_CTX_UseOCSPStaplingV2(WOLFSSL_CTX* ctx, byte status_type, byte options) { if (ctx == NULL || ctx->method->side != WOLFSSL_CLIENT_END) return BAD_FUNC_ARG; return TLSX_UseCertificateStatusRequestV2(&ctx->extensions, status_type, options, ctx->heap, ctx->devId); } #endif /* HAVE_CERTIFICATE_STATUS_REQUEST_V2 */ /* Elliptic Curves */ #if defined(HAVE_SUPPORTED_CURVES) && !defined(NO_WOLFSSL_CLIENT) int wolfSSL_UseSupportedCurve(WOLFSSL* ssl, word16 name) { if (ssl == NULL) return BAD_FUNC_ARG; switch (name) { case WOLFSSL_ECC_SECP160K1: case WOLFSSL_ECC_SECP160R1: case WOLFSSL_ECC_SECP160R2: case WOLFSSL_ECC_SECP192K1: case WOLFSSL_ECC_SECP192R1: case WOLFSSL_ECC_SECP224K1: case WOLFSSL_ECC_SECP224R1: case WOLFSSL_ECC_SECP256K1: case WOLFSSL_ECC_SECP256R1: case WOLFSSL_ECC_SECP384R1: case WOLFSSL_ECC_SECP521R1: case WOLFSSL_ECC_BRAINPOOLP256R1: case WOLFSSL_ECC_BRAINPOOLP384R1: case WOLFSSL_ECC_BRAINPOOLP512R1: case WOLFSSL_ECC_X25519: case WOLFSSL_ECC_X448: case WOLFSSL_FFDHE_2048: case WOLFSSL_FFDHE_3072: case WOLFSSL_FFDHE_4096: case WOLFSSL_FFDHE_6144: case WOLFSSL_FFDHE_8192: break; default: return BAD_FUNC_ARG; } ssl->options.userCurves = 1; return TLSX_UseSupportedCurve(&ssl->extensions, name, ssl->heap); } int wolfSSL_CTX_UseSupportedCurve(WOLFSSL_CTX* ctx, word16 name) { if (ctx == NULL) return BAD_FUNC_ARG; switch (name) { case WOLFSSL_ECC_SECP160K1: case WOLFSSL_ECC_SECP160R1: case WOLFSSL_ECC_SECP160R2: case WOLFSSL_ECC_SECP192K1: case WOLFSSL_ECC_SECP192R1: case WOLFSSL_ECC_SECP224K1: case WOLFSSL_ECC_SECP224R1: case WOLFSSL_ECC_SECP256K1: case WOLFSSL_ECC_SECP256R1: case WOLFSSL_ECC_SECP384R1: case WOLFSSL_ECC_SECP521R1: case WOLFSSL_ECC_BRAINPOOLP256R1: case WOLFSSL_ECC_BRAINPOOLP384R1: case WOLFSSL_ECC_BRAINPOOLP512R1: case WOLFSSL_ECC_X25519: case WOLFSSL_ECC_X448: case WOLFSSL_FFDHE_2048: case WOLFSSL_FFDHE_3072: case WOLFSSL_FFDHE_4096: case WOLFSSL_FFDHE_6144: case WOLFSSL_FFDHE_8192: break; default: return BAD_FUNC_ARG; } ctx->userCurves = 1; return TLSX_UseSupportedCurve(&ctx->extensions, name, ctx->heap); } #endif /* HAVE_SUPPORTED_CURVES && !NO_WOLFSSL_CLIENT */ /* QSH quantum safe handshake */ #ifdef HAVE_QSH /* returns 1 if QSH has been used 0 otherwise */ int wolfSSL_isQSH(WOLFSSL* ssl) { /* if no ssl struct than QSH was not used */ if (ssl == NULL) return 0; return ssl->isQSH; } int wolfSSL_UseSupportedQSH(WOLFSSL* ssl, word16 name) { if (ssl == NULL) return BAD_FUNC_ARG; switch (name) { #ifdef HAVE_NTRU case WOLFSSL_NTRU_EESS439: case WOLFSSL_NTRU_EESS593: case WOLFSSL_NTRU_EESS743: break; #endif default: return BAD_FUNC_ARG; } ssl->user_set_QSHSchemes = 1; return TLSX_UseQSHScheme(&ssl->extensions, name, NULL, 0, ssl->heap); } #ifndef NO_WOLFSSL_CLIENT /* user control over sending client public key in hello when flag = 1 will send keys if flag is 0 or function is not called then will not send keys in the hello extension return 0 on success */ int wolfSSL_UseClientQSHKeys(WOLFSSL* ssl, unsigned char flag) { if (ssl == NULL) return BAD_FUNC_ARG; ssl->sendQSHKeys = flag; return 0; } #endif /* NO_WOLFSSL_CLIENT */ #endif /* HAVE_QSH */ /* Application-Layer Protocol Negotiation */ #ifdef HAVE_ALPN WOLFSSL_ABI int wolfSSL_UseALPN(WOLFSSL* ssl, char *protocol_name_list, word32 protocol_name_listSz, byte options) { char *list, *ptr, *token[WOLFSSL_MAX_ALPN_NUMBER]={NULL}; word16 len; int idx = 0; int ret = WOLFSSL_FAILURE; WOLFSSL_ENTER("wolfSSL_UseALPN"); if (ssl == NULL || protocol_name_list == NULL) return BAD_FUNC_ARG; if (protocol_name_listSz > (WOLFSSL_MAX_ALPN_NUMBER * WOLFSSL_MAX_ALPN_PROTO_NAME_LEN + WOLFSSL_MAX_ALPN_NUMBER)) { WOLFSSL_MSG("Invalid arguments, protocol name list too long"); return BAD_FUNC_ARG; } if (!(options & WOLFSSL_ALPN_CONTINUE_ON_MISMATCH) && !(options & WOLFSSL_ALPN_FAILED_ON_MISMATCH)) { WOLFSSL_MSG("Invalid arguments, options not supported"); return BAD_FUNC_ARG; } list = (char *)XMALLOC(protocol_name_listSz+1, ssl->heap, DYNAMIC_TYPE_ALPN); if (list == NULL) { WOLFSSL_MSG("Memory failure"); return MEMORY_ERROR; } XSTRNCPY(list, protocol_name_list, protocol_name_listSz); list[protocol_name_listSz] = '\0'; /* read all protocol name from the list */ token[idx] = XSTRTOK(list, ",", &ptr); while (idx < WOLFSSL_MAX_ALPN_NUMBER && token[idx] != NULL) token[++idx] = XSTRTOK(NULL, ",", &ptr); /* add protocol name list in the TLS extension in reverse order */ while ((idx--) > 0) { len = (word16)XSTRLEN(token[idx]); ret = TLSX_UseALPN(&ssl->extensions, token[idx], len, options, ssl->heap); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("TLSX_UseALPN failure"); break; } } XFREE(list, ssl->heap, DYNAMIC_TYPE_ALPN); return ret; } int wolfSSL_ALPN_GetProtocol(WOLFSSL* ssl, char **protocol_name, word16 *size) { return TLSX_ALPN_GetRequest(ssl ? ssl->extensions : NULL, (void **)protocol_name, size); } int wolfSSL_ALPN_GetPeerProtocol(WOLFSSL* ssl, char **list, word16 *listSz) { if (list == NULL || listSz == NULL) return BAD_FUNC_ARG; if (ssl->alpn_client_list == NULL) return BUFFER_ERROR; *listSz = (word16)XSTRLEN(ssl->alpn_client_list); if (*listSz == 0) return BUFFER_ERROR; *list = (char *)XMALLOC((*listSz)+1, ssl->heap, DYNAMIC_TYPE_TLSX); if (*list == NULL) return MEMORY_ERROR; XSTRNCPY(*list, ssl->alpn_client_list, (*listSz)+1); (*list)[*listSz] = 0; return WOLFSSL_SUCCESS; } /* used to free memory allocated by wolfSSL_ALPN_GetPeerProtocol */ int wolfSSL_ALPN_FreePeerProtocol(WOLFSSL* ssl, char **list) { if (ssl == NULL) { return BAD_FUNC_ARG; } XFREE(*list, ssl->heap, DYNAMIC_TYPE_TLSX); *list = NULL; return WOLFSSL_SUCCESS; } #endif /* HAVE_ALPN */ /* Secure Renegotiation */ #ifdef HAVE_SECURE_RENEGOTIATION /* user is forcing ability to use secure renegotiation, we discourage it */ int wolfSSL_UseSecureRenegotiation(WOLFSSL* ssl) { int ret = BAD_FUNC_ARG; if (ssl) ret = TLSX_UseSecureRenegotiation(&ssl->extensions, ssl->heap); if (ret == WOLFSSL_SUCCESS) { TLSX* extension = TLSX_Find(ssl->extensions, TLSX_RENEGOTIATION_INFO); if (extension) ssl->secure_renegotiation = (SecureRenegotiation*)extension->data; } return ret; } int wolfSSL_CTX_UseSecureRenegotiation(WOLFSSL_CTX* ctx) { if (ctx == NULL) return BAD_FUNC_ARG; ctx->useSecureReneg = 1; return WOLFSSL_SUCCESS; } /* do a secure renegotiation handshake, user forced, we discourage */ static int _Rehandshake(WOLFSSL* ssl) { int ret; if (ssl == NULL) return BAD_FUNC_ARG; if (ssl->secure_renegotiation == NULL) { WOLFSSL_MSG("Secure Renegotiation not forced on by user"); return SECURE_RENEGOTIATION_E; } if (ssl->secure_renegotiation->enabled == 0) { WOLFSSL_MSG("Secure Renegotiation not enabled at extension level"); return SECURE_RENEGOTIATION_E; } /* If the client started the renegotiation, the server will already * have processed the client's hello. */ if (ssl->options.side != WOLFSSL_SERVER_END || ssl->options.acceptState != ACCEPT_FIRST_REPLY_DONE) { if (ssl->options.handShakeState != HANDSHAKE_DONE) { WOLFSSL_MSG("Can't renegotiate until previous handshake complete"); return SECURE_RENEGOTIATION_E; } #ifndef NO_FORCE_SCR_SAME_SUITE /* force same suite */ if (ssl->suites) { ssl->suites->suiteSz = SUITE_LEN; ssl->suites->suites[0] = ssl->options.cipherSuite0; ssl->suites->suites[1] = ssl->options.cipherSuite; } #endif /* reset handshake states */ ssl->options.sendVerify = 0; ssl->options.serverState = NULL_STATE; ssl->options.clientState = NULL_STATE; ssl->options.connectState = CONNECT_BEGIN; ssl->options.acceptState = ACCEPT_BEGIN_RENEG; ssl->options.handShakeState = NULL_STATE; ssl->options.processReply = 0; /* TODO, move states in internal.h */ XMEMSET(&ssl->msgsReceived, 0, sizeof(ssl->msgsReceived)); ssl->secure_renegotiation->cache_status = SCR_CACHE_NEEDED; #if !defined(NO_WOLFSSL_SERVER) && defined(HAVE_SERVER_RENEGOTIATION_INFO) if (ssl->options.side == WOLFSSL_SERVER_END) { ret = SendHelloRequest(ssl); if (ret != 0) { ssl->error = ret; return WOLFSSL_FATAL_ERROR; } } #endif /* NO_WOLFSSL_SERVER && HAVE_SERVER_RENEGOTIATION_INFO */ ret = InitHandshakeHashes(ssl); if (ret != 0) { ssl->error = ret; return WOLFSSL_FATAL_ERROR; } } ret = wolfSSL_negotiate(ssl); ssl->secure_rene_count++; return ret; } /* do a secure renegotiation handshake, user forced, we discourage */ int wolfSSL_Rehandshake(WOLFSSL* ssl) { int ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_Rehandshake"); if (ssl->options.side == WOLFSSL_SERVER_END) { /* Reset option to send certificate verify. */ ssl->options.sendVerify = 0; } else { /* Reset resuming flag to do full secure handshake. */ ssl->options.resuming = 0; #ifdef HAVE_SESSION_TICKET /* Clearing the ticket. */ ret = wolfSSL_UseSessionTicket(ssl); #endif } if (ret == WOLFSSL_SUCCESS) ret = _Rehandshake(ssl); return ret; } #ifndef NO_WOLFSSL_CLIENT /* do a secure resumption handshake, user forced, we discourage */ int wolfSSL_SecureResume(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_SecureResume"); if (ssl == NULL) return BAD_FUNC_ARG; if (ssl->options.side == WOLFSSL_SERVER_END) { ssl->error = SIDE_ERROR; return SSL_FATAL_ERROR; } return _Rehandshake(ssl); } #endif /* NO_WOLFSSL_CLIENT */ long wolfSSL_SSL_get_secure_renegotiation_support(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_SSL_get_secure_renegotiation_support"); if (!ssl || !ssl->secure_renegotiation) return WOLFSSL_FAILURE; return ssl->secure_renegotiation->enabled; } #endif /* HAVE_SECURE_RENEGOTIATION */ /* Session Ticket */ #if !defined(NO_WOLFSSL_SERVER) && defined(HAVE_SESSION_TICKET) /* WOLFSSL_SUCCESS on ok */ int wolfSSL_CTX_set_TicketEncCb(WOLFSSL_CTX* ctx, SessionTicketEncCb cb) { if (ctx == NULL) return BAD_FUNC_ARG; ctx->ticketEncCb = cb; return WOLFSSL_SUCCESS; } /* set hint interval, WOLFSSL_SUCCESS on ok */ int wolfSSL_CTX_set_TicketHint(WOLFSSL_CTX* ctx, int hint) { if (ctx == NULL) return BAD_FUNC_ARG; ctx->ticketHint = hint; return WOLFSSL_SUCCESS; } /* set user context, WOLFSSL_SUCCESS on ok */ int wolfSSL_CTX_set_TicketEncCtx(WOLFSSL_CTX* ctx, void* userCtx) { if (ctx == NULL) return BAD_FUNC_ARG; ctx->ticketEncCtx = userCtx; return WOLFSSL_SUCCESS; } #endif /* !defined(NO_WOLFSSL_CLIENT) && defined(HAVE_SESSION_TICKET) */ /* Session Ticket */ #if !defined(NO_WOLFSSL_CLIENT) && defined(HAVE_SESSION_TICKET) int wolfSSL_UseSessionTicket(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; return TLSX_UseSessionTicket(&ssl->extensions, NULL, ssl->heap); } int wolfSSL_CTX_UseSessionTicket(WOLFSSL_CTX* ctx) { if (ctx == NULL) return BAD_FUNC_ARG; return TLSX_UseSessionTicket(&ctx->extensions, NULL, ctx->heap); } WOLFSSL_API int wolfSSL_get_SessionTicket(WOLFSSL* ssl, byte* buf, word32* bufSz) { if (ssl == NULL || buf == NULL || bufSz == NULL || *bufSz == 0) return BAD_FUNC_ARG; if (ssl->session.ticketLen <= *bufSz) { XMEMCPY(buf, ssl->session.ticket, ssl->session.ticketLen); *bufSz = ssl->session.ticketLen; } else *bufSz = 0; return WOLFSSL_SUCCESS; } WOLFSSL_API int wolfSSL_set_SessionTicket(WOLFSSL* ssl, const byte* buf, word32 bufSz) { if (ssl == NULL || (buf == NULL && bufSz > 0)) return BAD_FUNC_ARG; if (bufSz > 0) { /* Ticket will fit into static ticket */ if(bufSz <= SESSION_TICKET_LEN) { if (ssl->session.isDynamic) { XFREE(ssl->session.ticket, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); ssl->session.isDynamic = 0; ssl->session.ticket = ssl->session.staticTicket; } } else { /* Ticket requires dynamic ticket storage */ if (ssl->session.ticketLen < bufSz) { /* is dyn buffer big enough */ if(ssl->session.isDynamic) XFREE(ssl->session.ticket, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); ssl->session.ticket = (byte*)XMALLOC(bufSz, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); if(!ssl->session.ticket) { ssl->session.ticket = ssl->session.staticTicket; ssl->session.isDynamic = 0; return MEMORY_ERROR; } ssl->session.isDynamic = 1; } } XMEMCPY(ssl->session.ticket, buf, bufSz); } ssl->session.ticketLen = (word16)bufSz; return WOLFSSL_SUCCESS; } WOLFSSL_API int wolfSSL_set_SessionTicket_cb(WOLFSSL* ssl, CallbackSessionTicket cb, void* ctx) { if (ssl == NULL) return BAD_FUNC_ARG; ssl->session_ticket_cb = cb; ssl->session_ticket_ctx = ctx; return WOLFSSL_SUCCESS; } #endif #ifdef HAVE_EXTENDED_MASTER #ifndef NO_WOLFSSL_CLIENT int wolfSSL_CTX_DisableExtendedMasterSecret(WOLFSSL_CTX* ctx) { if (ctx == NULL) return BAD_FUNC_ARG; ctx->haveEMS = 0; return WOLFSSL_SUCCESS; } int wolfSSL_DisableExtendedMasterSecret(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; ssl->options.haveEMS = 0; return WOLFSSL_SUCCESS; } #endif #endif #ifndef WOLFSSL_LEANPSK int wolfSSL_send(WOLFSSL* ssl, const void* data, int sz, int flags) { int ret; int oldFlags; WOLFSSL_ENTER("wolfSSL_send()"); if (ssl == NULL || data == NULL || sz < 0) return BAD_FUNC_ARG; oldFlags = ssl->wflags; ssl->wflags = flags; ret = wolfSSL_write(ssl, data, sz); ssl->wflags = oldFlags; WOLFSSL_LEAVE("wolfSSL_send()", ret); return ret; } int wolfSSL_recv(WOLFSSL* ssl, void* data, int sz, int flags) { int ret; int oldFlags; WOLFSSL_ENTER("wolfSSL_recv()"); if (ssl == NULL || data == NULL || sz < 0) return BAD_FUNC_ARG; oldFlags = ssl->rflags; ssl->rflags = flags; ret = wolfSSL_read(ssl, data, sz); ssl->rflags = oldFlags; WOLFSSL_LEAVE("wolfSSL_recv()", ret); return ret; } #endif /* WOLFSSL_SUCCESS on ok */ WOLFSSL_ABI int wolfSSL_shutdown(WOLFSSL* ssl) { int ret = WOLFSSL_FATAL_ERROR; WOLFSSL_ENTER("SSL_shutdown()"); if (ssl == NULL) return WOLFSSL_FATAL_ERROR; if (ssl->options.quietShutdown) { WOLFSSL_MSG("quiet shutdown, no close notify sent"); ret = WOLFSSL_SUCCESS; } else { /* try to send close notify, not an error if can't */ if (!ssl->options.isClosed && !ssl->options.connReset && !ssl->options.sentNotify) { ssl->error = SendAlert(ssl, alert_warning, close_notify); if (ssl->error < 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->options.sentNotify = 1; /* don't send close_notify twice */ if (ssl->options.closeNotify) ret = WOLFSSL_SUCCESS; else { ret = WOLFSSL_SHUTDOWN_NOT_DONE; WOLFSSL_LEAVE("SSL_shutdown()", ret); return ret; } } #ifdef WOLFSSL_SHUTDOWNONCE if (ssl->options.isClosed || ssl->options.connReset) { /* Shutdown has already occurred. * Caller is free to ignore this error. */ return SSL_SHUTDOWN_ALREADY_DONE_E; } #endif /* call wolfSSL_shutdown again for bidirectional shutdown */ if (ssl->options.sentNotify && !ssl->options.closeNotify) { ret = ProcessReply(ssl); if (ret == ZERO_RETURN) { /* simulate OpenSSL behavior */ ssl->error = WOLFSSL_ERROR_SYSCALL; ret = WOLFSSL_SUCCESS; } else if (ssl->error == WOLFSSL_ERROR_NONE) { ret = WOLFSSL_SHUTDOWN_NOT_DONE; } else { WOLFSSL_ERROR(ssl->error); ret = WOLFSSL_FATAL_ERROR; } } } #ifdef OPENSSL_EXTRA /* reset WOLFSSL structure state for possible re-use */ if (ret == WOLFSSL_SUCCESS) { if (wolfSSL_clear(ssl) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("could not clear WOLFSSL"); ret = WOLFSSL_FATAL_ERROR; } } #endif WOLFSSL_LEAVE("SSL_shutdown()", ret); return ret; } /* get current error state value */ int wolfSSL_state(WOLFSSL* ssl) { if (ssl == NULL) { return BAD_FUNC_ARG; } return ssl->error; } WOLFSSL_ABI int wolfSSL_get_error(WOLFSSL* ssl, int ret) { WOLFSSL_ENTER("SSL_get_error"); if (ret > 0) return WOLFSSL_ERROR_NONE; if (ssl == NULL) return BAD_FUNC_ARG; WOLFSSL_LEAVE("SSL_get_error", ssl->error); /* make sure converted types are handled in SetErrorString() too */ if (ssl->error == WANT_READ) return WOLFSSL_ERROR_WANT_READ; /* convert to OpenSSL type */ else if (ssl->error == WANT_WRITE) return WOLFSSL_ERROR_WANT_WRITE; /* convert to OpenSSL type */ else if (ssl->error == ZERO_RETURN) return WOLFSSL_ERROR_ZERO_RETURN; /* convert to OpenSSL type */ return ssl->error; } /* retrieve alert history, WOLFSSL_SUCCESS on ok */ int wolfSSL_get_alert_history(WOLFSSL* ssl, WOLFSSL_ALERT_HISTORY *h) { if (ssl && h) { *h = ssl->alert_history; } return WOLFSSL_SUCCESS; } #ifdef OPENSSL_EXTRA /* returns SSL_WRITING, SSL_READING or SSL_NOTHING */ int wolfSSL_want(WOLFSSL* ssl) { int rw_state = SSL_NOTHING; if (ssl) { if (ssl->error == WANT_READ) rw_state = SSL_READING; else if (ssl->error == WANT_WRITE) rw_state = SSL_WRITING; } return rw_state; } #endif /* return TRUE if current error is want read */ int wolfSSL_want_read(WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_want_read"); if (ssl->error == WANT_READ) return 1; return 0; } /* return TRUE if current error is want write */ int wolfSSL_want_write(WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_want_write"); if (ssl->error == WANT_WRITE) return 1; return 0; } char* wolfSSL_ERR_error_string(unsigned long errNumber, char* data) { static wcchar msg = "Please supply a buffer for error string"; WOLFSSL_ENTER("ERR_error_string"); if (data) { SetErrorString((int)errNumber, data); return data; } return (char*)msg; } void wolfSSL_ERR_error_string_n(unsigned long e, char* buf, unsigned long len) { WOLFSSL_ENTER("wolfSSL_ERR_error_string_n"); if (len >= WOLFSSL_MAX_ERROR_SZ) wolfSSL_ERR_error_string(e, buf); else { char tmp[WOLFSSL_MAX_ERROR_SZ]; WOLFSSL_MSG("Error buffer too short, truncating"); if (len) { wolfSSL_ERR_error_string(e, tmp); XMEMCPY(buf, tmp, len-1); buf[len-1] = '\0'; } } } /* don't free temporary arrays at end of handshake */ void wolfSSL_KeepArrays(WOLFSSL* ssl) { if (ssl) ssl->options.saveArrays = 1; } /* user doesn't need temporary arrays anymore, Free */ void wolfSSL_FreeArrays(WOLFSSL* ssl) { if (ssl && ssl->options.handShakeState == HANDSHAKE_DONE) { ssl->options.saveArrays = 0; FreeArrays(ssl, 1); } } /* Set option to indicate that the resources are not to be freed after * handshake. * * ssl The SSL/TLS object. * returns BAD_FUNC_ARG when ssl is NULL and 0 on success. */ int wolfSSL_KeepHandshakeResources(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; ssl->options.keepResources = 1; return 0; } /* Free the handshake resources after handshake. * * ssl The SSL/TLS object. * returns BAD_FUNC_ARG when ssl is NULL and 0 on success. */ int wolfSSL_FreeHandshakeResources(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; FreeHandshakeResources(ssl); return 0; } /* Use the client's order of preference when matching cipher suites. * * ssl The SSL/TLS context object. * returns BAD_FUNC_ARG when ssl is NULL and 0 on success. */ int wolfSSL_CTX_UseClientSuites(WOLFSSL_CTX* ctx) { if (ctx == NULL) return BAD_FUNC_ARG; ctx->useClientOrder = 1; return 0; } /* Use the client's order of preference when matching cipher suites. * * ssl The SSL/TLS object. * returns BAD_FUNC_ARG when ssl is NULL and 0 on success. */ int wolfSSL_UseClientSuites(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; ssl->options.useClientOrder = 1; return 0; } const byte* wolfSSL_GetMacSecret(WOLFSSL* ssl, int verify) { #ifndef WOLFSSL_AEAD_ONLY if (ssl == NULL) return NULL; if ( (ssl->options.side == WOLFSSL_CLIENT_END && !verify) || (ssl->options.side == WOLFSSL_SERVER_END && verify) ) return ssl->keys.client_write_MAC_secret; else return ssl->keys.server_write_MAC_secret; #else (void)ssl; (void)verify; return NULL; #endif } #ifdef ATOMIC_USER void wolfSSL_CTX_SetMacEncryptCb(WOLFSSL_CTX* ctx, CallbackMacEncrypt cb) { if (ctx) ctx->MacEncryptCb = cb; } void wolfSSL_SetMacEncryptCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->MacEncryptCtx = ctx; } void* wolfSSL_GetMacEncryptCtx(WOLFSSL* ssl) { if (ssl) return ssl->MacEncryptCtx; return NULL; } void wolfSSL_CTX_SetDecryptVerifyCb(WOLFSSL_CTX* ctx, CallbackDecryptVerify cb) { if (ctx) ctx->DecryptVerifyCb = cb; } void wolfSSL_SetDecryptVerifyCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->DecryptVerifyCtx = ctx; } void* wolfSSL_GetDecryptVerifyCtx(WOLFSSL* ssl) { if (ssl) return ssl->DecryptVerifyCtx; return NULL; } #if defined(HAVE_ENCRYPT_THEN_MAC) && !defined(WOLFSSL_AEAD_ONLY) /** * Set the callback, against the context, that encrypts then MACs. * * ctx SSL/TLS context. * cb Callback function to use with Encrypt-Then-MAC. */ void wolfSSL_CTX_SetEncryptMacCb(WOLFSSL_CTX* ctx, CallbackEncryptMac cb) { if (ctx) ctx->EncryptMacCb = cb; } /** * Set the context to use with callback that encrypts then MACs. * * ssl SSL/TLS object. * ctx Callback function's context. */ void wolfSSL_SetEncryptMacCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->EncryptMacCtx = ctx; } /** * Get the context being used with callback that encrypts then MACs. * * ssl SSL/TLS object. * returns callback function's context or NULL if SSL/TLS object is NULL. */ void* wolfSSL_GetEncryptMacCtx(WOLFSSL* ssl) { if (ssl) return ssl->EncryptMacCtx; return NULL; } /** * Set the callback, against the context, that MAC verifies then decrypts. * * ctx SSL/TLS context. * cb Callback function to use with Encrypt-Then-MAC. */ void wolfSSL_CTX_SetVerifyDecryptCb(WOLFSSL_CTX* ctx, CallbackVerifyDecrypt cb) { if (ctx) ctx->VerifyDecryptCb = cb; } /** * Set the context to use with callback that MAC verifies then decrypts. * * ssl SSL/TLS object. * ctx Callback function's context. */ void wolfSSL_SetVerifyDecryptCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->VerifyDecryptCtx = ctx; } /** * Get the context being used with callback that MAC verifies then decrypts. * * ssl SSL/TLS object. * returns callback function's context or NULL if SSL/TLS object is NULL. */ void* wolfSSL_GetVerifyDecryptCtx(WOLFSSL* ssl) { if (ssl) return ssl->VerifyDecryptCtx; return NULL; } #endif /* HAVE_ENCRYPT_THEN_MAC !WOLFSSL_AEAD_ONLY */ const byte* wolfSSL_GetClientWriteKey(WOLFSSL* ssl) { if (ssl) return ssl->keys.client_write_key; return NULL; } const byte* wolfSSL_GetClientWriteIV(WOLFSSL* ssl) { if (ssl) return ssl->keys.client_write_IV; return NULL; } const byte* wolfSSL_GetServerWriteKey(WOLFSSL* ssl) { if (ssl) return ssl->keys.server_write_key; return NULL; } const byte* wolfSSL_GetServerWriteIV(WOLFSSL* ssl) { if (ssl) return ssl->keys.server_write_IV; return NULL; } int wolfSSL_GetKeySize(WOLFSSL* ssl) { if (ssl) return ssl->specs.key_size; return BAD_FUNC_ARG; } int wolfSSL_GetIVSize(WOLFSSL* ssl) { if (ssl) return ssl->specs.iv_size; return BAD_FUNC_ARG; } int wolfSSL_GetBulkCipher(WOLFSSL* ssl) { if (ssl) return ssl->specs.bulk_cipher_algorithm; return BAD_FUNC_ARG; } int wolfSSL_GetCipherType(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; #ifndef WOLFSSL_AEAD_ONLY if (ssl->specs.cipher_type == block) return WOLFSSL_BLOCK_TYPE; if (ssl->specs.cipher_type == stream) return WOLFSSL_STREAM_TYPE; #endif if (ssl->specs.cipher_type == aead) return WOLFSSL_AEAD_TYPE; return -1; } int wolfSSL_GetCipherBlockSize(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; return ssl->specs.block_size; } int wolfSSL_GetAeadMacSize(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; return ssl->specs.aead_mac_size; } int wolfSSL_IsTLSv1_1(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; if (ssl->options.tls1_1) return 1; return 0; } int wolfSSL_GetSide(WOLFSSL* ssl) { if (ssl) return ssl->options.side; return BAD_FUNC_ARG; } int wolfSSL_GetHmacSize(WOLFSSL* ssl) { /* AEAD ciphers don't have HMAC keys */ if (ssl) return (ssl->specs.cipher_type != aead) ? ssl->specs.hash_size : 0; return BAD_FUNC_ARG; } #endif /* ATOMIC_USER */ #ifndef NO_CERTS WOLFSSL_CERT_MANAGER* wolfSSL_CTX_GetCertManager(WOLFSSL_CTX* ctx) { WOLFSSL_CERT_MANAGER* cm = NULL; if (ctx) cm = ctx->cm; return cm; } WOLFSSL_CERT_MANAGER* wolfSSL_CertManagerNew_ex(void* heap) { WOLFSSL_CERT_MANAGER* cm; WOLFSSL_ENTER("wolfSSL_CertManagerNew"); cm = (WOLFSSL_CERT_MANAGER*) XMALLOC(sizeof(WOLFSSL_CERT_MANAGER), heap, DYNAMIC_TYPE_CERT_MANAGER); if (cm) { XMEMSET(cm, 0, sizeof(WOLFSSL_CERT_MANAGER)); if (wc_InitMutex(&cm->caLock) != 0) { WOLFSSL_MSG("Bad mutex init"); wolfSSL_CertManagerFree(cm); return NULL; } #ifdef WOLFSSL_TRUST_PEER_CERT if (wc_InitMutex(&cm->tpLock) != 0) { WOLFSSL_MSG("Bad mutex init"); wolfSSL_CertManagerFree(cm); return NULL; } #endif /* set default minimum key size allowed */ #ifndef NO_RSA cm->minRsaKeySz = MIN_RSAKEY_SZ; #endif #ifdef HAVE_ECC cm->minEccKeySz = MIN_ECCKEY_SZ; #endif cm->heap = heap; } return cm; } WOLFSSL_CERT_MANAGER* wolfSSL_CertManagerNew(void) { return wolfSSL_CertManagerNew_ex(NULL); } void wolfSSL_CertManagerFree(WOLFSSL_CERT_MANAGER* cm) { WOLFSSL_ENTER("wolfSSL_CertManagerFree"); if (cm) { #ifdef HAVE_CRL if (cm->crl) FreeCRL(cm->crl, 1); #endif #ifdef HAVE_OCSP if (cm->ocsp) FreeOCSP(cm->ocsp, 1); XFREE(cm->ocspOverrideURL, cm->heap, DYNAMIC_TYPE_URL); #if !defined(NO_WOLFSSL_SERVER) && \ (defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \ defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)) if (cm->ocsp_stapling) FreeOCSP(cm->ocsp_stapling, 1); #endif #endif FreeSignerTable(cm->caTable, CA_TABLE_SIZE, cm->heap); wc_FreeMutex(&cm->caLock); #ifdef WOLFSSL_TRUST_PEER_CERT FreeTrustedPeerTable(cm->tpTable, TP_TABLE_SIZE, cm->heap); wc_FreeMutex(&cm->tpLock); #endif XFREE(cm, cm->heap, DYNAMIC_TYPE_CERT_MANAGER); } } #if defined(OPENSSL_EXTRA) && !defined(NO_FILESYSTEM) #if defined(WOLFSSL_SIGNER_DER_CERT) /****************************************************************************** * wolfSSL_CertManagerGetCerts - retrieve stack of X509 certificates in a * certificate manager (CM). * * RETURNS: * returns stack of X509 certs on success, otherwise returns a NULL. */ WOLFSSL_STACK* wolfSSL_CertManagerGetCerts(WOLFSSL_CERT_MANAGER* cm) { WOLFSSL_STACK* sk = NULL; Signer* signers = NULL; word32 row = 0; DecodedCert* dCert = NULL; WOLFSSL_X509* x509 = NULL; int found = 0; if (cm == NULL) return NULL; sk = wolfSSL_sk_X509_new(); if (sk == NULL) { return NULL; } if (wc_LockMutex(&cm->caLock) != 0) { goto error_init; } for (row = 0; row < CA_TABLE_SIZE; row++) { signers = cm->caTable[row]; while (signers && signers->derCert && signers->derCert->buffer) { dCert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), cm->heap, DYNAMIC_TYPE_DCERT); if (dCert == NULL) { goto error; } XMEMSET(dCert, 0, sizeof(DecodedCert)); InitDecodedCert(dCert, signers->derCert->buffer, signers->derCert->length, cm->heap); /* Parse Certificate */ if (ParseCert(dCert, CERT_TYPE, NO_VERIFY, cm)) { goto error; } x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), cm->heap, DYNAMIC_TYPE_X509); if (x509 == NULL) { goto error; } InitX509(x509, 1, NULL); if (CopyDecodedToX509(x509, dCert) == 0) { if (wolfSSL_sk_X509_push(sk, x509) != SSL_SUCCESS) { WOLFSSL_MSG("Unable to load x509 into stack"); FreeX509(x509); XFREE(x509, cm->heap, DYNAMIC_TYPE_X509); goto error; } } else { goto error; } found = 1; signers = signers->next; FreeDecodedCert(dCert); XFREE(dCert, cm->heap, DYNAMIC_TYPE_DCERT); dCert = NULL; } } wc_UnLockMutex(&cm->caLock); if (!found) { goto error_init; } return sk; error: wc_UnLockMutex(&cm->caLock); error_init: if (dCert) { FreeDecodedCert(dCert); XFREE(dCert, cm->heap, DYNAMIC_TYPE_DCERT); } if (sk) wolfSSL_sk_X509_free(sk); return NULL; } #endif /* WOLFSSL_SIGNER_DER_CERT */ /****************************************************************************** * wolfSSL_X509_STORE_GetCerts - retrieve stack of X509 in a certificate store ctx * * This API can be used in SSL verify callback function to view cert chain * See examples/client/client.c and myVerify() function in test.h * * RETURNS: * returns stack of X509 certs on success, otherwise returns a NULL. */ WOLFSSL_STACK* wolfSSL_X509_STORE_GetCerts(WOLFSSL_X509_STORE_CTX* s) { int certIdx = 0; WOLFSSL_BUFFER_INFO* cert = NULL; DecodedCert* dCert = NULL; WOLFSSL_X509* x509 = NULL; WOLFSSL_STACK* sk = NULL; int found = 0; if (s == NULL) { return NULL; } sk = wolfSSL_sk_X509_new(); if (sk == NULL) { return NULL; } for (certIdx = s->totalCerts - 1; certIdx >= 0; certIdx--) { /* get certificate buffer */ cert = &s->certs[certIdx]; dCert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (dCert == NULL) { goto error; } XMEMSET(dCert, 0, sizeof(DecodedCert)); InitDecodedCert(dCert, cert->buffer, cert->length, NULL); /* Parse Certificate */ if (ParseCert(dCert, CERT_TYPE, NO_VERIFY, NULL)){ goto error; } x509 = wolfSSL_X509_new(); if (x509 == NULL) { goto error; } InitX509(x509, 1, NULL); if (CopyDecodedToX509(x509, dCert) == 0) { if (wolfSSL_sk_X509_push(sk, x509) != SSL_SUCCESS) { WOLFSSL_MSG("Unable to load x509 into stack"); wolfSSL_X509_free(x509); goto error; } } else { goto error; } found = 1; FreeDecodedCert(dCert); XFREE(dCert, NULL, DYNAMIC_TYPE_DCERT); dCert = NULL; } if (!found) { wolfSSL_sk_X509_free(sk); sk = NULL; } return sk; error: if (dCert) { FreeDecodedCert(dCert); XFREE(dCert, NULL, DYNAMIC_TYPE_DCERT); } if (sk) wolfSSL_sk_X509_free(sk); return NULL; } #endif /* OPENSSL_EXTRA && !NO_FILESYSTEM */ /* Unload the CA signer list */ int wolfSSL_CertManagerUnloadCAs(WOLFSSL_CERT_MANAGER* cm) { WOLFSSL_ENTER("wolfSSL_CertManagerUnloadCAs"); if (cm == NULL) return BAD_FUNC_ARG; if (wc_LockMutex(&cm->caLock) != 0) return BAD_MUTEX_E; FreeSignerTable(cm->caTable, CA_TABLE_SIZE, cm->heap); wc_UnLockMutex(&cm->caLock); return WOLFSSL_SUCCESS; } #ifdef WOLFSSL_TRUST_PEER_CERT int wolfSSL_CertManagerUnload_trust_peers(WOLFSSL_CERT_MANAGER* cm) { WOLFSSL_ENTER("wolfSSL_CertManagerUnload_trust_peers"); if (cm == NULL) return BAD_FUNC_ARG; if (wc_LockMutex(&cm->tpLock) != 0) return BAD_MUTEX_E; FreeTrustedPeerTable(cm->tpTable, TP_TABLE_SIZE, cm->heap); wc_UnLockMutex(&cm->tpLock); return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_TRUST_PEER_CERT */ #endif /* NO_CERTS */ #if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM) void wolfSSL_ERR_print_errors_fp(XFILE fp, int err) { char data[WOLFSSL_MAX_ERROR_SZ + 1]; WOLFSSL_ENTER("wolfSSL_ERR_print_errors_fp"); SetErrorString(err, data); fprintf(fp, "%s", data); } #if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE) void wolfSSL_ERR_dump_errors_fp(XFILE fp) { wc_ERR_print_errors_fp(fp); } void wolfSSL_ERR_print_errors_cb (int (*cb)(const char *str, size_t len, void *u), void *u) { wc_ERR_print_errors_cb(cb, u); } #endif #endif WOLFSSL_ABI int wolfSSL_pending(WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_pending"); return ssl->buffers.clearOutputBuffer.length; } #ifndef WOLFSSL_LEANPSK /* turn on handshake group messages for context */ int wolfSSL_CTX_set_group_messages(WOLFSSL_CTX* ctx) { if (ctx == NULL) return BAD_FUNC_ARG; ctx->groupMessages = 1; return WOLFSSL_SUCCESS; } #endif #ifndef NO_WOLFSSL_CLIENT /* connect enough to get peer cert chain */ int wolfSSL_connect_cert(WOLFSSL* ssl) { int ret; if (ssl == NULL) return WOLFSSL_FAILURE; ssl->options.certOnly = 1; ret = wolfSSL_connect(ssl); ssl->options.certOnly = 0; return ret; } #endif #ifndef WOLFSSL_LEANPSK /* turn on handshake group messages for ssl object */ int wolfSSL_set_group_messages(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; ssl->options.groupMessages = 1; return WOLFSSL_SUCCESS; } /* make minVersion the internal equivalent SSL version */ static int SetMinVersionHelper(byte* minVersion, int version) { #ifdef NO_TLS (void)minVersion; #endif switch (version) { #if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS) case WOLFSSL_SSLV3: *minVersion = SSLv3_MINOR; break; #endif #ifndef NO_TLS #ifndef NO_OLD_TLS #ifdef WOLFSSL_ALLOW_TLSV10 case WOLFSSL_TLSV1: *minVersion = TLSv1_MINOR; break; #endif case WOLFSSL_TLSV1_1: *minVersion = TLSv1_1_MINOR; break; #endif #ifndef WOLFSSL_NO_TLS12 case WOLFSSL_TLSV1_2: *minVersion = TLSv1_2_MINOR; break; #endif #endif #ifdef WOLFSSL_TLS13 case WOLFSSL_TLSV1_3: *minVersion = TLSv1_3_MINOR; break; #endif default: WOLFSSL_MSG("Bad function argument"); return BAD_FUNC_ARG; } return WOLFSSL_SUCCESS; } /* Set minimum downgrade version allowed, WOLFSSL_SUCCESS on ok */ WOLFSSL_ABI int wolfSSL_CTX_SetMinVersion(WOLFSSL_CTX* ctx, int version) { WOLFSSL_ENTER("wolfSSL_CTX_SetMinVersion"); if (ctx == NULL) { WOLFSSL_MSG("Bad function argument"); return BAD_FUNC_ARG; } return SetMinVersionHelper(&ctx->minDowngrade, version); } /* Set minimum downgrade version allowed, WOLFSSL_SUCCESS on ok */ int wolfSSL_SetMinVersion(WOLFSSL* ssl, int version) { WOLFSSL_ENTER("wolfSSL_SetMinVersion"); if (ssl == NULL) { WOLFSSL_MSG("Bad function argument"); return BAD_FUNC_ARG; } return SetMinVersionHelper(&ssl->options.minDowngrade, version); } /* Function to get version as WOLFSSL_ enum value for wolfSSL_SetVersion */ int wolfSSL_GetVersion(WOLFSSL* ssl) { if (ssl == NULL) return BAD_FUNC_ARG; if (ssl->version.major == SSLv3_MAJOR) { switch (ssl->version.minor) { case SSLv3_MINOR : return WOLFSSL_SSLV3; case TLSv1_MINOR : return WOLFSSL_TLSV1; case TLSv1_1_MINOR : return WOLFSSL_TLSV1_1; case TLSv1_2_MINOR : return WOLFSSL_TLSV1_2; case TLSv1_3_MINOR : return WOLFSSL_TLSV1_3; default: break; } } return VERSION_ERROR; } int wolfSSL_SetVersion(WOLFSSL* ssl, int version) { word16 haveRSA = 1; word16 havePSK = 0; int keySz = 0; WOLFSSL_ENTER("wolfSSL_SetVersion"); if (ssl == NULL) { WOLFSSL_MSG("Bad function argument"); return BAD_FUNC_ARG; } switch (version) { #if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS) case WOLFSSL_SSLV3: ssl->version = MakeSSLv3(); break; #endif #ifndef NO_TLS #ifndef NO_OLD_TLS #ifdef WOLFSSL_ALLOW_TLSV10 case WOLFSSL_TLSV1: ssl->version = MakeTLSv1(); break; #endif case WOLFSSL_TLSV1_1: ssl->version = MakeTLSv1_1(); break; #endif #ifndef WOLFSSL_NO_TLS12 case WOLFSSL_TLSV1_2: ssl->version = MakeTLSv1_2(); break; #endif #endif #ifdef WOLFSSL_TLS13 case WOLFSSL_TLSV1_3: ssl->version = MakeTLSv1_3(); break; #endif default: WOLFSSL_MSG("Bad function argument"); return BAD_FUNC_ARG; } #ifdef NO_RSA haveRSA = 0; #endif #ifndef NO_PSK havePSK = ssl->options.havePSK; #endif #ifndef NO_CERTS keySz = ssl->buffers.keySz; #endif InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK, ssl->options.haveDH, ssl->options.haveNTRU, ssl->options.haveECDSAsig, ssl->options.haveECC, ssl->options.haveStaticECC, ssl->options.side); return WOLFSSL_SUCCESS; } #endif /* !leanpsk */ #if !defined(NO_CERTS) || !defined(NO_SESSION_CACHE) /* Make a work from the front of random hash */ static WC_INLINE word32 MakeWordFromHash(const byte* hashID) { return ((word32)hashID[0] << 24) | ((word32)hashID[1] << 16) | (hashID[2] << 8) | hashID[3]; } #endif /* !NO_CERTS || !NO_SESSION_CACHE */ #ifndef NO_CERTS /* hash is the SHA digest of name, just use first 32 bits as hash */ static WC_INLINE word32 HashSigner(const byte* hash) { return MakeWordFromHash(hash) % CA_TABLE_SIZE; } /* does CA already exist on signer list */ int AlreadySigner(WOLFSSL_CERT_MANAGER* cm, byte* hash) { Signer* signers; int ret = 0; word32 row; if (cm == NULL || hash == NULL) { return ret; } row = HashSigner(hash); if (wc_LockMutex(&cm->caLock) != 0) { return ret; } signers = cm->caTable[row]; while (signers) { byte* subjectHash; #ifndef NO_SKID subjectHash = signers->subjectKeyIdHash; #else subjectHash = signers->subjectNameHash; #endif if (XMEMCMP(hash, subjectHash, SIGNER_DIGEST_SIZE) == 0) { ret = 1; /* success */ break; } signers = signers->next; } wc_UnLockMutex(&cm->caLock); return ret; } #ifdef WOLFSSL_TRUST_PEER_CERT /* hash is the SHA digest of name, just use first 32 bits as hash */ static WC_INLINE word32 TrustedPeerHashSigner(const byte* hash) { return MakeWordFromHash(hash) % TP_TABLE_SIZE; } /* does trusted peer already exist on signer list */ int AlreadyTrustedPeer(WOLFSSL_CERT_MANAGER* cm, byte* hash) { TrustedPeerCert* tp; int ret = 0; word32 row = TrustedPeerHashSigner(hash); if (wc_LockMutex(&cm->tpLock) != 0) return ret; tp = cm->tpTable[row]; while (tp) { byte* subjectHash; #ifndef NO_SKID subjectHash = tp->subjectKeyIdHash; #else subjectHash = tp->subjectNameHash; #endif if (XMEMCMP(hash, subjectHash, SIGNER_DIGEST_SIZE) == 0) { ret = 1; break; } tp = tp->next; } wc_UnLockMutex(&cm->tpLock); return ret; } /* return Trusted Peer if found, otherwise NULL type is what to match on */ TrustedPeerCert* GetTrustedPeer(void* vp, byte* hash, int type) { WOLFSSL_CERT_MANAGER* cm = (WOLFSSL_CERT_MANAGER*)vp; TrustedPeerCert* ret = NULL; TrustedPeerCert* tp = NULL; word32 row; if (cm == NULL || hash == NULL) return NULL; row = TrustedPeerHashSigner(hash); if (wc_LockMutex(&cm->tpLock) != 0) return ret; tp = cm->tpTable[row]; while (tp) { byte* subjectHash; switch (type) { #ifndef NO_SKID case WC_MATCH_SKID: subjectHash = tp->subjectKeyIdHash; break; #endif case WC_MATCH_NAME: subjectHash = tp->subjectNameHash; break; default: WOLFSSL_MSG("Unknown search type"); wc_UnLockMutex(&cm->tpLock); return NULL; } if (XMEMCMP(hash, subjectHash, SIGNER_DIGEST_SIZE) == 0) { ret = tp; break; } tp = tp->next; } wc_UnLockMutex(&cm->tpLock); return ret; } int MatchTrustedPeer(TrustedPeerCert* tp, DecodedCert* cert) { if (tp == NULL || cert == NULL) return BAD_FUNC_ARG; /* subject key id or subject hash has been compared when searching tpTable for the cert from function GetTrustedPeer */ /* compare signatures */ if (tp->sigLen == cert->sigLength) { if (XMEMCMP(tp->sig, cert->signature, cert->sigLength)) { return WOLFSSL_FAILURE; } } else { return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_TRUST_PEER_CERT */ /* return CA if found, otherwise NULL */ Signer* GetCA(void* vp, byte* hash) { WOLFSSL_CERT_MANAGER* cm = (WOLFSSL_CERT_MANAGER*)vp; Signer* ret = NULL; Signer* signers; word32 row = HashSigner(hash); if (cm == NULL) return NULL; if (wc_LockMutex(&cm->caLock) != 0) return ret; signers = cm->caTable[row]; while (signers) { byte* subjectHash; #ifndef NO_SKID subjectHash = signers->subjectKeyIdHash; #else subjectHash = signers->subjectNameHash; #endif if (XMEMCMP(hash, subjectHash, SIGNER_DIGEST_SIZE) == 0) { ret = signers; break; } signers = signers->next; } wc_UnLockMutex(&cm->caLock); return ret; } #ifndef NO_SKID /* return CA if found, otherwise NULL. Walk through hash table. */ Signer* GetCAByName(void* vp, byte* hash) { WOLFSSL_CERT_MANAGER* cm = (WOLFSSL_CERT_MANAGER*)vp; Signer* ret = NULL; Signer* signers; word32 row; if (cm == NULL) return NULL; if (wc_LockMutex(&cm->caLock) != 0) return ret; for (row = 0; row < CA_TABLE_SIZE && ret == NULL; row++) { signers = cm->caTable[row]; while (signers && ret == NULL) { if (XMEMCMP(hash, signers->subjectNameHash, SIGNER_DIGEST_SIZE) == 0) { ret = signers; } signers = signers->next; } } wc_UnLockMutex(&cm->caLock); return ret; } #endif #ifdef WOLFSSL_TRUST_PEER_CERT /* add a trusted peer cert to linked list */ int AddTrustedPeer(WOLFSSL_CERT_MANAGER* cm, DerBuffer** pDer, int verify) { int ret, row; TrustedPeerCert* peerCert; DecodedCert* cert; DerBuffer* der = *pDer; byte* subjectHash = NULL; WOLFSSL_MSG("Adding a Trusted Peer Cert"); cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), cm->heap, DYNAMIC_TYPE_DCERT); if (cert == NULL) return MEMORY_E; InitDecodedCert(cert, der->buffer, der->length, cm->heap); if ((ret = ParseCert(cert, TRUSTED_PEER_TYPE, verify, cm)) != 0) { FreeDecodedCert(cert); XFREE(cert, NULL, DYNAMIC_TYPE_DCERT); return ret; } WOLFSSL_MSG("\tParsed new trusted peer cert"); peerCert = (TrustedPeerCert*)XMALLOC(sizeof(TrustedPeerCert), cm->heap, DYNAMIC_TYPE_CERT); if (peerCert == NULL) { FreeDecodedCert(cert); XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT); return MEMORY_E; } XMEMSET(peerCert, 0, sizeof(TrustedPeerCert)); #ifndef NO_SKID if (cert->extAuthKeyIdSet) { subjectHash = cert->extSubjKeyId; } else { subjectHash = cert->subjectHash; } #else subjectHash = cert->subjectHash; #endif #ifndef IGNORE_NAME_CONSTRAINTS if (peerCert->permittedNames) FreeNameSubtrees(peerCert->permittedNames, cm->heap); if (peerCert->excludedNames) FreeNameSubtrees(peerCert->excludedNames, cm->heap); #endif if (AlreadyTrustedPeer(cm, subjectHash)) { WOLFSSL_MSG("\tAlready have this CA, not adding again"); FreeTrustedPeer(peerCert, cm->heap); (void)ret; } else { /* add trusted peer signature */ peerCert->sigLen = cert->sigLength; peerCert->sig = XMALLOC(cert->sigLength, cm->heap, DYNAMIC_TYPE_SIGNATURE); if (peerCert->sig == NULL) { FreeDecodedCert(cert); XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT); FreeTrustedPeer(peerCert, cm->heap); return MEMORY_E; } XMEMCPY(peerCert->sig, cert->signature, cert->sigLength); /* add trusted peer name */ peerCert->nameLen = cert->subjectCNLen; peerCert->name = cert->subjectCN; #ifndef IGNORE_NAME_CONSTRAINTS peerCert->permittedNames = cert->permittedNames; peerCert->excludedNames = cert->excludedNames; #endif /* add SKID when available and hash of name */ #ifndef NO_SKID XMEMCPY(peerCert->subjectKeyIdHash, cert->extSubjKeyId, SIGNER_DIGEST_SIZE); #endif XMEMCPY(peerCert->subjectNameHash, cert->subjectHash, SIGNER_DIGEST_SIZE); peerCert->next = NULL; /* If Key Usage not set, all uses valid. */ cert->subjectCN = 0; #ifndef IGNORE_NAME_CONSTRAINTS cert->permittedNames = NULL; cert->excludedNames = NULL; #endif #ifndef NO_SKID if (cert->extAuthKeyIdSet) { row = TrustedPeerHashSigner(peerCert->subjectKeyIdHash); } else { row = TrustedPeerHashSigner(peerCert->subjectNameHash); } #else row = TrustedPeerHashSigner(peerCert->subjectNameHash); #endif if (wc_LockMutex(&cm->tpLock) == 0) { peerCert->next = cm->tpTable[row]; cm->tpTable[row] = peerCert; /* takes ownership */ wc_UnLockMutex(&cm->tpLock); } else { WOLFSSL_MSG("\tTrusted Peer Cert Mutex Lock failed"); FreeDecodedCert(cert); XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT); FreeTrustedPeer(peerCert, cm->heap); return BAD_MUTEX_E; } } WOLFSSL_MSG("\tFreeing parsed trusted peer cert"); FreeDecodedCert(cert); XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT); WOLFSSL_MSG("\tFreeing der trusted peer cert"); FreeDer(&der); WOLFSSL_MSG("\t\tOK Freeing der trusted peer cert"); WOLFSSL_LEAVE("AddTrustedPeer", ret); return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_TRUST_PEER_CERT */ /* owns der, internal now uses too */ /* type flag ids from user or from chain received during verify don't allow chain ones to be added w/o isCA extension */ int AddCA(WOLFSSL_CERT_MANAGER* cm, DerBuffer** pDer, int type, int verify) { int ret; Signer* signer = NULL; word32 row; byte* subjectHash; #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert = NULL; #else DecodedCert cert[1]; #endif DerBuffer* der = *pDer; WOLFSSL_MSG("Adding a CA"); if (cm == NULL) { FreeDer(pDer); return BAD_FUNC_ARG; } #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (cert == NULL) { FreeDer(pDer); return MEMORY_E; } #endif InitDecodedCert(cert, der->buffer, der->length, cm->heap); ret = ParseCert(cert, CA_TYPE, verify, cm); WOLFSSL_MSG("\tParsed new CA"); #ifndef NO_SKID subjectHash = cert->extSubjKeyId; #else subjectHash = cert->subjectHash; #endif /* check CA key size */ if (verify) { switch (cert->keyOID) { #ifndef NO_RSA case RSAk: if (cm->minRsaKeySz < 0 || cert->pubKeySize < (word16)cm->minRsaKeySz) { ret = RSA_KEY_SIZE_E; WOLFSSL_MSG("\tCA RSA key size error"); } break; #endif /* !NO_RSA */ #ifdef HAVE_ECC case ECDSAk: if (cm->minEccKeySz < 0 || cert->pubKeySize < (word16)cm->minEccKeySz) { ret = ECC_KEY_SIZE_E; WOLFSSL_MSG("\tCA ECC key size error"); } break; #endif /* HAVE_ECC */ #ifdef HAVE_ED25519 case ED25519k: if (cm->minEccKeySz < 0 || ED25519_KEY_SIZE < (word16)cm->minEccKeySz) { ret = ECC_KEY_SIZE_E; WOLFSSL_MSG("\tCA ECC key size error"); } break; #endif /* HAVE_ED25519 */ #ifdef HAVE_ED448 case ED448k: if (cm->minEccKeySz < 0 || ED448_KEY_SIZE < (word16)cm->minEccKeySz) { ret = ECC_KEY_SIZE_E; WOLFSSL_MSG("\tCA ECC key size error"); } break; #endif /* HAVE_ED448 */ default: WOLFSSL_MSG("\tNo key size check done on CA"); break; /* no size check if key type is not in switch */ } } if (ret == 0 && cert->isCA == 0 && type != WOLFSSL_USER_CA) { WOLFSSL_MSG("\tCan't add as CA if not actually one"); ret = NOT_CA_ERROR; } #ifndef ALLOW_INVALID_CERTSIGN else if (ret == 0 && cert->isCA == 1 && type != WOLFSSL_USER_CA && !cert->selfSigned && (cert->extKeyUsage & KEYUSE_KEY_CERT_SIGN) == 0) { /* Intermediate CA certs are required to have the keyCertSign * extension set. User loaded root certs are not. */ WOLFSSL_MSG("\tDoesn't have key usage certificate signing"); ret = NOT_CA_ERROR; } #endif else if (ret == 0 && AlreadySigner(cm, subjectHash)) { WOLFSSL_MSG("\tAlready have this CA, not adding again"); (void)ret; } else if (ret == 0) { /* take over signer parts */ signer = MakeSigner(cm->heap); if (!signer) ret = MEMORY_ERROR; } if (ret == 0 && signer != NULL) { #ifdef WOLFSSL_SIGNER_DER_CERT ret = AllocDer(&signer->derCert, der->length, der->type, NULL); } if (ret == 0 && signer != NULL) { XMEMCPY(signer->derCert->buffer, der->buffer, der->length); #endif signer->keyOID = cert->keyOID; if (cert->pubKeyStored) { signer->publicKey = cert->publicKey; signer->pubKeySize = cert->pubKeySize; } if (cert->subjectCNStored) { signer->nameLen = cert->subjectCNLen; signer->name = cert->subjectCN; } signer->pathLength = cert->pathLength; signer->maxPathLen = cert->maxPathLen; signer->pathLengthSet = cert->pathLengthSet; signer->selfSigned = cert->selfSigned; #ifndef IGNORE_NAME_CONSTRAINTS signer->permittedNames = cert->permittedNames; signer->excludedNames = cert->excludedNames; #endif #ifndef NO_SKID XMEMCPY(signer->subjectKeyIdHash, cert->extSubjKeyId, SIGNER_DIGEST_SIZE); #endif XMEMCPY(signer->subjectNameHash, cert->subjectHash, SIGNER_DIGEST_SIZE); #ifdef HAVE_OCSP XMEMCPY(signer->subjectKeyHash, cert->subjectKeyHash, KEYID_SIZE); #endif signer->keyUsage = cert->extKeyUsageSet ? cert->extKeyUsage : 0xFFFF; signer->next = NULL; /* If Key Usage not set, all uses valid. */ cert->publicKey = 0; /* in case lock fails don't free here. */ cert->subjectCN = 0; #ifndef IGNORE_NAME_CONSTRAINTS cert->permittedNames = NULL; cert->excludedNames = NULL; #endif #ifndef NO_SKID row = HashSigner(signer->subjectKeyIdHash); #else row = HashSigner(signer->subjectNameHash); #endif if (wc_LockMutex(&cm->caLock) == 0) { signer->next = cm->caTable[row]; cm->caTable[row] = signer; /* takes ownership */ wc_UnLockMutex(&cm->caLock); if (cm->caCacheCallback) cm->caCacheCallback(der->buffer, (int)der->length, type); } else { WOLFSSL_MSG("\tCA Mutex Lock failed"); ret = BAD_MUTEX_E; FreeSigner(signer, cm->heap); } } #if defined(WOLFSSL_RENESAS_TSIP_TLS) /* Verify CA by TSIP so that generated tsip key is going to be able to */ /* be used for peer's cert verification */ /* TSIP is only able to handle USER CA, and only one CA. */ /* Therefore, it doesn't need to call TSIP again if there is already */ /* verified CA. */ if ( ret == 0 && signer != NULL ) { signer->cm_idx = row; if (type == WOLFSSL_USER_CA && tsip_rootCAverified() == 0 ) { if ((ret = tsip_tls_RootCertVerify(cert->source, cert->maxIdx, cert->sigCtx.pubkey_n_start, cert->sigCtx.pubkey_n_len - 1, cert->sigCtx.pubkey_e_start, cert->sigCtx.pubkey_e_len - 1, row/* cm index */)) != 0) WOLFSSL_MSG("tsip_tls_RootCertVerify() failed"); else WOLFSSL_MSG("tsip_tls_RootCertVerify() succeed"); } } #endif WOLFSSL_MSG("\tFreeing Parsed CA"); FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, NULL, DYNAMIC_TYPE_DCERT); #endif WOLFSSL_MSG("\tFreeing der CA"); FreeDer(pDer); WOLFSSL_MSG("\t\tOK Freeing der CA"); WOLFSSL_LEAVE("AddCA", ret); return ret == 0 ? WOLFSSL_SUCCESS : ret; } #endif /* !NO_CERTS */ #ifndef NO_SESSION_CACHE /* basic config gives a cache with 33 sessions, adequate for clients and embedded servers TITAN_SESSION_CACHE allows just over 2 million sessions, for servers with titanic amounts of memory with long session ID timeouts and high levels of traffic. HUGE_SESSION_CACHE yields 65,791 sessions, for servers under heavy load, allows over 13,000 new sessions per minute or over 200 new sessions per second BIG_SESSION_CACHE yields 20,027 sessions MEDIUM_SESSION_CACHE allows 1055 sessions, adequate for servers that aren't under heavy load, basically allows 200 new sessions per minute SMALL_SESSION_CACHE only stores 6 sessions, good for embedded clients or systems where the default of nearly 3kB is too much RAM, this define uses less than 500 bytes RAM default SESSION_CACHE stores 33 sessions (no XXX_SESSION_CACHE defined) */ #if defined(TITAN_SESSION_CACHE) #define SESSIONS_PER_ROW 31 #define SESSION_ROWS 64937 #elif defined(HUGE_SESSION_CACHE) #define SESSIONS_PER_ROW 11 #define SESSION_ROWS 5981 #elif defined(BIG_SESSION_CACHE) #define SESSIONS_PER_ROW 7 #define SESSION_ROWS 2861 #elif defined(MEDIUM_SESSION_CACHE) #define SESSIONS_PER_ROW 5 #define SESSION_ROWS 211 #elif defined(SMALL_SESSION_CACHE) #define SESSIONS_PER_ROW 2 #define SESSION_ROWS 3 #else #define SESSIONS_PER_ROW 3 #define SESSION_ROWS 11 #endif typedef struct SessionRow { int nextIdx; /* where to place next one */ int totalCount; /* sessions ever on this row */ WOLFSSL_SESSION Sessions[SESSIONS_PER_ROW]; } SessionRow; static WOLFSSL_GLOBAL SessionRow SessionCache[SESSION_ROWS]; #if defined(WOLFSSL_SESSION_STATS) && defined(WOLFSSL_PEAK_SESSIONS) static WOLFSSL_GLOBAL word32 PeakSessions; #endif static WOLFSSL_GLOBAL wolfSSL_Mutex session_mutex; /* SessionCache mutex */ #ifndef NO_CLIENT_CACHE typedef struct ClientSession { word16 serverRow; /* SessionCache Row id */ word16 serverIdx; /* SessionCache Idx (column) */ } ClientSession; typedef struct ClientRow { int nextIdx; /* where to place next one */ int totalCount; /* sessions ever on this row */ ClientSession Clients[SESSIONS_PER_ROW]; } ClientRow; static WOLFSSL_GLOBAL ClientRow ClientCache[SESSION_ROWS]; /* Client Cache */ /* uses session mutex */ #endif /* NO_CLIENT_CACHE */ #endif /* NO_SESSION_CACHE */ WOLFSSL_ABI int wolfSSL_Init(void) { WOLFSSL_ENTER("wolfSSL_Init"); if (initRefCount == 0) { /* Initialize crypto for use with TLS connection */ if (wolfCrypt_Init() != 0) { WOLFSSL_MSG("Bad wolfCrypt Init"); return WC_INIT_E; } #ifdef OPENSSL_EXTRA if (wolfSSL_RAND_seed(NULL, 0) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("wolfSSL_RAND_Seed failed"); return WC_INIT_E; } #endif #ifndef NO_SESSION_CACHE if (wc_InitMutex(&session_mutex) != 0) { WOLFSSL_MSG("Bad Init Mutex session"); return BAD_MUTEX_E; } #endif if (wc_InitMutex(&count_mutex) != 0) { WOLFSSL_MSG("Bad Init Mutex count"); return BAD_MUTEX_E; } } if (wc_LockMutex(&count_mutex) != 0) { WOLFSSL_MSG("Bad Lock Mutex count"); return BAD_MUTEX_E; } initRefCount++; wc_UnLockMutex(&count_mutex); return WOLFSSL_SUCCESS; } #ifndef NO_CERTS /* process user cert chain to pass during the handshake */ static int ProcessUserChain(WOLFSSL_CTX* ctx, const unsigned char* buff, long sz, int format, int type, WOLFSSL* ssl, long* used, EncryptedInfo* info, int verify) { int ret = 0; void* heap = wolfSSL_CTX_GetHeap(ctx, ssl); #ifdef WOLFSSL_TLS13 int cnt = 0; #endif if ((type == CA_TYPE) && (ctx == NULL)) { WOLFSSL_MSG("Need context for CA load"); return BAD_FUNC_ARG; } /* we may have a user cert chain, try to consume */ if ((type == CERT_TYPE || type == CA_TYPE) && (info->consumed < sz)) { #ifdef WOLFSSL_SMALL_STACK byte staticBuffer[1]; /* force heap usage */ #else byte staticBuffer[FILE_BUFFER_SIZE]; /* tmp chain buffer */ #endif byte* chainBuffer = staticBuffer; int dynamicBuffer = 0; word32 bufferSz; long consumed = info->consumed; word32 idx = 0; int gotOne = 0; /* Calculate max possible size, including max headers */ bufferSz = (word32)(sz - consumed) + (CERT_HEADER_SZ * MAX_CHAIN_DEPTH); if (bufferSz > sizeof(staticBuffer)) { WOLFSSL_MSG("Growing Tmp Chain Buffer"); /* will shrink to actual size */ chainBuffer = (byte*)XMALLOC(bufferSz, heap, DYNAMIC_TYPE_FILE); if (chainBuffer == NULL) { return MEMORY_E; } dynamicBuffer = 1; } WOLFSSL_MSG("Processing Cert Chain"); while (consumed < sz) { DerBuffer* part = NULL; word32 remain = (word32)(sz - consumed); info->consumed = 0; if (format == WOLFSSL_FILETYPE_PEM) { #ifdef WOLFSSL_PEM_TO_DER ret = PemToDer(buff + consumed, remain, type, &part, heap, info, NULL); #else ret = NOT_COMPILED_IN; #endif } else { int length = remain; if (format == WOLFSSL_FILETYPE_ASN1) { /* get length of der (read sequence) */ word32 inOutIdx = 0; if (GetSequence(buff + consumed, &inOutIdx, &length, remain) < 0) { ret = ASN_NO_PEM_HEADER; } length += inOutIdx; /* include leading sequence */ } info->consumed = length; if (ret == 0) { ret = AllocDer(&part, length, type, heap); if (ret == 0) { XMEMCPY(part->buffer, buff + consumed, length); } } } if (ret == 0) { gotOne = 1; #ifdef WOLFSSL_TLS13 cnt++; #endif if ((idx + part->length + CERT_HEADER_SZ) > bufferSz) { WOLFSSL_MSG(" Cert Chain bigger than buffer"); ret = BUFFER_E; } else { c32to24(part->length, &chainBuffer[idx]); idx += CERT_HEADER_SZ; XMEMCPY(&chainBuffer[idx], part->buffer, part->length); idx += part->length; consumed += info->consumed; if (used) *used += info->consumed; } /* add CA's to certificate manager */ if (type == CA_TYPE) { /* verify CA unless user set to no verify */ ret = AddCA(ctx->cm, &part, WOLFSSL_USER_CA, verify); gotOne = 0; /* don't exit loop for CA type */ } } FreeDer(&part); if (ret == ASN_NO_PEM_HEADER && gotOne) { WOLFSSL_MSG("We got one good cert, so stuff at end ok"); break; } if (ret < 0) { WOLFSSL_MSG(" Error in Cert in Chain"); if (dynamicBuffer) XFREE(chainBuffer, heap, DYNAMIC_TYPE_FILE); return ret; } WOLFSSL_MSG(" Consumed another Cert in Chain"); } WOLFSSL_MSG("Finished Processing Cert Chain"); /* only retain actual size used */ ret = 0; if (idx > 0) { if (ssl) { if (ssl->buffers.weOwnCertChain) { FreeDer(&ssl->buffers.certChain); } ret = AllocDer(&ssl->buffers.certChain, idx, type, heap); if (ret == 0) { XMEMCPY(ssl->buffers.certChain->buffer, chainBuffer, idx); ssl->buffers.weOwnCertChain = 1; } #ifdef WOLFSSL_TLS13 ssl->buffers.certChainCnt = cnt; #endif } else if (ctx) { FreeDer(&ctx->certChain); ret = AllocDer(&ctx->certChain, idx, type, heap); if (ret == 0) { XMEMCPY(ctx->certChain->buffer, chainBuffer, idx); } #ifdef WOLFSSL_TLS13 ctx->certChainCnt = cnt; #endif } } if (dynamicBuffer) XFREE(chainBuffer, heap, DYNAMIC_TYPE_FILE); } return ret; } static int ProcessBufferTryDecode(WOLFSSL_CTX* ctx, WOLFSSL* ssl, DerBuffer* der, int* keySz, word32* idx, int* resetSuites, int* keyFormat, void* heap, int devId) { int ret = 0; (void)heap; (void)devId; if (ctx == NULL && ssl == NULL) ret = BAD_FUNC_ARG; if (!der || !keySz || !idx || !resetSuites || !keyFormat) ret = BAD_FUNC_ARG; #ifndef NO_RSA if (ret == 0 && (*keyFormat == 0 || *keyFormat == RSAk)) { /* make sure RSA key can be used */ #ifdef WOLFSSL_SMALL_STACK RsaKey* key; #else RsaKey key[1]; #endif #ifdef WOLFSSL_SMALL_STACK key = (RsaKey*)XMALLOC(sizeof(RsaKey), heap, DYNAMIC_TYPE_RSA); if (key == NULL) return MEMORY_E; #endif ret = wc_InitRsaKey_ex(key, heap, devId); if (ret == 0) { *idx = 0; if (wc_RsaPrivateKeyDecode(der->buffer, idx, key, der->length) != 0) { #if !defined(HAVE_ECC) && !defined(HAVE_ED25519) && \ !defined(HAVE_ED448) WOLFSSL_MSG("RSA decode failed and ECC/ED25519/ED448 not " "enabled to try"); ret = WOLFSSL_BAD_FILE; #endif } else { /* check that the size of the RSA key is enough */ int minRsaSz = ssl ? ssl->options.minRsaKeySz : ctx->minRsaKeySz; *keySz = wc_RsaEncryptSize((RsaKey*)key); if (*keySz < minRsaSz) { ret = RSA_KEY_SIZE_E; WOLFSSL_MSG("Private Key size too small"); } if (ssl) { ssl->buffers.keyType = rsa_sa_algo; ssl->buffers.keySz = *keySz; } else { ctx->privateKeyType = rsa_sa_algo; ctx->privateKeySz = *keySz; } *keyFormat = RSAk; if (ssl && ssl->options.side == WOLFSSL_SERVER_END) { ssl->options.haveStaticECC = 0; *resetSuites = 1; } } wc_FreeRsaKey(key); } #ifdef WOLFSSL_SMALL_STACK XFREE(key, heap, DYNAMIC_TYPE_RSA); #endif } #endif #ifdef HAVE_ECC if (ret == 0 && (*keyFormat == 0 || *keyFormat == ECDSAk)) { /* make sure ECC key can be used */ #ifdef WOLFSSL_SMALL_STACK ecc_key* key; #else ecc_key key[1]; #endif #ifdef WOLFSSL_SMALL_STACK key = (ecc_key*)XMALLOC(sizeof(ecc_key), heap, DYNAMIC_TYPE_ECC); if (key == NULL) return MEMORY_E; #endif if (wc_ecc_init_ex(key, heap, devId) == 0) { *idx = 0; if (wc_EccPrivateKeyDecode(der->buffer, idx, key, der->length) == 0) { /* check for minimum ECC key size and then free */ int minKeySz = ssl ? ssl->options.minEccKeySz : ctx->minEccKeySz; *keySz = wc_ecc_size(key); if (*keySz < minKeySz) { WOLFSSL_MSG("ECC private key too small"); ret = ECC_KEY_SIZE_E; } *keyFormat = ECDSAk; if (ssl) { ssl->options.haveStaticECC = 1; ssl->buffers.keyType = ecc_dsa_sa_algo; ssl->buffers.keySz = *keySz; } else { ctx->haveStaticECC = 1; ctx->privateKeyType = ecc_dsa_sa_algo; ctx->privateKeySz = *keySz; } if (ssl && ssl->options.side == WOLFSSL_SERVER_END) { *resetSuites = 1; } } wc_ecc_free(key); } #ifdef WOLFSSL_SMALL_STACK XFREE(key, heap, DYNAMIC_TYPE_ECC); #endif } #endif /* HAVE_ECC */ #ifdef HAVE_ED25519 if (ret == 0 && (*keyFormat == 0 || *keyFormat == ED25519k)) { /* make sure Ed25519 key can be used */ #ifdef WOLFSSL_SMALL_STACK ed25519_key* key; #else ed25519_key key[1]; #endif #ifdef WOLFSSL_SMALL_STACK key = (ed25519_key*)XMALLOC(sizeof(ed25519_key), heap, DYNAMIC_TYPE_ED25519); if (key == NULL) return MEMORY_E; #endif ret = wc_ed25519_init(key); if (ret == 0) { *idx = 0; if (wc_Ed25519PrivateKeyDecode(der->buffer, idx, key, der->length) == 0) { /* check for minimum key size and then free */ int minKeySz = ssl ? ssl->options.minEccKeySz : ctx->minEccKeySz; *keySz = ED25519_KEY_SIZE; if (*keySz < minKeySz) { WOLFSSL_MSG("ED25519 private key too small"); ret = ECC_KEY_SIZE_E; } if (ret == 0) { if (ssl) { ssl->buffers.keyType = ed25519_sa_algo; ssl->buffers.keySz = *keySz; } else if (ctx) { ctx->privateKeyType = ed25519_sa_algo; ctx->privateKeySz = *keySz; } *keyFormat = ED25519k; if (ssl && ssl->options.side == WOLFSSL_SERVER_END) { *resetSuites = 1; } } } wc_ed25519_free(key); } #ifdef WOLFSSL_SMALL_STACK XFREE(key, heap, DYNAMIC_TYPE_ED25519); #endif } #endif /* HAVE_ED25519 */ #ifdef HAVE_ED448 if (ret == 0 && (*keyFormat == 0 || *keyFormat == ED448k)) { /* make sure Ed448 key can be used */ #ifdef WOLFSSL_SMALL_STACK ed448_key* key = NULL; #else ed448_key key[1]; #endif #ifdef WOLFSSL_SMALL_STACK key = (ed448_key*)XMALLOC(sizeof(ed448_key), heap, DYNAMIC_TYPE_ED448); if (key == NULL) return MEMORY_E; #endif ret = wc_ed448_init(key); if (ret == 0) { *idx = 0; if (wc_Ed448PrivateKeyDecode(der->buffer, idx, key, der->length) != 0) { ret = WOLFSSL_BAD_FILE; } if (ret == 0) { /* check for minimum key size and then free */ int minKeySz = ssl ? ssl->options.minEccKeySz : ctx->minEccKeySz; *keySz = ED448_KEY_SIZE; if (*keySz < minKeySz) { WOLFSSL_MSG("ED448 private key too small"); ret = ECC_KEY_SIZE_E; } } if (ret == 0) { if (ssl) { ssl->buffers.keyType = ed448_sa_algo; ssl->buffers.keySz = *keySz; } else if (ctx) { ctx->privateKeyType = ed448_sa_algo; ctx->privateKeySz = *keySz; } *keyFormat = ED448k; if (ssl && ssl->options.side == WOLFSSL_SERVER_END) { *resetSuites = 1; } } wc_ed448_free(key); } #ifdef WOLFSSL_SMALL_STACK XFREE(key, heap, DYNAMIC_TYPE_ED448); #endif } #endif /* HAVE_ED448 */ return ret; } /* process the buffer buff, length sz, into ctx of format and type used tracks bytes consumed, userChain specifies a user cert chain to pass during the handshake */ int ProcessBuffer(WOLFSSL_CTX* ctx, const unsigned char* buff, long sz, int format, int type, WOLFSSL* ssl, long* used, int userChain, int verify) { DerBuffer* der = NULL; /* holds DER or RAW (for NTRU) */ int ret = 0; int done = 0; int keyFormat = 0; int resetSuites = 0; void* heap = wolfSSL_CTX_GetHeap(ctx, ssl); int devId = wolfSSL_CTX_GetDevId(ctx, ssl); word32 idx = 0; int keySz = 0; #if (defined(WOLFSSL_ENCRYPTED_KEYS) && !defined(NO_PWDBASED)) || \ defined(HAVE_PKCS8) word32 algId = 0; #endif #ifdef WOLFSSL_SMALL_STACK EncryptedInfo* info = NULL; #else EncryptedInfo info[1]; #endif (void)devId; (void)idx; (void)keySz; if (used) *used = sz; /* used bytes default to sz, PEM chain may shorten*/ /* check args */ if (format != WOLFSSL_FILETYPE_ASN1 && format != WOLFSSL_FILETYPE_PEM && format != WOLFSSL_FILETYPE_RAW) return WOLFSSL_BAD_FILETYPE; if (ctx == NULL && ssl == NULL) return BAD_FUNC_ARG; #ifdef WOLFSSL_SMALL_STACK info = (EncryptedInfo*)XMALLOC(sizeof(EncryptedInfo), heap, DYNAMIC_TYPE_ENCRYPTEDINFO); if (info == NULL) return MEMORY_E; #endif XMEMSET(info, 0, sizeof(EncryptedInfo)); #if defined(WOLFSSL_ENCRYPTED_KEYS) && !defined(NO_PWDBASED) if (ctx) { info->passwd_cb = ctx->passwd_cb; info->passwd_userdata = ctx->passwd_userdata; } #endif if (format == WOLFSSL_FILETYPE_PEM) { #ifdef WOLFSSL_PEM_TO_DER ret = PemToDer(buff, sz, type, &der, heap, info, &keyFormat); #else ret = NOT_COMPILED_IN; #endif } else { /* ASN1 (DER) or RAW (NTRU) */ int length = (int)sz; if (format == WOLFSSL_FILETYPE_ASN1) { /* get length of der (read sequence or octet string) */ word32 inOutIdx = 0; if (GetSequence(buff, &inOutIdx, &length, (word32)sz) >= 0) { length += inOutIdx; /* include leading sequence */ } /* get length using octect string (allowed for private key types) */ else if (type == PRIVATEKEY_TYPE && GetOctetString(buff, &inOutIdx, &length, (word32)sz) >= 0) { length += inOutIdx; /* include leading oct string */ } else { ret = ASN_PARSE_E; } } info->consumed = length; if (ret == 0) { ret = AllocDer(&der, (word32)length, type, heap); if (ret == 0) { XMEMCPY(der->buffer, buff, length); } #ifdef HAVE_PKCS8 /* if private key try and remove PKCS8 header */ if (type == PRIVATEKEY_TYPE) { if ((ret = ToTraditional_ex(der->buffer, der->length, &algId)) > 0) { /* Found PKCS8 header */ /* ToTraditional_ex moves buff and returns adjusted length */ der->length = ret; } ret = 0; /* failures should be ignored */ } #endif } } if (used) { *used = info->consumed; } /* process user chain */ if (ret >= 0) { /* Chain should have server cert first, then intermediates, then root. * First certificate in chain is processed below after ProcessUserChain * and is loaded into ssl->buffers.certificate. * Remainder are processed using ProcessUserChain and are loaded into * ssl->buffers.certChain. */ if (userChain) { ret = ProcessUserChain(ctx, buff, sz, format, type, ssl, used, info, verify); } } /* info is only used for private key with DER or PEM, so free now */ if (ret < 0 || type != PRIVATEKEY_TYPE || format == WOLFSSL_FILETYPE_RAW) { #ifdef WOLFSSL_SMALL_STACK XFREE(info, heap, DYNAMIC_TYPE_ENCRYPTEDINFO); #endif } /* check for error */ if (ret < 0) { FreeDer(&der); done = 1; } if (done == 1) { /* No operation, just skip the next section */ } /* Handle DER owner */ else if (type == CA_TYPE) { if (ctx == NULL) { WOLFSSL_MSG("Need context for CA load"); FreeDer(&der); return BAD_FUNC_ARG; } /* verify CA unless user set to no verify */ ret = AddCA(ctx->cm, &der, WOLFSSL_USER_CA, verify); done = 1; } #ifdef WOLFSSL_TRUST_PEER_CERT else if (type == TRUSTED_PEER_TYPE) { if (ctx == NULL) { WOLFSSL_MSG("Need context for trusted peer cert load"); FreeDer(&der); return BAD_FUNC_ARG; } /* add trusted peer cert */ ret = AddTrustedPeer(ctx->cm, &der, !ctx->verifyNone); done = 1; } #endif /* WOLFSSL_TRUST_PEER_CERT */ else if (type == CERT_TYPE) { if (ssl) { /* Make sure previous is free'd */ if (ssl->buffers.weOwnCert) { FreeDer(&ssl->buffers.certificate); #ifdef KEEP_OUR_CERT FreeX509(ssl->ourCert); if (ssl->ourCert) { XFREE(ssl->ourCert, ssl->heap, DYNAMIC_TYPE_X509); ssl->ourCert = NULL; } #endif } ssl->buffers.certificate = der; #ifdef KEEP_OUR_CERT ssl->keepCert = 1; /* hold cert for ssl lifetime */ #endif ssl->buffers.weOwnCert = 1; } else if (ctx) { FreeDer(&ctx->certificate); /* Make sure previous is free'd */ #ifdef KEEP_OUR_CERT if (ctx->ourCert) { if (ctx->ownOurCert) { FreeX509(ctx->ourCert); XFREE(ctx->ourCert, ctx->heap, DYNAMIC_TYPE_X509); } ctx->ourCert = NULL; } #endif ctx->certificate = der; } } else if (type == PRIVATEKEY_TYPE) { if (ssl) { /* Make sure previous is free'd */ if (ssl->buffers.weOwnKey) { FreeDer(&ssl->buffers.key); } ssl->buffers.key = der; ssl->buffers.weOwnKey = 1; } else if (ctx) { FreeDer(&ctx->privateKey); ctx->privateKey = der; } } else { FreeDer(&der); return WOLFSSL_BAD_CERTTYPE; } if (done == 1) { /* No operation, just skip the next section */ } else if (type == PRIVATEKEY_TYPE && format != WOLFSSL_FILETYPE_RAW) { #if defined(WOLFSSL_ENCRYPTED_KEYS) || defined(HAVE_PKCS8) keyFormat = algId; #endif ret = ProcessBufferTryDecode(ctx, ssl, der, &keySz, &idx, &resetSuites, &keyFormat, heap, devId); #if defined(WOLFSSL_ENCRYPTED_KEYS) && !defined(NO_PWDBASED) /* for WOLFSSL_FILETYPE_PEM, PemToDer manages the decryption */ /* If private key type PKCS8 header wasn't already removed (algoId == 0) */ if ((ret != 0 || keyFormat == 0) && format != WOLFSSL_FILETYPE_PEM && info->passwd_cb && algId == 0) { int passwordSz = NAME_SZ; #ifndef WOLFSSL_SMALL_STACK char password[NAME_SZ]; #else char* password = (char*)XMALLOC(passwordSz, heap, DYNAMIC_TYPE_STRING); if (password == NULL) { #ifdef WOLFSSL_SMALL_STACK XFREE(info, heap, DYNAMIC_TYPE_ENCRYPTEDINFO); #endif FreeDer(&der); return MEMORY_E; } #endif /* get password */ ret = info->passwd_cb(password, passwordSz, PEM_PASS_READ, info->passwd_userdata); if (ret >= 0) { passwordSz = ret; /* PKCS8 decrypt */ ret = ToTraditionalEnc(der->buffer, der->length, password, passwordSz, &algId); if (ret >= 0) { der->length = ret; } /* ignore failures and try parsing as unencrypted */ ForceZero(password, passwordSz); } #ifdef WOLFSSL_SMALL_STACK XFREE(password, heap, DYNAMIC_TYPE_STRING); #endif ret = ProcessBufferTryDecode(ctx, ssl, der, &keySz, &idx, &resetSuites, &keyFormat, heap, devId); } #endif /* WOLFSSL_ENCRYPTED_KEYS && !NO_PWDBASED */ #ifdef WOLFSSL_SMALL_STACK XFREE(info, heap, DYNAMIC_TYPE_ENCRYPTEDINFO); #endif if (ret != 0) return ret; if (keyFormat == 0) return WOLFSSL_BAD_FILE; (void)devId; } else if (type == CERT_TYPE) { #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert; #else DecodedCert cert[1]; #endif #ifdef HAVE_PK_CALLBACKS int keyType = 0; #endif #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), heap, DYNAMIC_TYPE_DCERT); if (cert == NULL) return MEMORY_E; #endif WOLFSSL_MSG("Checking cert signature type"); InitDecodedCert(cert, der->buffer, der->length, heap); if (DecodeToKey(cert, 0) < 0) { WOLFSSL_MSG("Decode to key failed"); FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, heap, DYNAMIC_TYPE_DCERT); #endif return WOLFSSL_BAD_FILE; } if (ssl && ssl->options.side == WOLFSSL_SERVER_END) { resetSuites = 1; } if (ssl && ssl->ctx->haveECDSAsig) { WOLFSSL_MSG("SSL layer setting cert, CTX had ECDSA, turning off"); ssl->options.haveECDSAsig = 0; /* may turn back on next */ } switch (cert->signatureOID) { case CTC_SHAwECDSA: case CTC_SHA256wECDSA: case CTC_SHA384wECDSA: case CTC_SHA512wECDSA: WOLFSSL_MSG("ECDSA cert signature"); if (ssl) ssl->options.haveECDSAsig = 1; else if (ctx) ctx->haveECDSAsig = 1; break; case CTC_ED25519: WOLFSSL_MSG("ED25519 cert signature"); if (ssl) ssl->options.haveECDSAsig = 1; else if (ctx) ctx->haveECDSAsig = 1; break; case CTC_ED448: WOLFSSL_MSG("ED448 cert signature"); if (ssl) ssl->options.haveECDSAsig = 1; else if (ctx) ctx->haveECDSAsig = 1; break; default: WOLFSSL_MSG("Not ECDSA cert signature"); break; } #if defined(HAVE_ECC) || defined(HAVE_ED25519) || defined(HAVE_ED448) if (ssl) { ssl->pkCurveOID = cert->pkCurveOID; #ifndef WC_STRICT_SIG if (cert->keyOID == ECDSAk) { ssl->options.haveECC = 1; } #ifdef HAVE_ED25519 else if (cert->keyOID == ED25519k) { ssl->options.haveECC = 1; } #endif #ifdef HAVE_ED448 else if (cert->keyOID == ED448k) { ssl->options.haveECC = 1; } #endif #else ssl->options.haveECC = ssl->options.haveECDSAsig; #endif } else if (ctx) { ctx->pkCurveOID = cert->pkCurveOID; #ifndef WC_STRICT_SIG if (cert->keyOID == ECDSAk) { ctx->haveECC = 1; } #ifdef HAVE_ED25519 else if (cert->keyOID == ED25519k) { ctx->haveECC = 1; } #endif #ifdef HAVE_ED448 else if (cert->keyOID == ED448k) { ctx->haveECC = 1; } #endif #else ctx->haveECC = ctx->haveECDSAsig; #endif } #endif /* check key size of cert unless specified not to */ switch (cert->keyOID) { #ifndef NO_RSA case RSAk: #ifdef HAVE_PK_CALLBACKS keyType = rsa_sa_algo; #endif #ifdef HAVE_PKCS11 if (ctx) { ctx->privateKeyType = rsa_sa_algo; } else { ssl->buffers.keyType = rsa_sa_algo; } #endif /* Determine RSA key size by parsing public key */ idx = 0; ret = wc_RsaPublicKeyDecode_ex(cert->publicKey, &idx, cert->pubKeySize, NULL, (word32*)&keySz, NULL, NULL); if (ret < 0) break; if (ssl && !ssl->options.verifyNone) { if (ssl->options.minRsaKeySz < 0 || keySz < (int)ssl->options.minRsaKeySz) { ret = RSA_KEY_SIZE_E; WOLFSSL_MSG("Certificate RSA key size too small"); } } else if (ctx && !ctx->verifyNone) { if (ctx->minRsaKeySz < 0 || keySz < (int)ctx->minRsaKeySz) { ret = RSA_KEY_SIZE_E; WOLFSSL_MSG("Certificate RSA key size too small"); } } break; #endif /* !NO_RSA */ #ifdef HAVE_ECC case ECDSAk: #ifdef HAVE_PK_CALLBACKS keyType = ecc_dsa_sa_algo; #endif #ifdef HAVE_PKCS11 if (ctx) { ctx->privateKeyType = ecc_dsa_sa_algo; } else { ssl->buffers.keyType = ecc_dsa_sa_algo; } #endif /* Determine ECC key size based on curve */ keySz = wc_ecc_get_curve_size_from_id( wc_ecc_get_oid(cert->pkCurveOID, NULL, NULL)); if (ssl && !ssl->options.verifyNone) { if (ssl->options.minEccKeySz < 0 || keySz < (int)ssl->options.minEccKeySz) { ret = ECC_KEY_SIZE_E; WOLFSSL_MSG("Certificate ECC key size error"); } } else if (ctx && !ctx->verifyNone) { if (ctx->minEccKeySz < 0 || keySz < (int)ctx->minEccKeySz) { ret = ECC_KEY_SIZE_E; WOLFSSL_MSG("Certificate ECC key size error"); } } break; #endif /* HAVE_ECC */ #ifdef HAVE_ED25519 case ED25519k: #ifdef HAVE_PK_CALLBACKS keyType = ed25519_sa_algo; #endif #ifdef HAVE_PKCS11 if (ctx) { ctx->privateKeyType = ed25519_sa_algo; } else { ssl->buffers.keyType = ed25519_sa_algo; } #endif /* ED25519 is fixed key size */ keySz = ED25519_KEY_SIZE; if (ssl && !ssl->options.verifyNone) { if (ssl->options.minEccKeySz < 0 || keySz < (int)ssl->options.minEccKeySz) { ret = ECC_KEY_SIZE_E; WOLFSSL_MSG("Certificate Ed key size error"); } } else if (ctx && !ctx->verifyNone) { if (ctx->minEccKeySz < 0 || keySz < (int)ctx->minEccKeySz) { ret = ECC_KEY_SIZE_E; WOLFSSL_MSG("Certificate ECC key size error"); } } break; #endif /* HAVE_ED25519 */ #ifdef HAVE_ED448 case ED448k: #ifdef HAVE_PK_CALLBACKS keyType = ed448_sa_algo; #endif #ifdef HAVE_PKCS11 if (ctx) { ctx->privateKeyType = ed448_sa_algo; } else { ssl->buffers.keyType = ed448_sa_algo; } #endif /* ED448 is fixed key size */ keySz = ED448_KEY_SIZE; if (ssl && !ssl->options.verifyNone) { if (ssl->options.minEccKeySz < 0 || keySz < (int)ssl->options.minEccKeySz) { ret = ECC_KEY_SIZE_E; WOLFSSL_MSG("Certificate Ed key size error"); } } else if (ctx && !ctx->verifyNone) { if (ctx->minEccKeySz < 0 || keySz < (int)ctx->minEccKeySz) { ret = ECC_KEY_SIZE_E; WOLFSSL_MSG("Certificate ECC key size error"); } } break; #endif /* HAVE_ED448 */ default: WOLFSSL_MSG("No key size check done on certificate"); break; /* do no check if not a case for the key */ } #ifdef HAVE_PK_CALLBACKS if (ssl && ssl->buffers.keyType == 0) { ssl->buffers.keyType = keyType; ssl->buffers.keySz = keySz; } else if (ctx && ctx->privateKeyType == 0) { ctx->privateKeyType = keyType; ctx->privateKeySz = keySz; } #endif FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, heap, DYNAMIC_TYPE_DCERT); #endif if (ret != 0) { done = 1; } } if (done == 1) { #ifndef NO_WOLFSSL_CM_VERIFY if ((type == CA_TYPE) || (type == CERT_TYPE)) { /* Call to over-ride status */ if ((ctx != NULL) && (ctx->cm != NULL) && (ctx->cm->verifyCallback != NULL)) { ret = CM_VerifyBuffer_ex(ctx->cm, buff, sz, format, (ret == WOLFSSL_SUCCESS ? 0 : ret)); } } #endif /* NO_WOLFSSL_CM_VERIFY */ return ret; } if (ssl && resetSuites) { word16 havePSK = 0; word16 haveRSA = 0; #ifndef NO_PSK if (ssl->options.havePSK) { havePSK = 1; } #endif #ifndef NO_RSA haveRSA = 1; #endif #ifndef NO_CERTS keySz = ssl->buffers.keySz; #endif /* let's reset suites */ InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK, ssl->options.haveDH, ssl->options.haveNTRU, ssl->options.haveECDSAsig, ssl->options.haveECC, ssl->options.haveStaticECC, ssl->options.side); } return WOLFSSL_SUCCESS; } /* CA PEM file for verification, may have multiple/chain certs to process */ static int ProcessChainBuffer(WOLFSSL_CTX* ctx, const unsigned char* buff, long sz, int format, int type, WOLFSSL* ssl, int verify) { long used = 0; int ret = 0; int gotOne = 0; WOLFSSL_MSG("Processing CA PEM file"); while (used < sz) { long consumed = 0; ret = ProcessBuffer(ctx, buff + used, sz - used, format, type, ssl, &consumed, 0, verify); if (ret < 0) { #if defined(WOLFSSL_WPAS) && defined(HAVE_CRL) DerBuffer* der = NULL; EncryptedInfo info; WOLFSSL_MSG("Trying a CRL"); if (PemToDer(buff + used, sz - used, CRL_TYPE, &der, NULL, &info, NULL) == 0) { WOLFSSL_MSG(" Processed a CRL"); wolfSSL_CertManagerLoadCRLBuffer(ctx->cm, der->buffer, der->length, WOLFSSL_FILETYPE_ASN1); FreeDer(&der); used += info.consumed; continue; } #endif if (consumed > 0) { /* Made progress in file */ WOLFSSL_ERROR(ret); WOLFSSL_MSG("CA Parse failed, with progress in file."); WOLFSSL_MSG("Search for other certs in file"); } else { WOLFSSL_MSG("CA Parse failed, no progress in file."); WOLFSSL_MSG("Do not continue search for other certs in file"); break; } } else { WOLFSSL_MSG(" Processed a CA"); gotOne = 1; } used += consumed; } if (gotOne) { WOLFSSL_MSG("Processed at least one valid CA. Other stuff OK"); return WOLFSSL_SUCCESS; } return ret; } static WC_INLINE WOLFSSL_METHOD* cm_pick_method(void) { #ifndef NO_WOLFSSL_CLIENT #if !defined(NO_OLD_TLS) && defined(WOLFSSL_ALLOW_SSLV3) return wolfSSLv3_client_method(); #elif !defined(NO_OLD_TLS) && defined(WOLFSSL_ALLOW_TLSV10) return wolfTLSv1_client_method(); #elif !defined(NO_OLD_TLS) return wolfTLSv1_1_client_method(); #elif !defined(WOLFSSL_NO_TLS12) return wolfTLSv1_2_client_method(); #elif defined(WOLFSSL_TLS13) return wolfTLSv1_3_client_method(); #else return NULL; #endif #elif !defined(NO_WOLFSSL_SERVER) #if !defined(NO_OLD_TLS) && defined(WOLFSSL_ALLOW_SSLV3) return wolfSSLv3_server_method(); #elif !defined(NO_OLD_TLS) && defined(WOLFSSL_ALLOW_TLSV10) return wolfTLSv1_server_method(); #elif !defined(NO_OLD_TLS) return wolfTLSv1_1_server_method(); #elif !defined(WOLFSSL_NO_TLS12) return wolfTLSv1_2_server_method(); #elif defined(WOLFSSL_TLS13) return wolfTLSv1_3_server_method(); #else return NULL; #endif #else return NULL; #endif } /* like load verify locations, 1 for success, < 0 for error */ int wolfSSL_CertManagerLoadCABuffer(WOLFSSL_CERT_MANAGER* cm, const unsigned char* in, long sz, int format) { int ret = WOLFSSL_FATAL_ERROR; WOLFSSL_CTX* tmp; WOLFSSL_ENTER("wolfSSL_CertManagerLoadCABuffer"); if (cm == NULL) { WOLFSSL_MSG("No CertManager error"); return ret; } tmp = wolfSSL_CTX_new(cm_pick_method()); if (tmp == NULL) { WOLFSSL_MSG("CTX new failed"); return ret; } /* for tmp use */ wolfSSL_CertManagerFree(tmp->cm); tmp->cm = cm; ret = wolfSSL_CTX_load_verify_buffer(tmp, in, sz, format); /* don't loose our good one */ tmp->cm = NULL; wolfSSL_CTX_free(tmp); return ret; } #ifdef HAVE_CRL int wolfSSL_CertManagerLoadCRLBuffer(WOLFSSL_CERT_MANAGER* cm, const unsigned char* buff, long sz, int type) { WOLFSSL_ENTER("wolfSSL_CertManagerLoadCRLBuffer"); if (cm == NULL) return BAD_FUNC_ARG; if (cm->crl == NULL) { if (wolfSSL_CertManagerEnableCRL(cm, 0) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Enable CRL failed"); return WOLFSSL_FATAL_ERROR; } } return BufferLoadCRL(cm->crl, buff, sz, type, VERIFY); } int wolfSSL_CertManagerFreeCRL(WOLFSSL_CERT_MANAGER* cm) { WOLFSSL_ENTER("wolfSSL_CertManagerFreeCRL"); if (cm == NULL) return BAD_FUNC_ARG; if (cm->crl != NULL){ FreeCRL(cm->crl, 1); cm->crl = NULL; } return WOLFSSL_SUCCESS; } int wolfSSL_CTX_LoadCRLBuffer(WOLFSSL_CTX* ctx, const unsigned char* buff, long sz, int type) { WOLFSSL_ENTER("wolfSSL_CTX_LoadCRLBuffer"); if (ctx == NULL) return BAD_FUNC_ARG; return wolfSSL_CertManagerLoadCRLBuffer(ctx->cm, buff, sz, type); } int wolfSSL_LoadCRLBuffer(WOLFSSL* ssl, const unsigned char* buff, long sz, int type) { WOLFSSL_ENTER("wolfSSL_LoadCRLBuffer"); if (ssl == NULL || ssl->ctx == NULL) return BAD_FUNC_ARG; return wolfSSL_CertManagerLoadCRLBuffer(ssl->ctx->cm, buff, sz, type); } #endif /* HAVE_CRL */ /* turn on CRL if off and compiled in, set options */ int wolfSSL_CertManagerEnableCRL(WOLFSSL_CERT_MANAGER* cm, int options) { int ret = WOLFSSL_SUCCESS; (void)options; WOLFSSL_ENTER("wolfSSL_CertManagerEnableCRL"); if (cm == NULL) return BAD_FUNC_ARG; #ifdef HAVE_CRL if (cm->crl == NULL) { cm->crl = (WOLFSSL_CRL*)XMALLOC(sizeof(WOLFSSL_CRL), cm->heap, DYNAMIC_TYPE_CRL); if (cm->crl == NULL) return MEMORY_E; if (InitCRL(cm->crl, cm) != 0) { WOLFSSL_MSG("Init CRL failed"); FreeCRL(cm->crl, 1); cm->crl = NULL; return WOLFSSL_FAILURE; } #ifdef HAVE_CRL_IO cm->crl->crlIOCb = EmbedCrlLookup; #endif } cm->crlEnabled = 1; if (options & WOLFSSL_CRL_CHECKALL) cm->crlCheckAll = 1; #else ret = NOT_COMPILED_IN; #endif return ret; } int wolfSSL_CertManagerDisableCRL(WOLFSSL_CERT_MANAGER* cm) { WOLFSSL_ENTER("wolfSSL_CertManagerDisableCRL"); if (cm == NULL) return BAD_FUNC_ARG; cm->crlEnabled = 0; return WOLFSSL_SUCCESS; } #ifndef NO_WOLFSSL_CM_VERIFY void wolfSSL_CertManagerSetVerify(WOLFSSL_CERT_MANAGER* cm, VerifyCallback vc) { WOLFSSL_ENTER("wolfSSL_CertManagerSetVerify"); if (cm == NULL) return; cm->verifyCallback = vc; } #endif /* NO_WOLFSSL_CM_VERIFY */ /* Verify the certificate, WOLFSSL_SUCCESS for ok, < 0 for error */ int CM_VerifyBuffer_ex(WOLFSSL_CERT_MANAGER* cm, const byte* buff, long sz, int format, int err_val) { int ret = 0; DerBuffer* der = NULL; #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert; #else DecodedCert cert[1]; #endif WOLFSSL_ENTER("wolfSSL_CertManagerVerifyBuffer"); #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), cm->heap, DYNAMIC_TYPE_DCERT); if (cert == NULL) return MEMORY_E; #endif if (format == WOLFSSL_FILETYPE_PEM) { #ifdef WOLFSSL_PEM_TO_DER ret = PemToDer(buff, sz, CERT_TYPE, &der, cm->heap, NULL, NULL); if (ret != 0) { FreeDer(&der); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT); #endif return ret; } InitDecodedCert(cert, der->buffer, der->length, cm->heap); #else ret = NOT_COMPILED_IN; #endif } else { InitDecodedCert(cert, (byte*)buff, (word32)sz, cm->heap); } if (ret == 0) ret = ParseCertRelative(cert, CERT_TYPE, 1, cm); #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) /* ret needs to be self-singer error for Qt compat */ if (ret == ASN_NO_SIGNER_E && cert->selfSigned) ret = ASN_SELF_SIGNED_E; #endif #ifdef HAVE_CRL if (ret == 0 && cm->crlEnabled) ret = CheckCertCRL(cm->crl, cert); #endif #ifndef NO_WOLFSSL_CM_VERIFY /* if verify callback has been set */ if (cm->verifyCallback) { buffer certBuf; #ifdef WOLFSSL_SMALL_STACK ProcPeerCertArgs* args; args = (ProcPeerCertArgs*)XMALLOC( sizeof(ProcPeerCertArgs), cm->heap, DYNAMIC_TYPE_TMP_BUFFER); if (args == NULL) { XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT); return MEMORY_E; } #else ProcPeerCertArgs args[1]; #endif certBuf.buffer = (byte*)buff; certBuf.length = (unsigned int)sz; XMEMSET(args, 0, sizeof(ProcPeerCertArgs)); args->totalCerts = 1; args->certs = &certBuf; args->dCert = cert; args->dCertInit = 1; if (err_val != 0) { ret = err_val; } ret = DoVerifyCallback(cm, NULL, ret, args); #ifdef WOLFSSL_SMALL_STACK XFREE(args, cm->heap, DYNAMIC_TYPE_TMP_BUFFER); #endif } #else (void)err_val; #endif FreeDecodedCert(cert); FreeDer(&der); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT); #endif return ret == 0 ? WOLFSSL_SUCCESS : ret; } /* Verify the certificate, WOLFSSL_SUCCESS for ok, < 0 for error */ int wolfSSL_CertManagerVerifyBuffer(WOLFSSL_CERT_MANAGER* cm, const byte* buff, long sz, int format) { return CM_VerifyBuffer_ex(cm, buff, sz, format, 0); } /* turn on OCSP if off and compiled in, set options */ int wolfSSL_CertManagerEnableOCSP(WOLFSSL_CERT_MANAGER* cm, int options) { int ret = WOLFSSL_SUCCESS; (void)options; WOLFSSL_ENTER("wolfSSL_CertManagerEnableOCSP"); if (cm == NULL) return BAD_FUNC_ARG; #ifdef HAVE_OCSP if (cm->ocsp == NULL) { cm->ocsp = (WOLFSSL_OCSP*)XMALLOC(sizeof(WOLFSSL_OCSP), cm->heap, DYNAMIC_TYPE_OCSP); if (cm->ocsp == NULL) return MEMORY_E; if (InitOCSP(cm->ocsp, cm) != 0) { WOLFSSL_MSG("Init OCSP failed"); FreeOCSP(cm->ocsp, 1); cm->ocsp = NULL; return WOLFSSL_FAILURE; } } cm->ocspEnabled = 1; if (options & WOLFSSL_OCSP_URL_OVERRIDE) cm->ocspUseOverrideURL = 1; if (options & WOLFSSL_OCSP_NO_NONCE) cm->ocspSendNonce = 0; else cm->ocspSendNonce = 1; if (options & WOLFSSL_OCSP_CHECKALL) cm->ocspCheckAll = 1; #ifndef WOLFSSL_USER_IO cm->ocspIOCb = EmbedOcspLookup; cm->ocspRespFreeCb = EmbedOcspRespFree; cm->ocspIOCtx = cm->heap; #endif /* WOLFSSL_USER_IO */ #else ret = NOT_COMPILED_IN; #endif return ret; } int wolfSSL_CertManagerDisableOCSP(WOLFSSL_CERT_MANAGER* cm) { WOLFSSL_ENTER("wolfSSL_CertManagerDisableOCSP"); if (cm == NULL) return BAD_FUNC_ARG; cm->ocspEnabled = 0; return WOLFSSL_SUCCESS; } /* turn on OCSP Stapling if off and compiled in, set options */ int wolfSSL_CertManagerEnableOCSPStapling(WOLFSSL_CERT_MANAGER* cm) { int ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_CertManagerEnableOCSPStapling"); if (cm == NULL) return BAD_FUNC_ARG; #if defined(HAVE_CERTIFICATE_STATUS_REQUEST) \ || defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2) #ifndef NO_WOLFSSL_SERVER if (cm->ocsp_stapling == NULL) { cm->ocsp_stapling = (WOLFSSL_OCSP*)XMALLOC(sizeof(WOLFSSL_OCSP), cm->heap, DYNAMIC_TYPE_OCSP); if (cm->ocsp_stapling == NULL) return MEMORY_E; if (InitOCSP(cm->ocsp_stapling, cm) != 0) { WOLFSSL_MSG("Init OCSP failed"); FreeOCSP(cm->ocsp_stapling, 1); cm->ocsp_stapling = NULL; return WOLFSSL_FAILURE; } } #ifndef WOLFSSL_USER_IO cm->ocspIOCb = EmbedOcspLookup; cm->ocspRespFreeCb = EmbedOcspRespFree; cm->ocspIOCtx = cm->heap; #endif /* WOLFSSL_USER_IO */ #endif /* NO_WOLFSSL_SERVER */ cm->ocspStaplingEnabled = 1; #else ret = NOT_COMPILED_IN; #endif return ret; } int wolfSSL_CertManagerDisableOCSPStapling(WOLFSSL_CERT_MANAGER* cm) { int ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_CertManagerDisableOCSPStapling"); if (cm == NULL) return BAD_FUNC_ARG; #if defined(HAVE_CERTIFICATE_STATUS_REQUEST) \ || defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2) cm->ocspStaplingEnabled = 0; #else ret = NOT_COMPILED_IN; #endif return ret; } #ifdef HAVE_OCSP /* check CRL if enabled, WOLFSSL_SUCCESS */ int wolfSSL_CertManagerCheckOCSP(WOLFSSL_CERT_MANAGER* cm, byte* der, int sz) { int ret; #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert = NULL; #else DecodedCert cert[1]; #endif WOLFSSL_ENTER("wolfSSL_CertManagerCheckOCSP"); if (cm == NULL) return BAD_FUNC_ARG; if (cm->ocspEnabled == 0) return WOLFSSL_SUCCESS; #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (cert == NULL) return MEMORY_E; #endif InitDecodedCert(cert, der, sz, NULL); if ((ret = ParseCertRelative(cert, CERT_TYPE, VERIFY_OCSP, cm)) != 0) { WOLFSSL_MSG("ParseCert failed"); } else if ((ret = CheckCertOCSP(cm->ocsp, cert, NULL)) != 0) { WOLFSSL_MSG("CheckCertOCSP failed"); } FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, NULL, DYNAMIC_TYPE_DCERT); #endif return ret == 0 ? WOLFSSL_SUCCESS : ret; } WOLFSSL_API int wolfSSL_CertManagerCheckOCSPResponse(WOLFSSL_CERT_MANAGER *cm, byte *response, int responseSz, buffer *responseBuffer, CertStatus *status, OcspEntry *entry, OcspRequest *ocspRequest) { int ret; WOLFSSL_ENTER("wolfSSL_CertManagerCheckOCSP_Staple"); if (cm == NULL || response == NULL) return BAD_FUNC_ARG; if (cm->ocspEnabled == 0) return WOLFSSL_SUCCESS; ret = CheckOcspResponse(cm->ocsp, response, responseSz, responseBuffer, status, entry, ocspRequest); return ret == 0 ? WOLFSSL_SUCCESS : ret; } int wolfSSL_CertManagerSetOCSPOverrideURL(WOLFSSL_CERT_MANAGER* cm, const char* url) { WOLFSSL_ENTER("wolfSSL_CertManagerSetOCSPOverrideURL"); if (cm == NULL) return BAD_FUNC_ARG; XFREE(cm->ocspOverrideURL, cm->heap, DYNAMIC_TYPE_URL); if (url != NULL) { int urlSz = (int)XSTRLEN(url) + 1; cm->ocspOverrideURL = (char*)XMALLOC(urlSz, cm->heap, DYNAMIC_TYPE_URL); if (cm->ocspOverrideURL != NULL) { XMEMCPY(cm->ocspOverrideURL, url, urlSz); } else return MEMORY_E; } else cm->ocspOverrideURL = NULL; return WOLFSSL_SUCCESS; } int wolfSSL_CertManagerSetOCSP_Cb(WOLFSSL_CERT_MANAGER* cm, CbOCSPIO ioCb, CbOCSPRespFree respFreeCb, void* ioCbCtx) { WOLFSSL_ENTER("wolfSSL_CertManagerSetOCSP_Cb"); if (cm == NULL) return BAD_FUNC_ARG; cm->ocspIOCb = ioCb; cm->ocspRespFreeCb = respFreeCb; cm->ocspIOCtx = ioCbCtx; return WOLFSSL_SUCCESS; } int wolfSSL_EnableOCSP(WOLFSSL* ssl, int options) { WOLFSSL_ENTER("wolfSSL_EnableOCSP"); if (ssl) return wolfSSL_CertManagerEnableOCSP(ssl->ctx->cm, options); else return BAD_FUNC_ARG; } int wolfSSL_DisableOCSP(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_DisableOCSP"); if (ssl) return wolfSSL_CertManagerDisableOCSP(ssl->ctx->cm); else return BAD_FUNC_ARG; } int wolfSSL_EnableOCSPStapling(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_EnableOCSPStapling"); if (ssl) return wolfSSL_CertManagerEnableOCSPStapling(ssl->ctx->cm); else return BAD_FUNC_ARG; } int wolfSSL_DisableOCSPStapling(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_DisableOCSPStapling"); if (ssl) return wolfSSL_CertManagerDisableOCSPStapling(ssl->ctx->cm); else return BAD_FUNC_ARG; } int wolfSSL_SetOCSP_OverrideURL(WOLFSSL* ssl, const char* url) { WOLFSSL_ENTER("wolfSSL_SetOCSP_OverrideURL"); if (ssl) return wolfSSL_CertManagerSetOCSPOverrideURL(ssl->ctx->cm, url); else return BAD_FUNC_ARG; } int wolfSSL_SetOCSP_Cb(WOLFSSL* ssl, CbOCSPIO ioCb, CbOCSPRespFree respFreeCb, void* ioCbCtx) { WOLFSSL_ENTER("wolfSSL_SetOCSP_Cb"); if (ssl) { ssl->ocspIOCtx = ioCbCtx; /* use SSL specific ioCbCtx */ return wolfSSL_CertManagerSetOCSP_Cb(ssl->ctx->cm, ioCb, respFreeCb, NULL); } else return BAD_FUNC_ARG; } int wolfSSL_CTX_EnableOCSP(WOLFSSL_CTX* ctx, int options) { WOLFSSL_ENTER("wolfSSL_CTX_EnableOCSP"); if (ctx) return wolfSSL_CertManagerEnableOCSP(ctx->cm, options); else return BAD_FUNC_ARG; } int wolfSSL_CTX_DisableOCSP(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_DisableOCSP"); if (ctx) return wolfSSL_CertManagerDisableOCSP(ctx->cm); else return BAD_FUNC_ARG; } int wolfSSL_CTX_SetOCSP_OverrideURL(WOLFSSL_CTX* ctx, const char* url) { WOLFSSL_ENTER("wolfSSL_SetOCSP_OverrideURL"); if (ctx) return wolfSSL_CertManagerSetOCSPOverrideURL(ctx->cm, url); else return BAD_FUNC_ARG; } int wolfSSL_CTX_SetOCSP_Cb(WOLFSSL_CTX* ctx, CbOCSPIO ioCb, CbOCSPRespFree respFreeCb, void* ioCbCtx) { WOLFSSL_ENTER("wolfSSL_CTX_SetOCSP_Cb"); if (ctx) return wolfSSL_CertManagerSetOCSP_Cb(ctx->cm, ioCb, respFreeCb, ioCbCtx); else return BAD_FUNC_ARG; } #if defined(HAVE_CERTIFICATE_STATUS_REQUEST) \ || defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2) int wolfSSL_CTX_EnableOCSPStapling(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_EnableOCSPStapling"); if (ctx) return wolfSSL_CertManagerEnableOCSPStapling(ctx->cm); else return BAD_FUNC_ARG; } int wolfSSL_CTX_DisableOCSPStapling(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_DisableOCSPStapling"); if (ctx) return wolfSSL_CertManagerDisableOCSPStapling(ctx->cm); else return BAD_FUNC_ARG; } #endif /* HAVE_CERTIFICATE_STATUS_REQUEST || HAVE_CERTIFICATE_STATUS_REQUEST_V2 */ #endif /* HAVE_OCSP */ /* macro to get verify settings for AddCA */ #define GET_VERIFY_SETTING_CTX(ctx) \ (ctx && ctx->verifyNone ? NO_VERIFY : VERIFY) #define GET_VERIFY_SETTING_SSL(ssl) \ (ssl && ssl->options.verifyNone ? NO_VERIFY : VERIFY) #ifndef NO_FILESYSTEM /* process a file with name fname into ctx of format and type userChain specifies a user certificate chain to pass during handshake */ int ProcessFile(WOLFSSL_CTX* ctx, const char* fname, int format, int type, WOLFSSL* ssl, int userChain, WOLFSSL_CRL* crl, int verify) { #ifdef WOLFSSL_SMALL_STACK byte staticBuffer[1]; /* force heap usage */ #else byte staticBuffer[FILE_BUFFER_SIZE]; #endif byte* myBuffer = staticBuffer; int dynamic = 0; int ret; long sz = 0; XFILE file; void* heapHint = wolfSSL_CTX_GetHeap(ctx, ssl); const char* header = NULL; const char* footer = NULL; (void)crl; (void)heapHint; if (fname == NULL) return WOLFSSL_BAD_FILE; file = XFOPEN(fname, "rb"); if (file == XBADFILE) return WOLFSSL_BAD_FILE; if (XFSEEK(file, 0, XSEEK_END) != 0) { XFCLOSE(file); return WOLFSSL_BAD_FILE; } sz = XFTELL(file); XREWIND(file); if (sz > MAX_WOLFSSL_FILE_SIZE || sz <= 0) { WOLFSSL_MSG("ProcessFile file size error"); XFCLOSE(file); return WOLFSSL_BAD_FILE; } if (sz > (long)sizeof(staticBuffer)) { WOLFSSL_MSG("Getting dynamic buffer"); myBuffer = (byte*)XMALLOC(sz, heapHint, DYNAMIC_TYPE_FILE); if (myBuffer == NULL) { XFCLOSE(file); return WOLFSSL_BAD_FILE; } dynamic = 1; } if ( (ret = (int)XFREAD(myBuffer, 1, sz, file)) != sz) ret = WOLFSSL_BAD_FILE; else { /* Try to detect type by parsing cert header and footer */ if (type == DETECT_CERT_TYPE) { if (wc_PemGetHeaderFooter(CA_TYPE, &header, &footer) == 0 && (XSTRNSTR((char*)myBuffer, header, (int)sz) != NULL)) { type = CA_TYPE; } #ifdef HAVE_CRL else if (wc_PemGetHeaderFooter(CRL_TYPE, &header, &footer) == 0 && (XSTRNSTR((char*)myBuffer, header, (int)sz) != NULL)) { type = CRL_TYPE; } #endif else if (wc_PemGetHeaderFooter(CERT_TYPE, &header, &footer) == 0 && (XSTRNSTR((char*)myBuffer, header, (int)sz) != NULL)) { type = CERT_TYPE; } else { WOLFSSL_MSG("Failed to detect certificate type"); if (dynamic) XFREE(myBuffer, heapHint, DYNAMIC_TYPE_FILE); XFCLOSE(file); return WOLFSSL_BAD_CERTTYPE; } } if ((type == CA_TYPE || type == TRUSTED_PEER_TYPE) && format == WOLFSSL_FILETYPE_PEM) { ret = ProcessChainBuffer(ctx, myBuffer, sz, format, type, ssl, verify); } #ifdef HAVE_CRL else if (type == CRL_TYPE) ret = BufferLoadCRL(crl, myBuffer, sz, format, verify); #endif else ret = ProcessBuffer(ctx, myBuffer, sz, format, type, ssl, NULL, userChain, verify); } XFCLOSE(file); if (dynamic) XFREE(myBuffer, heapHint, DYNAMIC_TYPE_FILE); return ret; } /* loads file then loads each file in path, no c_rehash */ int wolfSSL_CTX_load_verify_locations_ex(WOLFSSL_CTX* ctx, const char* file, const char* path, word32 flags) { int ret = WOLFSSL_SUCCESS; #ifndef NO_WOLFSSL_DIR int fileRet; int successCount = 0; int failCount = 0; #endif int verify; WOLFSSL_MSG("wolfSSL_CTX_load_verify_locations_ex"); if (ctx == NULL || (file == NULL && path == NULL)) { return WOLFSSL_FAILURE; } verify = GET_VERIFY_SETTING_CTX(ctx); if (flags & WOLFSSL_LOAD_FLAG_DATE_ERR_OKAY) verify = VERIFY_SKIP_DATE; if (file) { ret = ProcessFile(ctx, file, WOLFSSL_FILETYPE_PEM, CA_TYPE, NULL, 0, NULL, verify); #ifndef NO_WOLFSSL_DIR if (ret == WOLFSSL_SUCCESS) successCount++; #endif } if (ret == WOLFSSL_SUCCESS && path) { #ifndef NO_WOLFSSL_DIR char* name = NULL; #ifdef WOLFSSL_SMALL_STACK ReadDirCtx* readCtx; readCtx = (ReadDirCtx*)XMALLOC(sizeof(ReadDirCtx), ctx->heap, DYNAMIC_TYPE_DIRCTX); if (readCtx == NULL) return MEMORY_E; #else ReadDirCtx readCtx[1]; #endif /* try to load each regular file in path */ fileRet = wc_ReadDirFirst(readCtx, path, &name); while (fileRet == 0 && name) { WOLFSSL_MSG(name); /* log file name */ ret = ProcessFile(ctx, name, WOLFSSL_FILETYPE_PEM, CA_TYPE, NULL, 0, NULL, verify); if (ret != WOLFSSL_SUCCESS) { /* handle flags for ignoring errors, skipping expired certs or by PEM certificate header error */ if ( (flags & WOLFSSL_LOAD_FLAG_IGNORE_ERR) || ((flags & WOLFSSL_LOAD_FLAG_PEM_CA_ONLY) && (ret == ASN_NO_PEM_HEADER))) { /* Do not fail here if a certificate fails to load, continue to next file */ ret = WOLFSSL_SUCCESS; } else { WOLFSSL_ERROR(ret); WOLFSSL_MSG("Load CA file failed, continuing"); failCount++; } } else { successCount++; } fileRet = wc_ReadDirNext(readCtx, path, &name); } wc_ReadDirClose(readCtx); /* pass directory read failure to response code */ if (fileRet != WC_READDIR_NOFILE) { ret = fileRet; } /* report failure if no files were loaded or there were failures */ else if (successCount == 0 || failCount > 0) { /* use existing error code if exists */ if (ret == WOLFSSL_SUCCESS) ret = WOLFSSL_FAILURE; } else { ret = WOLFSSL_SUCCESS; } #ifdef WOLFSSL_SMALL_STACK XFREE(readCtx, ctx->heap, DYNAMIC_TYPE_DIRCTX); #endif #else ret = NOT_COMPILED_IN; (void)flags; #endif } return ret; } WOLFSSL_ABI int wolfSSL_CTX_load_verify_locations(WOLFSSL_CTX* ctx, const char* file, const char* path) { return wolfSSL_CTX_load_verify_locations_ex(ctx, file, path, WOLFSSL_LOAD_VERIFY_DEFAULT_FLAGS); } #ifdef WOLFSSL_TRUST_PEER_CERT /* Used to specify a peer cert to match when connecting ctx : the ctx structure to load in peer cert file: the string name of cert file type: type of format such as PEM/DER */ int wolfSSL_CTX_trust_peer_cert(WOLFSSL_CTX* ctx, const char* file, int type) { WOLFSSL_ENTER("wolfSSL_CTX_trust_peer_cert"); if (ctx == NULL || file == NULL) { return WOLFSSL_FAILURE; } return ProcessFile(ctx, file, type, TRUSTED_PEER_TYPE, NULL, 0, NULL, GET_VERIFY_SETTING_CTX(ctx)); } #endif /* WOLFSSL_TRUST_PEER_CERT */ /* Verify the certificate, WOLFSSL_SUCCESS for ok, < 0 for error */ int wolfSSL_CertManagerVerify(WOLFSSL_CERT_MANAGER* cm, const char* fname, int format) { int ret = WOLFSSL_FATAL_ERROR; #ifdef WOLFSSL_SMALL_STACK byte staticBuffer[1]; /* force heap usage */ #else byte staticBuffer[FILE_BUFFER_SIZE]; #endif byte* myBuffer = staticBuffer; int dynamic = 0; long sz = 0; XFILE file = XFOPEN(fname, "rb"); WOLFSSL_ENTER("wolfSSL_CertManagerVerify"); if (file == XBADFILE) return WOLFSSL_BAD_FILE; if(XFSEEK(file, 0, XSEEK_END) != 0) { XFCLOSE(file); return WOLFSSL_BAD_FILE; } sz = XFTELL(file); XREWIND(file); if (sz > MAX_WOLFSSL_FILE_SIZE || sz <= 0) { WOLFSSL_MSG("CertManagerVerify file size error"); XFCLOSE(file); return WOLFSSL_BAD_FILE; } if (sz > (long)sizeof(staticBuffer)) { WOLFSSL_MSG("Getting dynamic buffer"); myBuffer = (byte*) XMALLOC(sz, cm->heap, DYNAMIC_TYPE_FILE); if (myBuffer == NULL) { XFCLOSE(file); return WOLFSSL_BAD_FILE; } dynamic = 1; } if ( (ret = (int)XFREAD(myBuffer, 1, sz, file)) != sz) ret = WOLFSSL_BAD_FILE; else ret = wolfSSL_CertManagerVerifyBuffer(cm, myBuffer, sz, format); XFCLOSE(file); if (dynamic) XFREE(myBuffer, cm->heap, DYNAMIC_TYPE_FILE); return ret; } /* like load verify locations, 1 for success, < 0 for error */ int wolfSSL_CertManagerLoadCA(WOLFSSL_CERT_MANAGER* cm, const char* file, const char* path) { int ret = WOLFSSL_FATAL_ERROR; WOLFSSL_CTX* tmp; WOLFSSL_ENTER("wolfSSL_CertManagerLoadCA"); if (cm == NULL) { WOLFSSL_MSG("No CertManager error"); return ret; } tmp = wolfSSL_CTX_new(cm_pick_method()); if (tmp == NULL) { WOLFSSL_MSG("CTX new failed"); return ret; } /* for tmp use */ wolfSSL_CertManagerFree(tmp->cm); tmp->cm = cm; ret = wolfSSL_CTX_load_verify_locations(tmp, file, path); /* don't lose our good one */ tmp->cm = NULL; wolfSSL_CTX_free(tmp); return ret; } #ifndef NO_CHECK_PRIVATE_KEY /* Check private against public in certificate for match * * ctx WOLFSSL_CTX structure to check private key in * * Returns SSL_SUCCESS on good private key and SSL_FAILURE if miss matched. */ int wolfSSL_CTX_check_private_key(const WOLFSSL_CTX* ctx) { #ifdef WOLFSSL_SMALL_STACK DecodedCert* der = NULL; #else DecodedCert der[1]; #endif word32 size; byte* buff; int ret; WOLFSSL_ENTER("wolfSSL_CTX_check_private_key"); if (ctx == NULL) { return WOLFSSL_FAILURE; } #ifndef NO_CERTS #ifdef WOLFSSL_SMALL_STACK der = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (der == NULL) return MEMORY_E; #endif size = ctx->certificate->length; buff = ctx->certificate->buffer; InitDecodedCert(der, buff, size, ctx->heap); if (ParseCertRelative(der, CERT_TYPE, NO_VERIFY, NULL) != 0) { FreeDecodedCert(der); #ifdef WOLFSSL_SMALL_STACK XFREE(der, NULL, DYNAMIC_TYPE_DCERT); #endif return WOLFSSL_FAILURE; } size = ctx->privateKey->length; buff = ctx->privateKey->buffer; ret = wc_CheckPrivateKey(buff, size, der); FreeDecodedCert(der); #ifdef WOLFSSL_SMALL_STACK XFREE(der, NULL, DYNAMIC_TYPE_DCERT); #endif if (ret == 1) { return WOLFSSL_SUCCESS; } else { return WOLFSSL_FAILURE; } #else WOLFSSL_MSG("NO_CERTS is defined, can not check private key"); return WOLFSSL_FAILURE; #endif } #endif /* !NO_CHECK_PRIVATE_KEY */ #ifdef HAVE_CRL /* check CRL if enabled, WOLFSSL_SUCCESS */ int wolfSSL_CertManagerCheckCRL(WOLFSSL_CERT_MANAGER* cm, byte* der, int sz) { int ret = 0; #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert = NULL; #else DecodedCert cert[1]; #endif WOLFSSL_ENTER("wolfSSL_CertManagerCheckCRL"); if (cm == NULL) return BAD_FUNC_ARG; if (cm->crlEnabled == 0) return WOLFSSL_SUCCESS; #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (cert == NULL) return MEMORY_E; #endif InitDecodedCert(cert, der, sz, NULL); if ((ret = ParseCertRelative(cert, CERT_TYPE, VERIFY_CRL, cm)) != 0) { WOLFSSL_MSG("ParseCert failed"); } else if ((ret = CheckCertCRL(cm->crl, cert)) != 0) { WOLFSSL_MSG("CheckCertCRL failed"); } FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, NULL, DYNAMIC_TYPE_DCERT); #endif return ret == 0 ? WOLFSSL_SUCCESS : ret; } int wolfSSL_CertManagerSetCRL_Cb(WOLFSSL_CERT_MANAGER* cm, CbMissingCRL cb) { WOLFSSL_ENTER("wolfSSL_CertManagerSetCRL_Cb"); if (cm == NULL) return BAD_FUNC_ARG; cm->cbMissingCRL = cb; return WOLFSSL_SUCCESS; } #ifdef HAVE_CRL_IO int wolfSSL_CertManagerSetCRL_IOCb(WOLFSSL_CERT_MANAGER* cm, CbCrlIO cb) { if (cm == NULL) return BAD_FUNC_ARG; cm->crl->crlIOCb = cb; return WOLFSSL_SUCCESS; } #endif int wolfSSL_CertManagerLoadCRL(WOLFSSL_CERT_MANAGER* cm, const char* path, int type, int monitor) { WOLFSSL_ENTER("wolfSSL_CertManagerLoadCRL"); if (cm == NULL) return BAD_FUNC_ARG; if (cm->crl == NULL) { if (wolfSSL_CertManagerEnableCRL(cm, 0) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Enable CRL failed"); return WOLFSSL_FATAL_ERROR; } } return LoadCRL(cm->crl, path, type, monitor); } int wolfSSL_EnableCRL(WOLFSSL* ssl, int options) { WOLFSSL_ENTER("wolfSSL_EnableCRL"); if (ssl) return wolfSSL_CertManagerEnableCRL(ssl->ctx->cm, options); else return BAD_FUNC_ARG; } int wolfSSL_DisableCRL(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_DisableCRL"); if (ssl) return wolfSSL_CertManagerDisableCRL(ssl->ctx->cm); else return BAD_FUNC_ARG; } int wolfSSL_LoadCRL(WOLFSSL* ssl, const char* path, int type, int monitor) { WOLFSSL_ENTER("wolfSSL_LoadCRL"); if (ssl) return wolfSSL_CertManagerLoadCRL(ssl->ctx->cm, path, type, monitor); else return BAD_FUNC_ARG; } int wolfSSL_SetCRL_Cb(WOLFSSL* ssl, CbMissingCRL cb) { WOLFSSL_ENTER("wolfSSL_SetCRL_Cb"); if (ssl) return wolfSSL_CertManagerSetCRL_Cb(ssl->ctx->cm, cb); else return BAD_FUNC_ARG; } #ifdef HAVE_CRL_IO int wolfSSL_SetCRL_IOCb(WOLFSSL* ssl, CbCrlIO cb) { WOLFSSL_ENTER("wolfSSL_SetCRL_Cb"); if (ssl) return wolfSSL_CertManagerSetCRL_IOCb(ssl->ctx->cm, cb); else return BAD_FUNC_ARG; } #endif int wolfSSL_CTX_EnableCRL(WOLFSSL_CTX* ctx, int options) { WOLFSSL_ENTER("wolfSSL_CTX_EnableCRL"); if (ctx) return wolfSSL_CertManagerEnableCRL(ctx->cm, options); else return BAD_FUNC_ARG; } int wolfSSL_CTX_DisableCRL(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_DisableCRL"); if (ctx) return wolfSSL_CertManagerDisableCRL(ctx->cm); else return BAD_FUNC_ARG; } int wolfSSL_CTX_LoadCRL(WOLFSSL_CTX* ctx, const char* path, int type, int monitor) { WOLFSSL_ENTER("wolfSSL_CTX_LoadCRL"); if (ctx) return wolfSSL_CertManagerLoadCRL(ctx->cm, path, type, monitor); else return BAD_FUNC_ARG; } int wolfSSL_CTX_SetCRL_Cb(WOLFSSL_CTX* ctx, CbMissingCRL cb) { WOLFSSL_ENTER("wolfSSL_CTX_SetCRL_Cb"); if (ctx) return wolfSSL_CertManagerSetCRL_Cb(ctx->cm, cb); else return BAD_FUNC_ARG; } #ifdef HAVE_CRL_IO int wolfSSL_CTX_SetCRL_IOCb(WOLFSSL_CTX* ctx, CbCrlIO cb) { WOLFSSL_ENTER("wolfSSL_CTX_SetCRL_IOCb"); if (ctx) return wolfSSL_CertManagerSetCRL_IOCb(ctx->cm, cb); else return BAD_FUNC_ARG; } #endif #endif /* HAVE_CRL */ #ifdef WOLFSSL_DER_LOAD /* Add format parameter to allow DER load of CA files */ int wolfSSL_CTX_der_load_verify_locations(WOLFSSL_CTX* ctx, const char* file, int format) { WOLFSSL_ENTER("wolfSSL_CTX_der_load_verify_locations"); if (ctx == NULL || file == NULL) return WOLFSSL_FAILURE; if (ProcessFile(ctx, file, format, CA_TYPE, NULL, 0, NULL, GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } #endif /* WOLFSSL_DER_LOAD */ WOLFSSL_ABI int wolfSSL_CTX_use_certificate_file(WOLFSSL_CTX* ctx, const char* file, int format) { WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_file"); if (ProcessFile(ctx, file, format, CERT_TYPE, NULL, 0, NULL, GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } WOLFSSL_ABI int wolfSSL_CTX_use_PrivateKey_file(WOLFSSL_CTX* ctx, const char* file, int format) { WOLFSSL_ENTER("wolfSSL_CTX_use_PrivateKey_file"); if (ProcessFile(ctx, file, format, PRIVATEKEY_TYPE, NULL, 0, NULL, GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } /* Sets the max chain depth when verifying a certificate chain. Default depth * is set to MAX_CHAIN_DEPTH. * * ctx WOLFSSL_CTX structure to set depth in * depth max depth */ void wolfSSL_CTX_set_verify_depth(WOLFSSL_CTX *ctx, int depth) { WOLFSSL_ENTER("wolfSSL_CTX_set_verify_depth"); if (ctx == NULL || depth < 0 || depth > MAX_CHAIN_DEPTH) { WOLFSSL_MSG("Bad depth argument, too large or less than 0"); return; } ctx->verifyDepth = (byte)depth; } /* get cert chaining depth using ssl struct */ long wolfSSL_get_verify_depth(WOLFSSL* ssl) { if(ssl == NULL) { return BAD_FUNC_ARG; } #ifndef OPENSSL_EXTRA return MAX_CHAIN_DEPTH; #else return ssl->options.verifyDepth; #endif } /* get cert chaining depth using ctx struct */ long wolfSSL_CTX_get_verify_depth(WOLFSSL_CTX* ctx) { if (ctx == NULL) { return BAD_FUNC_ARG; } #ifndef OPENSSL_EXTRA return MAX_CHAIN_DEPTH; #else return ctx->verifyDepth; #endif } WOLFSSL_ABI int wolfSSL_CTX_use_certificate_chain_file(WOLFSSL_CTX* ctx, const char* file) { /* process up to MAX_CHAIN_DEPTH plus subject cert */ WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_chain_file"); if (ProcessFile(ctx, file, WOLFSSL_FILETYPE_PEM, CERT_TYPE, NULL, 1, NULL, GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } int wolfSSL_CTX_use_certificate_chain_file_format(WOLFSSL_CTX* ctx, const char* file, int format) { /* process up to MAX_CHAIN_DEPTH plus subject cert */ WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_chain_file_format"); if (ProcessFile(ctx, file, format, CERT_TYPE, NULL, 1, NULL, GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } #ifndef NO_DH /* server Diffie-Hellman parameters */ static int wolfSSL_SetTmpDH_file_wrapper(WOLFSSL_CTX* ctx, WOLFSSL* ssl, const char* fname, int format) { #ifdef WOLFSSL_SMALL_STACK byte staticBuffer[1]; /* force heap usage */ #else byte staticBuffer[FILE_BUFFER_SIZE]; #endif byte* myBuffer = staticBuffer; int dynamic = 0; int ret; long sz = 0; XFILE file; if (ctx == NULL || fname == NULL) return BAD_FUNC_ARG; file = XFOPEN(fname, "rb"); if (file == XBADFILE) return WOLFSSL_BAD_FILE; if(XFSEEK(file, 0, XSEEK_END) != 0) { XFCLOSE(file); return WOLFSSL_BAD_FILE; } sz = XFTELL(file); XREWIND(file); if (sz > MAX_WOLFSSL_FILE_SIZE || sz <= 0) { WOLFSSL_MSG("SetTmpDH file size error"); XFCLOSE(file); return WOLFSSL_BAD_FILE; } if (sz > (long)sizeof(staticBuffer)) { WOLFSSL_MSG("Getting dynamic buffer"); myBuffer = (byte*) XMALLOC(sz, ctx->heap, DYNAMIC_TYPE_FILE); if (myBuffer == NULL) { XFCLOSE(file); return WOLFSSL_BAD_FILE; } dynamic = 1; } if ( (ret = (int)XFREAD(myBuffer, 1, sz, file)) != sz) ret = WOLFSSL_BAD_FILE; else { if (ssl) ret = wolfSSL_SetTmpDH_buffer(ssl, myBuffer, sz, format); else ret = wolfSSL_CTX_SetTmpDH_buffer(ctx, myBuffer, sz, format); } XFCLOSE(file); if (dynamic) XFREE(myBuffer, ctx->heap, DYNAMIC_TYPE_FILE); return ret; } /* server Diffie-Hellman parameters */ int wolfSSL_SetTmpDH_file(WOLFSSL* ssl, const char* fname, int format) { if (ssl == NULL) return BAD_FUNC_ARG; return wolfSSL_SetTmpDH_file_wrapper(ssl->ctx, ssl, fname, format); } /* server Diffie-Hellman parameters */ int wolfSSL_CTX_SetTmpDH_file(WOLFSSL_CTX* ctx, const char* fname, int format) { return wolfSSL_SetTmpDH_file_wrapper(ctx, NULL, fname, format); } #endif /* NO_DH */ #endif /* NO_FILESYSTEM */ #ifdef OPENSSL_EXTRA /* put SSL type in extra for now, not very common */ /* Converts a DER format key read from "bio" to a PKCS8 structure. * * bio input bio to read DER from * pkey If not NULL then this pointer will be overwritten with a new PKCS8 * structure. * * returns a WOLFSSL_PKCS8_PRIV_KEY_INFO pointer on success and NULL in fail * case. */ WOLFSSL_PKCS8_PRIV_KEY_INFO* wolfSSL_d2i_PKCS8_PKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_PKCS8_PRIV_KEY_INFO** pkey) { WOLFSSL_PKCS8_PRIV_KEY_INFO* pkcs8 = NULL; #ifdef WOLFSSL_PEM_TO_DER unsigned char* mem = NULL; int memSz; int keySz; word32 algId; WOLFSSL_MSG("wolfSSL_d2i_PKCS8_PKEY_bio()"); if (bio == NULL) { return NULL; } if ((memSz = wolfSSL_BIO_get_mem_data(bio, &mem)) < 0) { return NULL; } if ((keySz = wc_KeyPemToDer(mem, memSz, mem, memSz, NULL)) < 0) { WOLFSSL_MSG("Not PEM format"); keySz = memSz; if ((keySz = ToTraditional_ex((byte*)mem, (word32)keySz, &algId)) < 0) { return NULL; } } pkcs8 = wolfSSL_EVP_PKEY_new(); if (pkcs8 == NULL) { return NULL; } pkcs8->pkey.ptr = (char*)XMALLOC(keySz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); if (pkcs8->pkey.ptr == NULL) { wolfSSL_EVP_PKEY_free(pkcs8); return NULL; } XMEMCPY(pkcs8->pkey.ptr, mem, keySz); pkcs8->pkey_sz = keySz; if (pkey != NULL) { *pkey = pkcs8; } #else (void)bio; (void)pkey; #endif /* WOLFSSL_PEM_TO_DER */ return pkcs8; } /* expecting DER format public key * * bio input bio to read DER from * out If not NULL then this pointer will be overwritten with a new * WOLFSSL_EVP_PKEY pointer * * returns a WOLFSSL_EVP_PKEY pointer on success and NULL in fail case. */ WOLFSSL_EVP_PKEY* wolfSSL_d2i_PUBKEY_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY** out) { unsigned char* mem; long memSz; WOLFSSL_EVP_PKEY* pkey = NULL; WOLFSSL_ENTER("wolfSSL_d2i_PUBKEY_bio()"); if (bio == NULL) { return NULL; } (void)out; memSz = wolfSSL_BIO_pending(bio); if (memSz <= 0) { return NULL; } mem = (unsigned char*)XMALLOC(memSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (mem == NULL) { return NULL; } if (wolfSSL_BIO_read(bio, mem, (int)memSz) == memSz) { pkey = wolfSSL_d2i_PUBKEY(NULL, (const unsigned char**)&mem, memSz); if (out != NULL && pkey != NULL) { *out = pkey; } } XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return pkey; } /* Converts a DER encoded public key to a WOLFSSL_EVP_PKEY structure. * * out pointer to new WOLFSSL_EVP_PKEY structure. Can be NULL * in DER buffer to convert * inSz size of in buffer * * returns a pointer to a new WOLFSSL_EVP_PKEY structure on success and NULL * on fail */ WOLFSSL_EVP_PKEY* wolfSSL_d2i_PUBKEY(WOLFSSL_EVP_PKEY** out, const unsigned char** in, long inSz) { WOLFSSL_EVP_PKEY* pkey = NULL; const unsigned char* mem; long memSz = inSz; WOLFSSL_ENTER("wolfSSL_d2i_PUBKEY"); if (in == NULL || inSz < 0) { WOLFSSL_MSG("Bad argument"); return NULL; } mem = *in; #if !defined(NO_RSA) { RsaKey rsa; word32 keyIdx = 0; /* test if RSA key */ if (wc_InitRsaKey(&rsa, NULL) == 0 && wc_RsaPublicKeyDecode(mem, &keyIdx, &rsa, (word32)memSz) == 0) { wc_FreeRsaKey(&rsa); pkey = wolfSSL_EVP_PKEY_new(); if (pkey != NULL) { pkey->pkey_sz = keyIdx; pkey->pkey.ptr = (char*)XMALLOC(memSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); if (pkey->pkey.ptr == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } XMEMCPY(pkey->pkey.ptr, mem, keyIdx); pkey->type = EVP_PKEY_RSA; if (out != NULL) { *out = pkey; } pkey->ownRsa = 1; pkey->rsa = wolfSSL_RSA_new(); if (pkey->rsa == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } if (wolfSSL_RSA_LoadDer_ex(pkey->rsa, (const unsigned char*)pkey->pkey.ptr, pkey->pkey_sz, WOLFSSL_RSA_LOAD_PUBLIC) != 1) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } return pkey; } } wc_FreeRsaKey(&rsa); } #endif /* NO_RSA */ #ifdef HAVE_ECC { word32 keyIdx = 0; ecc_key ecc; if (wc_ecc_init(&ecc) == 0 && wc_EccPublicKeyDecode(mem, &keyIdx, &ecc, (word32)memSz) == 0) { wc_ecc_free(&ecc); pkey = wolfSSL_EVP_PKEY_new(); if (pkey != NULL) { pkey->pkey_sz = keyIdx; pkey->pkey.ptr = (char*)XMALLOC(keyIdx, NULL, DYNAMIC_TYPE_PUBLIC_KEY); if (pkey->pkey.ptr == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } XMEMCPY(pkey->pkey.ptr, mem, keyIdx); pkey->type = EVP_PKEY_EC; if (out != NULL) { *out = pkey; } pkey->ownEcc = 1; pkey->ecc = wolfSSL_EC_KEY_new(); if (pkey->ecc == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } if (wolfSSL_EC_KEY_LoadDer_ex(pkey->ecc, (const unsigned char*)pkey->pkey.ptr, pkey->pkey_sz, WOLFSSL_EC_KEY_LOAD_PUBLIC) != 1) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } return pkey; } } wc_ecc_free(&ecc); } #endif /* HAVE_ECC */ #if !defined(NO_DSA) { DsaKey dsa; word32 keyIdx = 0; /* test if DSA key */ if (wc_InitDsaKey(&dsa) == 0 && wc_DsaPublicKeyDecode(mem, &keyIdx, &dsa, (word32)memSz) == 0) { wc_FreeDsaKey(&dsa); pkey = wolfSSL_EVP_PKEY_new(); if (pkey != NULL) { pkey->pkey_sz = keyIdx; pkey->pkey.ptr = (char*)XMALLOC(memSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); if (pkey->pkey.ptr == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } XMEMCPY(pkey->pkey.ptr, mem, keyIdx); pkey->type = EVP_PKEY_DSA; if (out != NULL) { *out = pkey; } pkey->ownDsa = 1; pkey->dsa = wolfSSL_DSA_new(); if (pkey->dsa == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } if (wolfSSL_DSA_LoadDer_ex(pkey->dsa, (const unsigned char*)pkey->pkey.ptr, pkey->pkey_sz, WOLFSSL_DSA_LOAD_PUBLIC) != 1) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } return pkey; } } wc_FreeDsaKey(&dsa); } #endif /* NO_DSA */ #if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL)) { DhKey dh; word32 keyIdx = 0; /* test if DH key */ if (wc_InitDhKey(&dh) == 0 && wc_DhKeyDecode(mem, &keyIdx, &dh, (word32)memSz) == 0) { wc_FreeDhKey(&dh); pkey = wolfSSL_EVP_PKEY_new(); if (pkey != NULL) { pkey->pkey_sz = (int)memSz; pkey->pkey.ptr = (char*)XMALLOC(memSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); if (pkey->pkey.ptr == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } XMEMCPY(pkey->pkey.ptr, mem, memSz); pkey->type = EVP_PKEY_DH; if (out != NULL) { *out = pkey; } pkey->ownDh = 1; pkey->dh = wolfSSL_DH_new(); if (pkey->dh == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } if (wolfSSL_DH_LoadDer(pkey->dh, (const unsigned char*)pkey->pkey.ptr, pkey->pkey_sz) != WOLFSSL_SUCCESS) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } return pkey; } } wc_FreeDhKey(&dh); } #endif /* !NO_DH && (WOLFSSL_QT || OPENSSL_ALL) */ return pkey; } /* Reads in a DER format key. If PKCS8 headers are found they are stripped off. * * type type of key * out newly created WOLFSSL_EVP_PKEY structure * in pointer to input key DER * inSz size of in buffer * * On success a non null pointer is returned and the pointer in is advanced the * same number of bytes read. */ WOLFSSL_EVP_PKEY* wolfSSL_d2i_PrivateKey(int type, WOLFSSL_EVP_PKEY** out, const unsigned char **in, long inSz) { WOLFSSL_EVP_PKEY* local; word32 idx = 0; int ret; word32 algId; WOLFSSL_ENTER("wolfSSL_d2i_PrivateKey"); if (in == NULL || inSz < 0) { WOLFSSL_MSG("Bad argument"); return NULL; } /* Check if input buffer has PKCS8 header. In the case that it does not * have a PKCS8 header then do not error out. */ if ((ret = ToTraditionalInline_ex((const byte*)(*in), &idx, (word32)inSz, &algId)) > 0) { WOLFSSL_MSG("Found and removed PKCS8 header"); } else { if (ret != ASN_PARSE_E) { WOLFSSL_MSG("Unexpected error with trying to remove PKCS8 header"); return NULL; } } if (out != NULL && *out != NULL) { wolfSSL_EVP_PKEY_free(*out); *out = NULL; } local = wolfSSL_EVP_PKEY_new(); if (local == NULL) { return NULL; } /* sanity check on idx before use */ if ((int)idx > inSz) { WOLFSSL_MSG("Issue with index pointer"); wolfSSL_EVP_PKEY_free(local); local = NULL; return NULL; } local->type = type; local->pkey_sz = (int)inSz - idx; local->pkey.ptr = (char*)XMALLOC(inSz - idx, NULL, DYNAMIC_TYPE_PUBLIC_KEY); if (local->pkey.ptr == NULL) { wolfSSL_EVP_PKEY_free(local); local = NULL; return NULL; } else { XMEMCPY(local->pkey.ptr, *in + idx, inSz - idx); } switch (type) { #ifndef NO_RSA case EVP_PKEY_RSA: local->ownRsa = 1; local->rsa = wolfSSL_RSA_new(); if (local->rsa == NULL) { wolfSSL_EVP_PKEY_free(local); return NULL; } if (wolfSSL_RSA_LoadDer_ex(local->rsa, (const unsigned char*)local->pkey.ptr, local->pkey_sz, WOLFSSL_RSA_LOAD_PRIVATE) != SSL_SUCCESS) { wolfSSL_EVP_PKEY_free(local); return NULL; } break; #endif /* NO_RSA */ #ifdef HAVE_ECC case EVP_PKEY_EC: local->ownEcc = 1; local->ecc = wolfSSL_EC_KEY_new(); if (local->ecc == NULL) { wolfSSL_EVP_PKEY_free(local); return NULL; } if (wolfSSL_EC_KEY_LoadDer(local->ecc, (const unsigned char*)local->pkey.ptr, local->pkey_sz) != SSL_SUCCESS) { wolfSSL_EVP_PKEY_free(local); return NULL; } break; #endif /* HAVE_ECC */ #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) #ifndef NO_DSA case EVP_PKEY_DSA: local->ownDsa = 1; local->dsa = wolfSSL_DSA_new(); if (local->dsa == NULL) { wolfSSL_EVP_PKEY_free(local); return NULL; } if (wolfSSL_DSA_LoadDer(local->dsa, (const unsigned char*)local->pkey.ptr, local->pkey_sz) != SSL_SUCCESS) { wolfSSL_EVP_PKEY_free(local); return NULL; } break; #endif /* NO_DSA */ #ifndef NO_DH case EVP_PKEY_DH: local->ownDh = 1; local->dh = wolfSSL_DH_new(); if (local->dh == NULL) { wolfSSL_EVP_PKEY_free(local); return NULL; } if (wolfSSL_DH_LoadDer(local->dh, (const unsigned char*)local->pkey.ptr, local->pkey_sz) != SSL_SUCCESS) { wolfSSL_EVP_PKEY_free(local); return NULL; } break; #endif /* HAVE_DH */ #endif /* WOLFSSL_QT || OPENSSL_ALL */ default: WOLFSSL_MSG("Unsupported key type"); wolfSSL_EVP_PKEY_free(local); return NULL; } /* advance pointer with success */ if (local != NULL) { if ((idx + local->pkey_sz) <= (word32)inSz) { *in = *in + idx + local->pkey_sz; } if (out != NULL) { *out = local; } } return local; } #ifndef NO_CERTS int wolfSSL_check_private_key(const WOLFSSL* ssl) { DecodedCert der; word32 size; byte* buff; int ret; if (ssl == NULL) { return WOLFSSL_FAILURE; } size = ssl->buffers.certificate->length; buff = ssl->buffers.certificate->buffer; InitDecodedCert(&der, buff, size, ssl->heap); #ifdef HAVE_PK_CALLBACKS ret = InitSigPkCb((WOLFSSL*)ssl, &der.sigCtx); if (ret != 0) { FreeDecodedCert(&der); return ret; } #endif if (ParseCertRelative(&der, CERT_TYPE, NO_VERIFY, NULL) != 0) { FreeDecodedCert(&der); return WOLFSSL_FAILURE; } size = ssl->buffers.key->length; buff = ssl->buffers.key->buffer; ret = wc_CheckPrivateKey(buff, size, &der); FreeDecodedCert(&der); return ret; } #if defined(OPENSSL_ALL) /* Returns the number of X509V3 extensions in X509 object, or 0 on failure */ int wolfSSL_X509_get_ext_count(const WOLFSSL_X509* passedCert) { int extCount = 0; int length = 0; int outSz = 0; const byte* rawCert; int sz = 0; word32 idx = 0; DecodedCert cert; const byte* input; WOLFSSL_ENTER("wolfSSL_X509_get_ext_count()"); if (passedCert == NULL) { WOLFSSL_MSG("\tNot passed a certificate"); return WOLFSSL_FAILURE; } rawCert = wolfSSL_X509_get_der((WOLFSSL_X509*)passedCert, &outSz); if (rawCert == NULL) { WOLFSSL_MSG("\tpassedCert has no internal DerBuffer set."); return WOLFSSL_FAILURE; } InitDecodedCert(&cert, rawCert, (word32)outSz, 0); if (ParseCert(&cert, CA_TYPE, NO_VERIFY, NULL) < 0) { WOLFSSL_MSG("\tCertificate parsing failed"); return WOLFSSL_FAILURE; } input = cert.extensions; sz = cert.extensionsSz; if (input == NULL || sz == 0) { WOLFSSL_MSG("\tsz or input NULL error"); FreeDecodedCert(&cert); return WOLFSSL_FAILURE; } if (input[idx++] != ASN_EXTENSIONS) { WOLFSSL_MSG("\tfail: should be an EXTENSIONS"); FreeDecodedCert(&cert); return WOLFSSL_FAILURE; } if (GetLength(input, &idx, &length, sz) < 0) { WOLFSSL_MSG("\tfail: invalid length"); FreeDecodedCert(&cert); return WOLFSSL_FAILURE; } if (GetSequence(input, &idx, &length, sz) < 0) { WOLFSSL_MSG("\tfail: should be a SEQUENCE (1)"); FreeDecodedCert(&cert); return WOLFSSL_FAILURE; } while (idx < (word32)sz) { if (GetSequence(input, &idx, &length, sz) < 0) { WOLFSSL_MSG("\tfail: should be a SEQUENCE"); FreeDecodedCert(&cert); return WOLFSSL_FAILURE; } idx += length; extCount++; } FreeDecodedCert(&cert); return extCount; } /* Creates and returns pointer to a new X509_EXTENSION object in memory */ WOLFSSL_X509_EXTENSION* wolfSSL_X509_EXTENSION_new(void) { WOLFSSL_ENTER("wolfSSL_X509_EXTENSION_new"); WOLFSSL_X509_EXTENSION* newExt; newExt = (WOLFSSL_X509_EXTENSION*)XMALLOC(sizeof(WOLFSSL_X509_EXTENSION), NULL, DYNAMIC_TYPE_X509_EXT); if (newExt == NULL) return NULL; XMEMSET(newExt, 0, sizeof(WOLFSSL_X509_EXTENSION)); return newExt; } void wolfSSL_X509_EXTENSION_free(WOLFSSL_X509_EXTENSION* x) { WOLFSSL_ASN1_STRING asn1; WOLFSSL_ENTER("wolfSSL_X509_EXTENSION_free"); if (x == NULL) return; if (x->obj != NULL) wolfSSL_ASN1_OBJECT_free(x->obj); asn1 = x->value; if (asn1.length > 0 && asn1.data != NULL && asn1.isDynamic) XFREE(asn1.data, NULL, DYNAMIC_TYPE_OPENSSL); wolfSSL_sk_free(x->ext_sk); XFREE(x, NULL, DYNAMIC_TYPE_X509_EXT); } /* Creates and returns a new WOLFSSL_X509_EXTENSION stack. */ WOLFSSL_STACK* wolfSSL_sk_new_x509_ext(void) { WOLFSSL_STACK* sk; WOLFSSL_ENTER("wolfSSL_sk_new_x509_ext"); sk = wolfSSL_sk_new_null(); if (sk) { sk->type = STACK_TYPE_X509_EXT; } return sk; } /* return 1 on success 0 on fail */ int wolfSSL_sk_X509_EXTENSION_push(WOLFSSL_STACK* sk,WOLFSSL_X509_EXTENSION* ext) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_X509_EXTENSION_push"); if (sk == NULL || ext == NULL) { return WOLFSSL_FAILURE; } /* no previous values in stack */ if (sk->data.ext == NULL) { sk->data.ext = ext; sk->num += 1; return WOLFSSL_SUCCESS; } /* stack already has value(s) create a new node and add more */ node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_X509); if (node == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } XMEMSET(node, 0, sizeof(WOLFSSL_STACK)); /* push new obj onto head of stack */ node->data.ext = sk->data.ext; node->next = sk->next; node->type = sk->type; sk->next = node; sk->data.ext = ext; sk->num += 1; return WOLFSSL_SUCCESS; } /* Free the structure for X509_EXTENSION stack * * sk stack to free nodes in */ void wolfSSL_sk_X509_EXTENSION_free(WOLFSSL_STACK* sk) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_X509_EXTENSION_free"); if (sk == NULL) { return; } /* parse through stack freeing each node */ node = sk->next; while ((node != NULL) && (sk->num > 1)) { WOLFSSL_STACK* tmp = node; node = node->next; wolfSSL_X509_EXTENSION_free(tmp->data.ext); XFREE(tmp, NULL, DYNAMIC_TYPE_X509); sk->num -= 1; } /* free head of stack */ if (sk->num == 1) { wolfSSL_X509_EXTENSION_free(sk->data.ext); } XFREE(sk, NULL, DYNAMIC_TYPE_X509); } int wolfSSL_ASN1_BIT_STRING_set_bit(WOLFSSL_ASN1_BIT_STRING* str, int pos, int val) { int bytes_cnt, bit; byte* temp; if (!str || (val != 0 && val != 1) || pos < 0) { return WOLFSSL_FAILURE; } bytes_cnt = pos/8; bit = 1<<(7-(pos%8)); if (bytes_cnt+1 > str->length) { if (!(temp = (byte*)XREALLOC(str->data, bytes_cnt+1, NULL, DYNAMIC_TYPE_OPENSSL))) { return WOLFSSL_FAILURE; } XMEMSET(temp+str->length, 0, bytes_cnt+1 - str->length); str->data = temp; str->length = bytes_cnt+1; } str->data[bytes_cnt] &= ~bit; str->data[bytes_cnt] |= val ? bit : 0; return WOLFSSL_SUCCESS; } /* Gets the X509_EXTENSION* ext based on it's location in WOLFSSL_X509* x509. * * x509 : The X509 structure to look for the extension. * loc : Location of the extension. If the extension is found at the given * location, a new X509_EXTENSION structure is populated with extension-specific * data based on the extension type. * Returns NULL on error or pointer to X509_EXTENSION structure containing the * extension. The returned X509_EXTENSION should not be free'd by caller. * The returned X509_EXTENSION is pushed onto a stack inside the x509 argument. * This is later free'd when x509 is free'd. * * NOTE: for unknown extension NIDs, a X509_EXTENSION is populated with the * extension oid as the ASN1_OBJECT (QT compatibility) */ WOLFSSL_X509_EXTENSION* wolfSSL_X509_get_ext(const WOLFSSL_X509* x509, int loc) { WOLFSSL_X509_EXTENSION* ext = NULL; WOLFSSL_ENTER("wolfSSL_X509_get_ext"); if (x509 == NULL) return NULL; ext = wolfSSL_X509_set_ext((WOLFSSL_X509*) x509, loc); return ext; } /* Pushes a new X509_EXTENSION* ext onto the stack inside WOLFSSL_X509* x509. * This is currently a helper function for wolfSSL_X509_get_ext * Caller does not free the returned WOLFSSL_X509_EXTENSION* */ WOLFSSL_X509_EXTENSION* wolfSSL_X509_set_ext(WOLFSSL_X509* x509, int loc) { int extCount = 0, length = 0, outSz = 0, sz = 0, ret = 0; int objSz = 0, isSet = 0; const byte* rawCert; const byte* input; byte* oidBuf; word32 oid, idx = 0, tmpIdx = 0; WOLFSSL_X509_EXTENSION* ext = NULL; WOLFSSL_ASN1_INTEGER* a; WOLFSSL_STACK* sk; DecodedCert cert; WOLFSSL_ENTER("wolfSSL_X509_set_ext"); if(x509 == NULL){ WOLFSSL_MSG("\tNot passed a certificate"); return NULL; } if(loc <0 || (loc > wolfSSL_X509_get_ext_count(x509))){ WOLFSSL_MSG("\tBad location argument"); return NULL; } ext = wolfSSL_X509_EXTENSION_new(); if (ext == NULL) { WOLFSSL_MSG("\tX509_EXTENSION_new() failed"); return NULL; } rawCert = wolfSSL_X509_get_der((WOLFSSL_X509*)x509, &outSz); if (rawCert == NULL) { WOLFSSL_MSG("\tX509_get_der() failed"); wolfSSL_X509_EXTENSION_free(ext); return NULL; } InitDecodedCert( &cert, rawCert, (word32)outSz, 0); if (ParseCert(&cert, CA_TYPE, NO_VERIFY, NULL) < 0) { WOLFSSL_MSG("\tCertificate parsing failed"); wolfSSL_X509_EXTENSION_free(ext); return NULL; } input = cert.extensions; sz = cert.extensionsSz; if (input == NULL || sz == 0) { WOLFSSL_MSG("\tfail: should be an EXTENSIONS"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } if (input[idx++] != ASN_EXTENSIONS) { WOLFSSL_MSG("\tfail: should be an EXTENSIONS"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } if (GetLength(input, &idx, &length, sz) < 0) { WOLFSSL_MSG("\tfail: invalid length"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } if (GetSequence(input, &idx, &length, sz) < 0) { WOLFSSL_MSG("\tfail: should be a SEQUENCE (1)"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } while (idx < (word32)sz) { oid = 0; if (GetSequence(input, &idx, &length, sz) < 0) { WOLFSSL_MSG("\tfail: should be a SEQUENCE"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } tmpIdx = idx; ret = GetObjectId(input, &idx, &oid, oidCertExtType, sz); if (ret < 0) { WOLFSSL_MSG("\tfail: OBJECT ID"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } idx = tmpIdx; /* Continue while loop until extCount == loc or idx > sz */ if (extCount != loc) { idx += length; extCount++; continue; } /* extCount == loc. Now get the extension. */ /* Check if extension has been set */ isSet = wolfSSL_X509_ext_isSet_by_NID((WOLFSSL_X509*)x509, oid); ext->obj = wolfSSL_OBJ_nid2obj(oid); if (ext->obj == NULL) { WOLFSSL_MSG("\tfail: Invalid OBJECT"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } ext->obj->nid = oid; switch (oid) { case BASIC_CA_OID: if (!isSet) break; /* Set pathlength */ a = wolfSSL_ASN1_INTEGER_new(); if (a == NULL) { wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } a->length = x509->pathLength; /* Save ASN1_INTEGER in x509 extension */ ext->obj->pathlen = a; ext->obj->ca = x509->isCa; ext->crit = x509->basicConstCrit; break; case AUTH_INFO_OID: if (!isSet) break; /* Create a stack to hold both the caIssuer and ocsp objects in X509_EXTENSION structure */ sk = (WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)*)XMALLOC( sizeof(WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)), NULL, DYNAMIC_TYPE_ASN1); if (sk == NULL) { WOLFSSL_MSG("Failed to malloc stack"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } XMEMSET(sk, 0, sizeof(WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT))); sk->type = STACK_TYPE_OBJ; /* Add CaIssuers object to stack */ if (x509->authInfoCaIssuer != NULL && x509->authInfoCaIssuerSz > 0) { WOLFSSL_ASN1_OBJECT* obj; obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Error creating ASN1 object"); wolfSSL_sk_ASN1_OBJECT_free(sk); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } obj->obj = (byte*)x509->authInfoCaIssuer; obj->objSz = x509->authInfoCaIssuerSz; obj->grp = oidCertAuthInfoType; obj->nid = AIA_CA_ISSUER_OID; ret = wolfSSL_sk_ASN1_OBJECT_push(sk, obj); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error pushing ASN1 object onto stack"); wolfSSL_ASN1_OBJECT_free(obj); wolfSSL_sk_ASN1_OBJECT_free(sk); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } } /* Add OCSP object to stack */ if (x509->authInfo != NULL && x509->authInfoSz > 0) { WOLFSSL_ASN1_OBJECT* obj; obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Error creating ASN1 object"); wolfSSL_sk_ASN1_OBJECT_free(sk); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } obj->obj = x509->authInfo; obj->objSz = x509->authInfoSz; obj->grp = oidCertAuthInfoType; obj->nid = AIA_OCSP_OID; ret = wolfSSL_sk_ASN1_OBJECT_push(sk, obj); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error pushing ASN1 object onto stack"); wolfSSL_ASN1_OBJECT_free(obj); wolfSSL_sk_ASN1_OBJECT_free(sk); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } } ext->ext_sk = sk; ext->crit = x509->authInfoCrit; break; case AUTH_KEY_OID: if (!isSet) break; ret = wolfSSL_ASN1_STRING_set(&ext->value, x509->authKeyId, x509->authKeyIdSz); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ASN1_STRING_set() failed"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } ext->crit = x509->authKeyIdCrit; break; case SUBJ_KEY_OID: if (!isSet) break; ret = wolfSSL_ASN1_STRING_set(&ext->value, x509->subjKeyId, x509->subjKeyIdSz); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ASN1_STRING_set() failed"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } ext->crit = x509->subjKeyIdCrit; break; case CERT_POLICY_OID: if (!isSet) break; ext->crit = x509->certPolicyCrit; break; case KEY_USAGE_OID: if (!isSet) break; ret = wolfSSL_ASN1_STRING_set(&ext->value, (byte*)&(x509->keyUsage), sizeof(word16)); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ASN1_STRING_set() failed"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } ext->crit = x509->keyUsageCrit; break; case EXT_KEY_USAGE_OID: if (!isSet) break; ext->crit = x509->keyUsageCrit; break; case CRL_DIST_OID: if (!isSet) break; ext->crit = x509->CRLdistCrit; break; case ALT_NAMES_OID: { WOLFSSL_GENERAL_NAME* gn = NULL; DNS_entry* dns = NULL; if (!isSet) break; sk = (WOLF_STACK_OF(WOLFSSL_GENERAL_NAME)*)XMALLOC( sizeof(WOLF_STACK_OF(WOLFSSL_GENERAL_NAME)), NULL, DYNAMIC_TYPE_ASN1); if (sk == NULL) { return NULL; } XMEMSET(sk, 0, sizeof(WOLF_STACK_OF(WOLFSSL_GENERAL_NAME))); sk->type = STACK_TYPE_GEN_NAME; if (x509->subjAltNameSet && x509->altNames != NULL) { /* alt names are DNS_entry structs */ dns = x509->altNames; /* Currently only support GEN_DNS type */ while (dns != NULL) { gn = wolfSSL_GENERAL_NAME_new(); if (gn == NULL) { WOLFSSL_MSG("Error creating GENERAL_NAME"); wolfSSL_sk_free(sk); return NULL; } gn->type = dns->type; gn->d.ia5->length = dns->len; if (wolfSSL_ASN1_STRING_set(gn->d.ia5, dns->name, gn->d.ia5->length) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ASN1_STRING_set failed"); wolfSSL_GENERAL_NAME_free(gn); wolfSSL_sk_free(sk); return NULL; } dns = dns->next; /* last dns in list add at end of function */ if (dns != NULL) { if (wolfSSL_sk_GENERAL_NAME_push(sk, gn) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error pushing onto stack"); wolfSSL_GENERAL_NAME_free(gn); wolfSSL_sk_free(sk); sk = NULL; } } } if (wolfSSL_sk_GENERAL_NAME_push(sk,gn) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error pushing onto stack"); wolfSSL_GENERAL_NAME_free(gn); wolfSSL_sk_free(sk); sk = NULL; } } ext->ext_sk = sk; ext->crit = x509->subjAltNameCrit; break; } default: WOLFSSL_MSG("Unknown extension type found, parsing OID"); /* If the extension type is not recognized/supported, set the ASN1_OBJECT in the extension with the parsed oid for access in later function calls */ /* Get OID from input */ if (GetASNObjectId(input, &idx, &length, sz) != 0) { WOLFSSL_MSG("Failed to Get ASN Object Id"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } oidBuf = (byte*)XMALLOC(length+1+MAX_LENGTH_SZ, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (oidBuf == NULL) { WOLFSSL_MSG("Failed to malloc tmp buffer"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } oidBuf[0] = ASN_OBJECT_ID; objSz++; objSz += SetLength(length, oidBuf + 1); objSz += length; /* Set object size and reallocate space in object buffer */ ext->obj->objSz = objSz; if(((ext->obj->dynamic & WOLFSSL_ASN1_DYNAMIC_DATA) != 0) || (ext->obj->obj == NULL)) { ext->obj->obj =(byte*)XREALLOC((byte*)ext->obj->obj, ext->obj->objSz, NULL,DYNAMIC_TYPE_ASN1); if (ext->obj->obj == NULL) { wolfSSL_ASN1_OBJECT_free(ext->obj); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } ext->obj->dynamic |= WOLFSSL_ASN1_DYNAMIC_DATA; } else { ext->obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA; } /* Get OID from input and copy to ASN1_OBJECT buffer */ XMEMCPY(oidBuf+2, input+idx, length); XMEMCPY((byte*)ext->obj->obj, oidBuf, ext->obj->objSz); XFREE(oidBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER); oidBuf = NULL; ext->obj->grp = oidCertExtType; ext->crit = 0; /* Get extension data and copy as ASN1_STRING */ tmpIdx = idx + length; if ((tmpIdx >= (word32)sz) || (input[tmpIdx++] != ASN_OCTET_STRING)) { WOLFSSL_MSG("Error decoding unknown extension data"); wolfSSL_ASN1_OBJECT_free(ext->obj); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } if (GetLength(input, &tmpIdx, &length, sz) <= 0) { WOLFSSL_MSG("Error: Invalid Input Length."); wolfSSL_ASN1_OBJECT_free(ext->obj); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } ext->value.data = (char*)XMALLOC(length, NULL, DYNAMIC_TYPE_ASN1); ext->value.isDynamic = 1; if (ext->value.data == NULL) { WOLFSSL_MSG("Failed to malloc ASN1_STRING data"); wolfSSL_X509_EXTENSION_free(ext); FreeDecodedCert(&cert); return NULL; } XMEMCPY(ext->value.data,input+tmpIdx,length); ext->value.length = length; } /* switch(oid) */ break; /* Got the Extension. Now exit while loop. */ } /* while(idx < sz) */ /* Store the new extension in a stack inside x509 * The extensions on the stack are free'd internally when FreeX509 is called */ if (x509->ext_sk == NULL) x509->ext_sk = wolfSSL_sk_new_x509_ext(); if (x509->ext_sk != NULL) wolfSSL_sk_X509_EXTENSION_push(x509->ext_sk, ext); FreeDecodedCert(&cert); return ext; } /* Return 0 on success and 1 on failure. Copies ext data to bio, using indent * to pad the output. flag is ignored. */ int wolfSSL_X509V3_EXT_print(WOLFSSL_BIO *out, WOLFSSL_X509_EXTENSION *ext, unsigned long flag, int indent) { ASN1_OBJECT* obj; ASN1_STRING* str; int nid; const int sz = CTC_NAME_SIZE*2; int rc = WOLFSSL_FAILURE; char tmp[CTC_NAME_SIZE*2]; WOLFSSL_ENTER("wolfSSL_X509V3_EXT_print"); if ((out == NULL) || (ext == NULL)) { WOLFSSL_MSG("NULL parameter error"); return rc; } obj = wolfSSL_X509_EXTENSION_get_object(ext); if (obj == NULL) { WOLFSSL_MSG("Error getting ASN1_OBJECT from X509_EXTENSION"); return rc; } str = wolfSSL_X509_EXTENSION_get_data(ext); if (obj == NULL) { WOLFSSL_MSG("Error getting ASN1_STRING from X509_EXTENSION"); return rc; } /* Print extension based on the type */ nid = wolfSSL_OBJ_obj2nid(obj); switch (nid) { case BASIC_CA_OID: { char isCa[] = "TRUE"; char notCa[] = "FALSE"; XSNPRINTF(tmp, sz, "%*sCA:%s", indent, "", obj->ca ? isCa : notCa); break; } case ALT_NAMES_OID: { WOLFSSL_STACK* sk; char* val; int len; tmp[0] = '\0'; /* Make sure tmp is null-terminated */ sk = ext->ext_sk; while (sk != NULL) { if (sk->type == STACK_TYPE_GEN_NAME && sk->data.gn) { /* str is GENERAL_NAME for subject alternative name ext */ str = sk->data.gn->d.ia5; len = str->length + 2; /* + 2 for NULL char and "," */ if (len > sz) { WOLFSSL_MSG("len greater than buffer size"); return rc; } val = (char*)XMALLOC(len + indent, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (val == NULL) { WOLFSSL_MSG("Memory error"); return rc; } if (sk->next) XSNPRINTF(val, len, "%*s%s, ", indent, "", str->strData); else XSNPRINTF(val, len, "%*s%s", indent, "", str->strData); XSTRNCAT(tmp, val, len); XFREE(val, NULL, DYNAMIC_TYPE_TMP_BUFFER); } sk = sk->next; } break; } case AUTH_KEY_OID: case SUBJ_KEY_OID: { char* asn1str; asn1str = wolfSSL_i2s_ASN1_STRING(NULL, str); XSNPRINTF(tmp, sz, "%*s%s", indent, "", asn1str); XFREE(asn1str, NULL, DYNAMIC_TYPE_TMP_BUFFER); break; } case AUTH_INFO_OID: case CERT_POLICY_OID: case CRL_DIST_OID: case KEY_USAGE_OID: WOLFSSL_MSG("X509V3_EXT_print not yet implemented for ext type"); break; default: XSNPRINTF(tmp, sz, "%*s%s", indent, "", str->strData); } if (wolfSSL_BIO_write(out, tmp, (int)XSTRLEN(tmp)) == (int)XSTRLEN(tmp)) { rc = WOLFSSL_SUCCESS; } (void) flag; return rc; } /* Returns crit flag in X509_EXTENSION object */ int wolfSSL_X509_EXTENSION_get_critical(const WOLFSSL_X509_EXTENSION* ex) { WOLFSSL_ENTER("wolfSSL_X509_EXTENSION_get_critical"); if (ex == NULL) return BAD_FUNC_ARG; return ex->crit; } /* Creates v3_ext_method for a given X509v3 extension * * ex : The X509_EXTENSION used to create v3_ext_method. If the extension is * not NULL, get the NID of the extension object and populate the * extension type-specific X509V3_EXT_* function(s) in v3_ext_method. * * Returns NULL on error or pointer to the v3_ext_method populated with extension * type-specific X509V3_EXT_* function(s). * * NOTE: NID_subject_key_identifier is currently the only extension implementing * the X509V3_EXT_* functions, as it is the only type called directly by QT. The * other extension types return a pointer to a v3_ext_method struct that contains * only the NID. */ const WOLFSSL_v3_ext_method* wolfSSL_X509V3_EXT_get(WOLFSSL_X509_EXTENSION* ex) { int nid; WOLFSSL_v3_ext_method method; WOLFSSL_ENTER("wolfSSL_X509V3_EXT_get"); if ((ex == NULL) || (ex->obj == NULL)) { WOLFSSL_MSG("Passed an invalid X509_EXTENSION*"); return NULL; } /* Initialize all methods to NULL */ method.d2i = NULL; method.i2v = NULL; method.i2s = NULL; method.i2r = NULL; nid = ex->obj->nid; if (nid <= 0) { WOLFSSL_MSG("Failed to get nid from passed extension object"); return NULL; } switch (nid) { case NID_basic_constraints: break; case NID_subject_key_identifier: method.i2s = (X509V3_EXT_I2S)wolfSSL_i2s_ASN1_STRING; break; case NID_key_usage: WOLFSSL_MSG("i2v function not yet implemented for Key Usage"); break; case NID_authority_key_identifier: WOLFSSL_MSG("i2v function not yet implemented for Auth Key Id"); break; case NID_info_access: WOLFSSL_MSG("i2v function not yet implemented for Info Access"); break; case NID_ext_key_usage: WOLFSSL_MSG("i2v function not yet implemented for Ext Key Usage"); break; case NID_certificate_policies: WOLFSSL_MSG("r2i function not yet implemented for Cert Policies"); break; case NID_crl_distribution_points: WOLFSSL_MSG("r2i function not yet implemented for CRL Dist Points"); break; default: /* If extension type is unknown, return NULL -- QT makes call to X509_EXTENSION_get_data() if there is no v3_ext_method */ WOLFSSL_MSG("X509V3_EXT_get(): Unknown extension type found"); return NULL; } method.ext_nid = nid; ex->ext_method = method; return (const WOLFSSL_v3_ext_method*)&ex->ext_method; } /* Parses and returns an x509v3 extension internal structure. * * ext : The X509_EXTENSION for parsing internal structure. If extension is * not NULL, get the NID of the extension object and create a new * extension-specific internal structure based on the extension type. * * Returns NULL on error or if NID is not found, otherwise returns a pointer to * the extension type-specific X509_EXTENSION internal structure. * Return is expected to be free'd by caller. */ void* wolfSSL_X509V3_EXT_d2i(WOLFSSL_X509_EXTENSION* ext) { const WOLFSSL_v3_ext_method* method; int ret; WOLFSSL_ASN1_OBJECT* object; WOLFSSL_BASIC_CONSTRAINTS* bc; WOLFSSL_AUTHORITY_KEYID* akey; WOLFSSL_ASN1_STRING* asn1String, *newString; WOLFSSL_AUTHORITY_INFO_ACCESS* aia; WOLFSSL_STACK* sk; WOLFSSL_ENTER("wolfSSL_X509V3_EXT_d2i"); if(ext == NULL) { WOLFSSL_MSG("Bad function Argument"); return NULL; } /* extract extension info */ method = wolfSSL_X509V3_EXT_get(ext); if (method == NULL) { WOLFSSL_MSG("wolfSSL_X509V3_EXT_get error"); return NULL; } object = wolfSSL_X509_EXTENSION_get_object(ext); if (object == NULL) { WOLFSSL_MSG("X509_EXTENSION_get_object failed"); return NULL; } /* Return pointer to proper internal structure based on NID */ switch (object->type) { /* basicConstraints */ case (NID_basic_constraints): WOLFSSL_MSG("basicConstraints"); /* Allocate new BASIC_CONSTRAINTS structure */ bc = (WOLFSSL_BASIC_CONSTRAINTS*) XMALLOC(sizeof(WOLFSSL_BASIC_CONSTRAINTS), NULL, DYNAMIC_TYPE_X509_EXT); if (bc == NULL) { WOLFSSL_MSG("Failed to malloc basic constraints"); return NULL; } /* Copy pathlen and CA into BASIC_CONSTRAINTS from object */ bc->ca = object->ca; if (object->pathlen->length > 0) { bc->pathlen = wolfSSL_ASN1_INTEGER_dup(object->pathlen); if (bc->pathlen == NULL) { WOLFSSL_MSG("Failed to duplicate ASN1_INTEGER"); XFREE(bc, NULL, DYNAMIC_TYPE_X509_EXT); return NULL; } } else bc->pathlen = NULL; return bc; /* subjectKeyIdentifier */ case (NID_subject_key_identifier): WOLFSSL_MSG("subjectKeyIdentifier"); asn1String = wolfSSL_X509_EXTENSION_get_data(ext); if (asn1String == NULL) { WOLFSSL_MSG("X509_EXTENSION_get_data() failed"); return NULL; } newString = wolfSSL_ASN1_STRING_new(); if (newString == NULL) { WOLFSSL_MSG("Failed to malloc ASN1_STRING"); return NULL; } ret = wolfSSL_ASN1_STRING_set(newString, asn1String->data, asn1String->length); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ASN1_STRING_set() failed"); wolfSSL_ASN1_STRING_free(newString); return NULL; }; newString->type = asn1String->type; return newString; /* authorityKeyIdentifier */ case (NID_authority_key_identifier): WOLFSSL_MSG("AuthorityKeyIdentifier"); akey = (WOLFSSL_AUTHORITY_KEYID*) XMALLOC(sizeof(WOLFSSL_AUTHORITY_KEYID), NULL, DYNAMIC_TYPE_X509_EXT); if (akey == NULL) { WOLFSSL_MSG("Failed to malloc authority key id"); return NULL; } akey->keyid = wolfSSL_ASN1_STRING_new(); if (akey->keyid == NULL) { WOLFSSL_MSG("ASN1_STRING_new() failed"); wolfSSL_AUTHORITY_KEYID_free(akey); return NULL; } asn1String = wolfSSL_X509_EXTENSION_get_data(ext); if (asn1String == NULL) { WOLFSSL_MSG("X509_EXTENSION_get_data() failed"); wolfSSL_AUTHORITY_KEYID_free(akey); return NULL; } ret = wolfSSL_ASN1_STRING_set(akey->keyid, asn1String->data, asn1String->length); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ASN1_STRING_set() failed"); wolfSSL_AUTHORITY_KEYID_free(akey); return NULL; }; akey->keyid->type = asn1String->type; /* For now, set issuer and serial to NULL. This may need to be updated for future use */ akey->issuer = NULL; akey->serial = NULL; return akey; /* keyUsage */ case (NID_key_usage): WOLFSSL_MSG("keyUsage"); /* This may need to be updated for future use. The i2v method for keyUsage is not currently set. For now, return the ASN1_STRING representation of KeyUsage bit string */ asn1String = wolfSSL_X509_EXTENSION_get_data(ext); if (asn1String == NULL) { WOLFSSL_MSG("X509_EXTENSION_get_data() failed"); return NULL; } newString = wolfSSL_ASN1_STRING_new(); if (newString == NULL) { WOLFSSL_MSG("Failed to malloc ASN1_STRING"); return NULL; } ret = wolfSSL_ASN1_STRING_set(newString, asn1String->data, asn1String->length); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ASN1_STRING_set() failed"); wolfSSL_ASN1_STRING_free(newString); return NULL; }; newString->type = asn1String->type; return newString; /* extKeyUsage */ case (NID_ext_key_usage): WOLFSSL_MSG("extKeyUsage not supported yet"); return NULL; /* certificatePolicies */ case (NID_certificate_policies): WOLFSSL_MSG("certificatePolicies not supported yet"); return NULL; /* cRLDistributionPoints */ case (NID_crl_distribution_points): WOLFSSL_MSG("cRLDistributionPoints not supported yet"); return NULL; /* authorityInfoAccess */ case (NID_info_access): WOLFSSL_MSG("AuthorityInfoAccess"); sk = ext->ext_sk; if (sk == NULL) { WOLFSSL_MSG("ACCESS_DESCRIPTION stack NULL"); return NULL; } /* AUTHORITY_INFO_ACCESS is a stack of ACCESS_DESCRIPTION entries */ aia = wolfSSL_sk_new_null(); if (aia == NULL) { WOLFSSL_MSG("Failed to malloc AUTHORITY_INFO_ACCESS"); return NULL; } aia->type = STACK_TYPE_ACCESS_DESCRIPTION; while (sk) { WOLFSSL_ACCESS_DESCRIPTION* ad; WOLFSSL_ASN1_OBJECT* aiaEntry; if (sk->type != STACK_TYPE_OBJ) { sk = sk->next; continue; } aiaEntry = sk->data.obj; /* ACCESS_DESCRIPTION has two members, method and location. Method: ASN1_OBJECT as either AIA_OCSP_OID or AIA_CA_ISSUER_OID Location: GENERAL_NAME structure containing the URI. */ ad = (WOLFSSL_ACCESS_DESCRIPTION*) XMALLOC(sizeof(WOLFSSL_ACCESS_DESCRIPTION), NULL, DYNAMIC_TYPE_X509_EXT); if (ad == NULL) { WOLFSSL_MSG("Failed to malloc ACCESS_DESCRIPTION"); XFREE(aia, NULL, DYNAMIC_TYPE_X509_EXT); return NULL; } XMEMSET(ad, 0, sizeof(WOLFSSL_ACCESS_DESCRIPTION)); /* Create new ASN1_OBJECT from oid */ ad->method = wolfSSL_OBJ_nid2obj(aiaEntry->nid); if (ad->method == NULL) { WOLFSSL_MSG("OBJ_nid2obj() failed"); XFREE(aia, NULL, DYNAMIC_TYPE_X509_EXT); XFREE(ad, NULL, DYNAMIC_TYPE_X509_EXT); return NULL; } /* Allocate memory for GENERAL NAME */ ad->location = (WOLFSSL_GENERAL_NAME*) XMALLOC(sizeof(WOLFSSL_GENERAL_NAME), NULL, DYNAMIC_TYPE_OPENSSL); if (ad->location == NULL) { WOLFSSL_MSG("Failed to malloc GENERAL_NAME"); wolfSSL_ASN1_OBJECT_free(ad->method); XFREE(aia, NULL, DYNAMIC_TYPE_X509_EXT); XFREE(ad, NULL, DYNAMIC_TYPE_X509_EXT); return NULL; } XMEMSET(ad->location, 0, sizeof(WOLFSSL_GENERAL_NAME)); ad->location->type = GEN_URI; ad->location->d.uniformResourceIdentifier = wolfSSL_ASN1_STRING_new(); /* Set the URI in GENERAL_NAME */ ret = wolfSSL_ASN1_STRING_set( ad->location->d.uniformResourceIdentifier, aiaEntry->obj, aiaEntry->objSz); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ASN1_STRING_set() failed"); wolfSSL_ASN1_OBJECT_free(ad->method); XFREE(aia, NULL, DYNAMIC_TYPE_X509_EXT); XFREE(ad, NULL, DYNAMIC_TYPE_X509_EXT); return NULL; } /* Push to AUTHORITY_INFO_ACCESS stack */ ret = wolfSSL_sk_ACCESS_DESCRIPTION_push(aia, ad); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error pushing ASN1 AD onto stack"); wolfSSL_sk_ACCESS_DESCRIPTION_pop_free(aia, NULL); wolfSSL_ASN1_OBJECT_free(ad->method); XFREE(aia, NULL, DYNAMIC_TYPE_X509_EXT); XFREE(ad, NULL, DYNAMIC_TYPE_X509_EXT); return NULL; } sk = sk->next; } return aia; default: WOLFSSL_MSG("Extension NID not in table, returning NULL"); break; } return NULL; } /* Looks for the extension matching the passed in nid * * x509 : certificate to get parse through for extension. * nid : Extension OID to be found. * lastPos : Start search from extension after lastPos. * Set to -1 to search from index 0. * return >= 0 If successful the extension index is returned. * return -1 If extension is not found or error is encountered. */ int wolfSSL_X509_get_ext_by_NID(const WOLFSSL_X509* x509, int nid, int lastPos) { int extCount = 0, length = 0, outSz = 0, sz = 0, ret = 0; int isSet = 0, found = 0, loc; const byte* rawCert; const byte* input; word32 oid, idx = 0, tmpIdx = 0; DecodedCert cert; WOLFSSL_ENTER("wolfSSL_X509_get_ext_by_NID"); if(x509 == NULL){ WOLFSSL_MSG("\tNot passed a certificate"); return WOLFSSL_FATAL_ERROR; } if(lastPos < -1 || (lastPos > (wolfSSL_X509_get_ext_count(x509) - 1))){ WOLFSSL_MSG("\tBad location argument"); return WOLFSSL_FATAL_ERROR; } loc = lastPos + 1; rawCert = wolfSSL_X509_get_der((WOLFSSL_X509*)x509, &outSz); if (rawCert == NULL) { WOLFSSL_MSG("\tX509_get_der() failed"); return WOLFSSL_FATAL_ERROR; } InitDecodedCert( &cert, rawCert, (word32)outSz, 0); if (ParseCert(&cert, CA_TYPE, NO_VERIFY, NULL) < 0) { WOLFSSL_MSG("\tCertificate parsing failed"); return WOLFSSL_FATAL_ERROR; } input = cert.extensions; sz = cert.extensionsSz; if (input == NULL || sz == 0) { WOLFSSL_MSG("\tfail: should be an EXTENSIONS"); FreeDecodedCert(&cert); return WOLFSSL_FATAL_ERROR; } if (input[idx++] != ASN_EXTENSIONS) { WOLFSSL_MSG("\tfail: should be an EXTENSIONS"); FreeDecodedCert(&cert); return WOLFSSL_FATAL_ERROR; } if (GetLength(input, &idx, &length, sz) < 0) { WOLFSSL_MSG("\tfail: invalid length"); FreeDecodedCert(&cert); return WOLFSSL_FATAL_ERROR; } if (GetSequence(input, &idx, &length, sz) < 0) { WOLFSSL_MSG("\tfail: should be a SEQUENCE (1)"); FreeDecodedCert(&cert); return WOLFSSL_FATAL_ERROR; } while (idx < (word32)sz) { oid = 0; if (GetSequence(input, &idx, &length, sz) < 0) { WOLFSSL_MSG("\tfail: should be a SEQUENCE"); FreeDecodedCert(&cert); return WOLFSSL_FATAL_ERROR; } tmpIdx = idx; ret = GetObjectId(input, &idx, &oid, oidCertExtType, sz); if (ret < 0) { WOLFSSL_MSG("\tfail: OBJECT ID"); FreeDecodedCert(&cert); return WOLFSSL_FATAL_ERROR; } idx = tmpIdx; if (extCount >= loc) { /* extCount >= loc. Now check if extension has been set */ isSet = wolfSSL_X509_ext_isSet_by_NID((WOLFSSL_X509*)x509, oid); if (isSet && ((word32)nid == oid)) { found = 1; break; } } idx += length; extCount++; } /* while(idx < sz) */ FreeDecodedCert(&cert); return found ? extCount : WOLFSSL_FATAL_ERROR; } #endif /* OPENSSL_ALL */ WOLFSSL_ASN1_BIT_STRING* wolfSSL_ASN1_BIT_STRING_new(void) { WOLFSSL_ASN1_BIT_STRING* str; str = (WOLFSSL_ASN1_BIT_STRING*)XMALLOC(sizeof(WOLFSSL_ASN1_BIT_STRING), NULL, DYNAMIC_TYPE_OPENSSL); if (str) { XMEMSET(str, 0, sizeof(WOLFSSL_ASN1_BIT_STRING)); } return str; } void wolfSSL_ASN1_BIT_STRING_free(WOLFSSL_ASN1_BIT_STRING* str) { if (str) { if (str->data) { XFREE(str->data, NULL, DYNAMIC_TYPE_OPENSSL); str->data = NULL; } XFREE(str, NULL, DYNAMIC_TYPE_OPENSSL); } } int wolfSSL_ASN1_BIT_STRING_get_bit(const WOLFSSL_ASN1_BIT_STRING* str, int i) { if (!str || !str->data || str->length <= (i/8) || i < 0) { return WOLFSSL_FAILURE; } return (str->data[i/8] & (1<<(7-(i%8)))) ? 1 : 0; } /* Looks for the extension matching the passed in nid * * c : if not null then is set to status value -2 if multiple occurrences * of the extension are found, -1 if not found, 0 if found and not * critical, and 1 if found and critical. * nid : Extension OID to be found. * idx : if NULL return first extension found match, otherwise start search at * idx location and set idx to the location of extension returned. * returns NULL or a pointer to an WOLFSSL_ASN1_BIT_STRING (for KEY_USAGE_OID) * or WOLFSSL_STACK (for other) * holding extension structure * * NOTE code for decoding extensions is in asn.c DecodeCertExtensions -- * use already decoded extension in this function to avoid decoding twice. * Currently we do not make use of idx since getting pre decoded extensions. */ void* wolfSSL_X509_get_ext_d2i(const WOLFSSL_X509* x509, int nid, int* c, int* idx) { void* ret = NULL; WOLFSSL_STACK* sk = NULL; WOLFSSL_ASN1_OBJECT* obj = NULL; WOLFSSL_GENERAL_NAME* gn = NULL; WOLFSSL_ENTER("wolfSSL_X509_get_ext_d2i"); if (x509 == NULL) { return NULL; } if (c != NULL) { *c = -1; /* default to not found */ } switch (nid) { case BASIC_CA_OID: if (x509->basicConstSet) { obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); return NULL; } if (c != NULL) { *c = x509->basicConstCrit; } obj->type = BASIC_CA_OID; obj->grp = oidCertExtType; obj->nid = nid; obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) || \ defined(WOLFSSL_APACHE_HTTPD) obj->ca = x509->isCa; #endif } else { WOLFSSL_MSG("No Basic Constraint set"); } return obj; case ALT_NAMES_OID: { DNS_entry* dns = NULL; /* Malloc GENERAL_NAME stack */ sk = (WOLF_STACK_OF(WOLFSSL_GENERAL_NAME)*)XMALLOC( sizeof(WOLF_STACK_OF(WOLFSSL_GENERAL_NAME)), NULL, DYNAMIC_TYPE_ASN1); if (sk == NULL) { return NULL; } XMEMSET(sk, 0, sizeof(WOLF_STACK_OF(WOLFSSL_GENERAL_NAME))); sk->type = STACK_TYPE_GEN_NAME; if (x509->subjAltNameSet && x509->altNames != NULL) { /* alt names are DNS_entry structs */ if (c != NULL) { if (x509->altNames->next != NULL) { *c = -2; /* more then one found */ } else { *c = x509->subjAltNameCrit; } } dns = x509->altNames; /* Currently only support GEN_DNS type */ while (dns != NULL) { gn = wolfSSL_GENERAL_NAME_new(); if (gn == NULL) { WOLFSSL_MSG("Error creating GENERAL_NAME"); wolfSSL_sk_free(sk); return NULL; } gn->type = dns->type; gn->d.ia5->length = dns->len; if (wolfSSL_ASN1_STRING_set(gn->d.ia5, dns->name, gn->d.ia5->length) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ASN1_STRING_set failed"); wolfSSL_GENERAL_NAME_free(gn); wolfSSL_sk_free(sk); return NULL; } dns = dns->next; /* last dns in list add at end of function */ if (dns != NULL) { if (wolfSSL_sk_GENERAL_NAME_push(sk, gn) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error pushing ASN1 object onto stack"); wolfSSL_GENERAL_NAME_free(gn); wolfSSL_sk_free(sk); sk = NULL; } } } } else { WOLFSSL_MSG("No Alt Names set"); } break; } case CRL_DIST_OID: if (x509->CRLdistSet && x509->CRLInfo != NULL) { if (c != NULL) { *c = x509->CRLdistCrit; } obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); return NULL; } obj->type = CRL_DIST_OID; obj->grp = oidCertExtType; obj->obj = x509->CRLInfo; obj->objSz = x509->CRLInfoSz; obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA ; } else { WOLFSSL_MSG("No CRL dist set"); } break; case AUTH_INFO_OID: if (x509->authInfoSet && x509->authInfo != NULL) { if (c != NULL) { *c = x509->authInfoCrit; } obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); return NULL; } obj->type = AUTH_INFO_OID; obj->grp = oidCertExtType; obj->obj = x509->authInfo; obj->objSz = x509->authInfoSz; obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA; } else { WOLFSSL_MSG("No Auth Info set"); } break; case AUTH_KEY_OID: if (x509->authKeyIdSet) { if (c != NULL) { *c = x509->authKeyIdCrit; } obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); return NULL; } obj->type = AUTH_KEY_OID; obj->grp = oidCertExtType; obj->obj = x509->authKeyId; obj->objSz = x509->authKeyIdSz; obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA; } else { WOLFSSL_MSG("No Auth Key set"); } break; case SUBJ_KEY_OID: if (x509->subjKeyIdSet) { if (c != NULL) { *c = x509->subjKeyIdCrit; } obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); return NULL; } obj->type = SUBJ_KEY_OID; obj->grp = oidCertExtType; obj->obj = x509->subjKeyId; obj->objSz = x509->subjKeyIdSz; obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA; } else { WOLFSSL_MSG("No Subject Key set"); } break; case CERT_POLICY_OID: { #ifdef WOLFSSL_CERT_EXT int i; if (x509->certPoliciesNb > 0) { if (c != NULL) { if (x509->certPoliciesNb > 1) { *c = -2; } else { *c = 0; } } sk = wolfSSL_sk_new_asn1_obj(); if (sk == NULL) { return NULL; } for (i = 0; i < x509->certPoliciesNb - 1; i++) { obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); wolfSSL_sk_ASN1_OBJECT_free(sk); return NULL; } obj->type = CERT_POLICY_OID; obj->grp = oidCertExtType; obj->obj = (byte*)(x509->certPolicies[i]); obj->objSz = MAX_CERTPOL_SZ; obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA; if (wolfSSL_sk_ASN1_OBJECT_push(sk, obj) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error pushing ASN1 object onto stack"); wolfSSL_ASN1_OBJECT_free(obj); wolfSSL_sk_ASN1_OBJECT_free(sk); sk = NULL; } } obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); wolfSSL_sk_ASN1_OBJECT_free(sk); return NULL; } obj->type = CERT_POLICY_OID; obj->grp = oidCertExtType; obj->obj = (byte*)(x509->certPolicies[i]); obj->objSz = MAX_CERTPOL_SZ; obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA; } else { WOLFSSL_MSG("No Cert Policy set"); } #elif defined(WOLFSSL_SEP) if (x509->certPolicySet) { if (c != NULL) { *c = x509->certPolicyCrit; } obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); return NULL; } obj->type = CERT_POLICY_OID; obj->grp = oidCertExtType; obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; } else { WOLFSSL_MSG("No Cert Policy set"); } #else WOLFSSL_MSG("wolfSSL not built with WOLFSSL_SEP or WOLFSSL_CERT_EXT"); #endif break; } case KEY_USAGE_OID: { WOLFSSL_ASN1_BIT_STRING* bit_str = NULL; if (x509->keyUsageSet) { if (c != NULL) { *c = x509->keyUsageCrit; } bit_str = wolfSSL_ASN1_BIT_STRING_new(); if (bit_str == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_BIT_STRING struct"); return NULL; } bit_str->type = KEY_USAGE_OID; bit_str->flags = 0; bit_str->length = sizeof(word16); bit_str->data = (byte*)XMALLOC(bit_str->length, NULL, DYNAMIC_TYPE_OPENSSL); if (bit_str->data == NULL) { wolfSSL_ASN1_BIT_STRING_free(bit_str); return NULL; } XMEMCPY(bit_str->data, &x509->keyUsage, bit_str->length); } else { WOLFSSL_MSG("No Key Usage set"); } /* don't add stack of and return bit string directly */ return bit_str; } case INHIBIT_ANY_OID: WOLFSSL_MSG("INHIBIT ANY extension not supported"); break; case EXT_KEY_USAGE_OID: if (x509->extKeyUsageSrc != NULL) { if (c != NULL) { if (x509->extKeyUsageCount > 1) { *c = -2; } else { *c = x509->extKeyUsageCrit; } } obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); return NULL; } obj->type = EXT_KEY_USAGE_OID; obj->grp = oidCertExtType; obj->obj = x509->extKeyUsageSrc; obj->objSz = x509->extKeyUsageSz; obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA; } else { WOLFSSL_MSG("No Extended Key Usage set"); } break; case NAME_CONS_OID: WOLFSSL_MSG("Name Constraint OID extension not supported"); break; case PRIV_KEY_USAGE_PERIOD_OID: WOLFSSL_MSG("Private Key Usage Period extension not supported"); break; case SUBJECT_INFO_ACCESS: WOLFSSL_MSG("Subject Info Access extension not supported"); break; case POLICY_MAP_OID: WOLFSSL_MSG("Policy Map extension not supported"); break; case POLICY_CONST_OID: WOLFSSL_MSG("Policy Constraint extension not supported"); break; case ISSUE_ALT_NAMES_OID: WOLFSSL_MSG("Issue Alt Names extension not supported"); break; case TLS_FEATURE_OID: WOLFSSL_MSG("TLS Feature extension not supported"); break; default: WOLFSSL_MSG("Unsupported/Unknown extension OID"); } /* make sure stack of is allocated */ if ((obj || gn) && sk == NULL) { sk = wolfSSL_sk_new_asn1_obj(); if (sk == NULL) { goto err; } } if (obj && wolfSSL_sk_ASN1_OBJECT_push(sk, obj) == WOLFSSL_SUCCESS) { /* obj pushed successfully on stack */ } else if (gn && wolfSSL_sk_GENERAL_NAME_push(sk, gn) == WOLFSSL_SUCCESS) { /* gn pushed successfully on stack */ } else { /* Nothing to push or push failed */ WOLFSSL_MSG("Error pushing ASN1_OBJECT or GENERAL_NAME object onto stack " "or nothing to push."); goto err; } ret = sk; (void)idx; return ret; err: if (obj) { wolfSSL_ASN1_OBJECT_free(obj); } if (gn) { wolfSSL_GENERAL_NAME_free(gn); } if (sk) { wolfSSL_sk_ASN1_OBJECT_free(sk); } return NULL; } int wolfSSL_X509_add_altname(WOLFSSL_X509* x509, const char* name, int type) { DNS_entry* newAltName = NULL; char* nameCopy = NULL; word32 nameSz; if (x509 == NULL) return WOLFSSL_FAILURE; if (name == NULL) return WOLFSSL_SUCCESS; nameSz = (word32)XSTRLEN(name); if (nameSz == 0) return WOLFSSL_SUCCESS; newAltName = (DNS_entry*)XMALLOC(sizeof(DNS_entry), x509->heap, DYNAMIC_TYPE_ALTNAME); if (newAltName == NULL) return WOLFSSL_FAILURE; nameCopy = (char*)XMALLOC(nameSz + 1, x509->heap, DYNAMIC_TYPE_ALTNAME); if (nameCopy == NULL) { XFREE(newAltName, x509->heap, DYNAMIC_TYPE_ALTNAME); return WOLFSSL_FAILURE; } XMEMCPY(nameCopy, name, nameSz + 1); newAltName->next = x509->altNames; newAltName->type = type; newAltName->len = nameSz; newAltName->name = nameCopy; x509->altNames = newAltName; return WOLFSSL_SUCCESS; } #ifndef NO_WOLFSSL_STUB int wolfSSL_X509_add_ext(WOLFSSL_X509 *x509, WOLFSSL_X509_EXTENSION *ext, int loc) { WOLFSSL_STUB("wolfSSL_X509_add_ext"); (void)x509; (void)ext; (void)loc; return WOLFSSL_FAILURE; } /* currently LHASH is not implemented (and not needed for Apache port) */ WOLFSSL_X509_EXTENSION* wolfSSL_X509V3_EXT_conf_nid( WOLF_LHASH_OF(CONF_VALUE)* conf, WOLFSSL_X509V3_CTX* ctx, int nid, char* value) { WOLFSSL_STUB("wolfSSL_X509V3_EXT_conf_nid"); if (conf != NULL) { WOLFSSL_MSG("Handling LHASH not implemented yet"); return NULL; } (void)conf; (void)ctx; (void)nid; (void)value; return NULL; } void wolfSSL_X509V3_set_ctx_nodb(WOLFSSL_X509V3_CTX* ctx) { WOLFSSL_STUB("wolfSSL_X509V3_set_ctx_nodb"); (void)ctx; } #endif /* !NO_WOLFSSL_STUB */ /* Returns pointer to ASN1_OBJECT from an X509_EXTENSION object */ WOLFSSL_ASN1_OBJECT* wolfSSL_X509_EXTENSION_get_object \ (WOLFSSL_X509_EXTENSION* ext) { WOLFSSL_ENTER("wolfSSL_X509_EXTENSION_get_object"); if(ext == NULL) return NULL; return ext->obj; } /* Returns pointer to ASN1_STRING in X509_EXTENSION object */ WOLFSSL_ASN1_STRING* wolfSSL_X509_EXTENSION_get_data(WOLFSSL_X509_EXTENSION* ext) { WOLFSSL_ENTER("wolfSSL_X509_EXTENSION_get_data"); if (ext == NULL) return NULL; return &ext->value; } #if !defined(NO_PWDBASED) int wolfSSL_X509_digest(const WOLFSSL_X509* x509, const WOLFSSL_EVP_MD* digest, unsigned char* buf, unsigned int* len) { int ret; WOLFSSL_ENTER("wolfSSL_X509_digest"); if (x509 == NULL || digest == NULL) { WOLFSSL_MSG("Null argument found"); return WOLFSSL_FAILURE; } if (x509->derCert == NULL) { WOLFSSL_MSG("No DER certificate stored in X509"); return WOLFSSL_FAILURE; } ret = wolfSSL_EVP_Digest(x509->derCert->buffer, x509->derCert->length, buf, len, digest, NULL); WOLFSSL_LEAVE("wolfSSL_X509_digest", ret); return ret; } #endif int wolfSSL_use_PrivateKey(WOLFSSL* ssl, WOLFSSL_EVP_PKEY* pkey) { WOLFSSL_ENTER("wolfSSL_use_PrivateKey"); if (ssl == NULL || pkey == NULL ) { return WOLFSSL_FAILURE; } return wolfSSL_use_PrivateKey_buffer(ssl, (unsigned char*)pkey->pkey.ptr, pkey->pkey_sz, WOLFSSL_FILETYPE_ASN1); } int wolfSSL_use_PrivateKey_ASN1(int pri, WOLFSSL* ssl, const unsigned char* der, long derSz) { WOLFSSL_ENTER("wolfSSL_use_PrivateKey_ASN1"); if (ssl == NULL || der == NULL ) { return WOLFSSL_FAILURE; } (void)pri; /* type of private key */ return wolfSSL_use_PrivateKey_buffer(ssl, der, derSz, WOLFSSL_FILETYPE_ASN1); } /****************************************************************************** * wolfSSL_CTX_use_PrivateKey_ASN1 - loads a private key buffer into the SSL ctx * * RETURNS: * returns WOLFSSL_SUCCESS on success, otherwise returns WOLFSSL_FAILURE */ int wolfSSL_CTX_use_PrivateKey_ASN1(int pri, WOLFSSL_CTX* ctx, unsigned char* der, long derSz) { WOLFSSL_ENTER("wolfSSL_CTX_use_PrivateKey_ASN1"); if (ctx == NULL || der == NULL ) { return WOLFSSL_FAILURE; } (void)pri; /* type of private key */ return wolfSSL_CTX_use_PrivateKey_buffer(ctx, der, derSz, WOLFSSL_FILETYPE_ASN1); } #ifndef NO_RSA int wolfSSL_use_RSAPrivateKey_ASN1(WOLFSSL* ssl, unsigned char* der, long derSz) { WOLFSSL_ENTER("wolfSSL_use_RSAPrivateKey_ASN1"); if (ssl == NULL || der == NULL ) { return WOLFSSL_FAILURE; } return wolfSSL_use_PrivateKey_buffer(ssl, der, derSz, WOLFSSL_FILETYPE_ASN1); } #endif int wolfSSL_use_certificate(WOLFSSL* ssl, WOLFSSL_X509* x509) { long idx; WOLFSSL_ENTER("wolfSSL_use_certificate"); if (x509 != NULL && ssl != NULL && x509->derCert != NULL) { if (ProcessBuffer(NULL, x509->derCert->buffer, x509->derCert->length, WOLFSSL_FILETYPE_ASN1, CERT_TYPE, ssl, &idx, 0, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } } (void)idx; return WOLFSSL_FAILURE; } #endif /* NO_CERTS */ #endif /* OPENSSL_EXTRA */ #ifndef NO_CERTS int wolfSSL_use_certificate_ASN1(WOLFSSL* ssl, const unsigned char* der, int derSz) { long idx; WOLFSSL_ENTER("wolfSSL_use_certificate_ASN1"); if (der != NULL && ssl != NULL) { if (ProcessBuffer(NULL, der, derSz, WOLFSSL_FILETYPE_ASN1, CERT_TYPE, ssl, &idx, 0, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } } (void)idx; return WOLFSSL_FAILURE; } #ifndef NO_FILESYSTEM WOLFSSL_ABI int wolfSSL_use_certificate_file(WOLFSSL* ssl, const char* file, int format) { WOLFSSL_ENTER("wolfSSL_use_certificate_file"); if (ssl == NULL) { return BAD_FUNC_ARG; } if (ProcessFile(ssl->ctx, file, format, CERT_TYPE, ssl, 0, NULL, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } WOLFSSL_ABI int wolfSSL_use_PrivateKey_file(WOLFSSL* ssl, const char* file, int format) { WOLFSSL_ENTER("wolfSSL_use_PrivateKey_file"); if (ssl == NULL) { return BAD_FUNC_ARG; } if (ProcessFile(ssl->ctx, file, format, PRIVATEKEY_TYPE, ssl, 0, NULL, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } WOLFSSL_ABI int wolfSSL_use_certificate_chain_file(WOLFSSL* ssl, const char* file) { /* process up to MAX_CHAIN_DEPTH plus subject cert */ WOLFSSL_ENTER("wolfSSL_use_certificate_chain_file"); if (ssl == NULL) { return BAD_FUNC_ARG; } if (ProcessFile(ssl->ctx, file, WOLFSSL_FILETYPE_PEM, CERT_TYPE, ssl, 1, NULL, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } int wolfSSL_use_certificate_chain_file_format(WOLFSSL* ssl, const char* file, int format) { /* process up to MAX_CHAIN_DEPTH plus subject cert */ WOLFSSL_ENTER("wolfSSL_use_certificate_chain_file_format"); if (ssl == NULL) { return BAD_FUNC_ARG; } if (ProcessFile(ssl->ctx, file, format, CERT_TYPE, ssl, 1, NULL, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } #endif /* !NO_FILESYSTEM */ #endif /* !NO_CERTS */ #ifdef HAVE_ECC /* Set Temp CTX EC-DHE size in octets, should be 20 - 66 for 160 - 521 bit */ int wolfSSL_CTX_SetTmpEC_DHE_Sz(WOLFSSL_CTX* ctx, word16 sz) { if (ctx == NULL) return BAD_FUNC_ARG; if (sz == 0) { /* applies only to ECDSA */ if (ctx->privateKeyType != ecc_dsa_sa_algo) return WOLFSSL_SUCCESS; if (ctx->privateKeySz == 0) { WOLFSSL_MSG("Must set private key/cert first"); return BAD_FUNC_ARG; } sz = (word16)ctx->privateKeySz; } /* check size */ if (sz < ECC_MINSIZE || sz > ECC_MAXSIZE) return BAD_FUNC_ARG; ctx->eccTempKeySz = sz; return WOLFSSL_SUCCESS; } /* Set Temp SSL EC-DHE size in octets, should be 20 - 66 for 160 - 521 bit */ int wolfSSL_SetTmpEC_DHE_Sz(WOLFSSL* ssl, word16 sz) { if (ssl == NULL || sz < ECC_MINSIZE || sz > ECC_MAXSIZE) return BAD_FUNC_ARG; ssl->eccTempKeySz = sz; return WOLFSSL_SUCCESS; } #endif /* HAVE_ECC */ #ifdef OPENSSL_EXTRA #ifndef NO_FILESYSTEM int wolfSSL_CTX_use_RSAPrivateKey_file(WOLFSSL_CTX* ctx,const char* file, int format) { WOLFSSL_ENTER("SSL_CTX_use_RSAPrivateKey_file"); return wolfSSL_CTX_use_PrivateKey_file(ctx, file, format); } int wolfSSL_use_RSAPrivateKey_file(WOLFSSL* ssl, const char* file, int format) { WOLFSSL_ENTER("wolfSSL_use_RSAPrivateKey_file"); return wolfSSL_use_PrivateKey_file(ssl, file, format); } #endif /* NO_FILESYSTEM */ /* Copies the master secret over to out buffer. If outSz is 0 returns the size * of master secret. * * ses : a session from completed TLS/SSL handshake * out : buffer to hold copy of master secret * outSz : size of out buffer * returns : number of bytes copied into out buffer on success * less then or equal to 0 is considered a failure case */ int wolfSSL_SESSION_get_master_key(const WOLFSSL_SESSION* ses, unsigned char* out, int outSz) { int size; if (outSz == 0) { return SECRET_LEN; } if (ses == NULL || out == NULL || outSz < 0) { return 0; } if (outSz > SECRET_LEN) { size = SECRET_LEN; } else { size = outSz; } XMEMCPY(out, ses->masterSecret, size); return size; } int wolfSSL_SESSION_get_master_key_length(const WOLFSSL_SESSION* ses) { (void)ses; return SECRET_LEN; } #endif /* OPENSSL_EXTRA */ #ifndef NO_FILESYSTEM #ifdef HAVE_NTRU int wolfSSL_CTX_use_NTRUPrivateKey_file(WOLFSSL_CTX* ctx, const char* file) { WOLFSSL_ENTER("wolfSSL_CTX_use_NTRUPrivateKey_file"); if (ctx == NULL) return WOLFSSL_FAILURE; if (ProcessFile(ctx, file, WOLFSSL_FILETYPE_RAW, PRIVATEKEY_TYPE, NULL, 0, NULL, GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) { ctx->haveNTRU = 1; return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } #endif /* HAVE_NTRU */ #endif /* NO_FILESYSTEM */ void wolfSSL_CTX_set_verify(WOLFSSL_CTX* ctx, int mode, VerifyCallback vc) { WOLFSSL_ENTER("wolfSSL_CTX_set_verify"); if (ctx == NULL) return; if (mode & WOLFSSL_VERIFY_PEER) { ctx->verifyPeer = 1; ctx->verifyNone = 0; /* in case previously set */ } if (mode == WOLFSSL_VERIFY_NONE) { ctx->verifyNone = 1; ctx->verifyPeer = 0; /* in case previously set */ } if (mode & WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT) { ctx->failNoCert = 1; } if (mode & WOLFSSL_VERIFY_FAIL_EXCEPT_PSK) { ctx->failNoCert = 0; /* fail on all is set to fail on PSK */ ctx->failNoCertxPSK = 1; } ctx->verifyCallback = vc; } #ifdef OPENSSL_ALL void wolfSSL_CTX_set_cert_verify_callback(WOLFSSL_CTX* ctx, CertVerifyCallback cb, void* arg) { WOLFSSL_ENTER("SSL_CTX_set_cert_verify_callback"); if (ctx == NULL) return; ctx->verifyCertCb = cb; ctx->verifyCertCbArg = arg; } #endif void wolfSSL_set_verify(WOLFSSL* ssl, int mode, VerifyCallback vc) { WOLFSSL_ENTER("wolfSSL_set_verify"); if (ssl == NULL) return; if (mode & WOLFSSL_VERIFY_PEER) { ssl->options.verifyPeer = 1; ssl->options.verifyNone = 0; /* in case previously set */ } if (mode == WOLFSSL_VERIFY_NONE) { ssl->options.verifyNone = 1; ssl->options.verifyPeer = 0; /* in case previously set */ } if (mode & WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT) ssl->options.failNoCert = 1; if (mode & WOLFSSL_VERIFY_FAIL_EXCEPT_PSK) { ssl->options.failNoCert = 0; /* fail on all is set to fail on PSK */ ssl->options.failNoCertxPSK = 1; } ssl->verifyCallback = vc; } void wolfSSL_set_verify_result(WOLFSSL *ssl, long v) { WOLFSSL_ENTER("wolfSSL_set_verify_result"); if (ssl == NULL) return; #ifdef OPENSSL_ALL ssl->verifyCallbackResult = v; #else (void)v; WOLFSSL_STUB("wolfSSL_set_verify_result"); #endif } /* store user ctx for verify callback */ void wolfSSL_SetCertCbCtx(WOLFSSL* ssl, void* ctx) { WOLFSSL_ENTER("wolfSSL_SetCertCbCtx"); if (ssl) ssl->verifyCbCtx = ctx; } /* store context CA Cache addition callback */ void wolfSSL_CTX_SetCACb(WOLFSSL_CTX* ctx, CallbackCACache cb) { if (ctx && ctx->cm) ctx->cm->caCacheCallback = cb; } #if defined(PERSIST_CERT_CACHE) #if !defined(NO_FILESYSTEM) /* Persist cert cache to file */ int wolfSSL_CTX_save_cert_cache(WOLFSSL_CTX* ctx, const char* fname) { WOLFSSL_ENTER("wolfSSL_CTX_save_cert_cache"); if (ctx == NULL || fname == NULL) return BAD_FUNC_ARG; return CM_SaveCertCache(ctx->cm, fname); } /* Persist cert cache from file */ int wolfSSL_CTX_restore_cert_cache(WOLFSSL_CTX* ctx, const char* fname) { WOLFSSL_ENTER("wolfSSL_CTX_restore_cert_cache"); if (ctx == NULL || fname == NULL) return BAD_FUNC_ARG; return CM_RestoreCertCache(ctx->cm, fname); } #endif /* NO_FILESYSTEM */ /* Persist cert cache to memory */ int wolfSSL_CTX_memsave_cert_cache(WOLFSSL_CTX* ctx, void* mem, int sz, int* used) { WOLFSSL_ENTER("wolfSSL_CTX_memsave_cert_cache"); if (ctx == NULL || mem == NULL || used == NULL || sz <= 0) return BAD_FUNC_ARG; return CM_MemSaveCertCache(ctx->cm, mem, sz, used); } /* Restore cert cache from memory */ int wolfSSL_CTX_memrestore_cert_cache(WOLFSSL_CTX* ctx, const void* mem, int sz) { WOLFSSL_ENTER("wolfSSL_CTX_memrestore_cert_cache"); if (ctx == NULL || mem == NULL || sz <= 0) return BAD_FUNC_ARG; return CM_MemRestoreCertCache(ctx->cm, mem, sz); } /* get how big the the cert cache save buffer needs to be */ int wolfSSL_CTX_get_cert_cache_memsize(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_get_cert_cache_memsize"); if (ctx == NULL) return BAD_FUNC_ARG; return CM_GetCertCacheMemSize(ctx->cm); } #endif /* PERSIST_CERT_CACHE */ #endif /* !NO_CERTS */ #ifndef NO_SESSION_CACHE WOLFSSL_ABI WOLFSSL_SESSION* wolfSSL_get_session(WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_get_session"); if (ssl) return GetSession(ssl, 0, 1); return NULL; } WOLFSSL_ABI int wolfSSL_set_session(WOLFSSL* ssl, WOLFSSL_SESSION* session) { WOLFSSL_ENTER("SSL_set_session"); if (session) return SetSession(ssl, session); return WOLFSSL_FAILURE; } #ifndef NO_CLIENT_CACHE /* Associate client session with serverID, find existing or store for saving if newSession flag on, don't reuse existing session WOLFSSL_SUCCESS on ok */ int wolfSSL_SetServerID(WOLFSSL* ssl, const byte* id, int len, int newSession) { WOLFSSL_SESSION* session = NULL; WOLFSSL_ENTER("wolfSSL_SetServerID"); if (ssl == NULL || id == NULL || len <= 0) return BAD_FUNC_ARG; if (newSession == 0) { session = GetSessionClient(ssl, id, len); if (session) { if (SetSession(ssl, session) != WOLFSSL_SUCCESS) { #ifdef HAVE_EXT_CACHE wolfSSL_SESSION_free(session); #endif WOLFSSL_MSG("SetSession failed"); session = NULL; } } } if (session == NULL) { WOLFSSL_MSG("Valid ServerID not cached already"); ssl->session.idLen = (word16)min(SERVER_ID_LEN, (word32)len); XMEMCPY(ssl->session.serverID, id, ssl->session.idLen); } #ifdef HAVE_EXT_CACHE else wolfSSL_SESSION_free(session); #endif return WOLFSSL_SUCCESS; } #endif /* NO_CLIENT_CACHE */ #if defined(PERSIST_SESSION_CACHE) /* for persistence, if changes to layout need to increment and modify save_session_cache() and restore_session_cache and memory versions too */ #define WOLFSSL_CACHE_VERSION 2 /* Session Cache Header information */ typedef struct { int version; /* cache layout version id */ int rows; /* session rows */ int columns; /* session columns */ int sessionSz; /* sizeof WOLFSSL_SESSION */ } cache_header_t; /* current persistence layout is: 1) cache_header_t 2) SessionCache 3) ClientCache update WOLFSSL_CACHE_VERSION if change layout for the following PERSISTENT_SESSION_CACHE functions */ /* get how big the the session cache save buffer needs to be */ int wolfSSL_get_session_cache_memsize(void) { int sz = (int)(sizeof(SessionCache) + sizeof(cache_header_t)); #ifndef NO_CLIENT_CACHE sz += (int)(sizeof(ClientCache)); #endif return sz; } /* Persist session cache to memory */ int wolfSSL_memsave_session_cache(void* mem, int sz) { int i; cache_header_t cache_header; SessionRow* row = (SessionRow*)((byte*)mem + sizeof(cache_header)); #ifndef NO_CLIENT_CACHE ClientRow* clRow; #endif WOLFSSL_ENTER("wolfSSL_memsave_session_cache"); if (sz < wolfSSL_get_session_cache_memsize()) { WOLFSSL_MSG("Memory buffer too small"); return BUFFER_E; } cache_header.version = WOLFSSL_CACHE_VERSION; cache_header.rows = SESSION_ROWS; cache_header.columns = SESSIONS_PER_ROW; cache_header.sessionSz = (int)sizeof(WOLFSSL_SESSION); XMEMCPY(mem, &cache_header, sizeof(cache_header)); if (wc_LockMutex(&session_mutex) != 0) { WOLFSSL_MSG("Session cache mutex lock failed"); return BAD_MUTEX_E; } for (i = 0; i < cache_header.rows; ++i) XMEMCPY(row++, SessionCache + i, sizeof(SessionRow)); #ifndef NO_CLIENT_CACHE clRow = (ClientRow*)row; for (i = 0; i < cache_header.rows; ++i) XMEMCPY(clRow++, ClientCache + i, sizeof(ClientRow)); #endif wc_UnLockMutex(&session_mutex); WOLFSSL_LEAVE("wolfSSL_memsave_session_cache", WOLFSSL_SUCCESS); return WOLFSSL_SUCCESS; } /* Restore the persistent session cache from memory */ int wolfSSL_memrestore_session_cache(const void* mem, int sz) { int i; cache_header_t cache_header; SessionRow* row = (SessionRow*)((byte*)mem + sizeof(cache_header)); #ifndef NO_CLIENT_CACHE ClientRow* clRow; #endif WOLFSSL_ENTER("wolfSSL_memrestore_session_cache"); if (sz < wolfSSL_get_session_cache_memsize()) { WOLFSSL_MSG("Memory buffer too small"); return BUFFER_E; } XMEMCPY(&cache_header, mem, sizeof(cache_header)); if (cache_header.version != WOLFSSL_CACHE_VERSION || cache_header.rows != SESSION_ROWS || cache_header.columns != SESSIONS_PER_ROW || cache_header.sessionSz != (int)sizeof(WOLFSSL_SESSION)) { WOLFSSL_MSG("Session cache header match failed"); return CACHE_MATCH_ERROR; } if (wc_LockMutex(&session_mutex) != 0) { WOLFSSL_MSG("Session cache mutex lock failed"); return BAD_MUTEX_E; } for (i = 0; i < cache_header.rows; ++i) XMEMCPY(SessionCache + i, row++, sizeof(SessionRow)); #ifndef NO_CLIENT_CACHE clRow = (ClientRow*)row; for (i = 0; i < cache_header.rows; ++i) XMEMCPY(ClientCache + i, clRow++, sizeof(ClientRow)); #endif wc_UnLockMutex(&session_mutex); WOLFSSL_LEAVE("wolfSSL_memrestore_session_cache", WOLFSSL_SUCCESS); return WOLFSSL_SUCCESS; } #if !defined(NO_FILESYSTEM) /* Persist session cache to file */ /* doesn't use memsave because of additional memory use */ int wolfSSL_save_session_cache(const char *fname) { XFILE file; int ret; int rc = WOLFSSL_SUCCESS; int i; cache_header_t cache_header; WOLFSSL_ENTER("wolfSSL_save_session_cache"); file = XFOPEN(fname, "w+b"); if (file == XBADFILE) { WOLFSSL_MSG("Couldn't open session cache save file"); return WOLFSSL_BAD_FILE; } cache_header.version = WOLFSSL_CACHE_VERSION; cache_header.rows = SESSION_ROWS; cache_header.columns = SESSIONS_PER_ROW; cache_header.sessionSz = (int)sizeof(WOLFSSL_SESSION); /* cache header */ ret = (int)XFWRITE(&cache_header, sizeof cache_header, 1, file); if (ret != 1) { WOLFSSL_MSG("Session cache header file write failed"); XFCLOSE(file); return FWRITE_ERROR; } if (wc_LockMutex(&session_mutex) != 0) { WOLFSSL_MSG("Session cache mutex lock failed"); XFCLOSE(file); return BAD_MUTEX_E; } /* session cache */ for (i = 0; i < cache_header.rows; ++i) { ret = (int)XFWRITE(SessionCache + i, sizeof(SessionRow), 1, file); if (ret != 1) { WOLFSSL_MSG("Session cache member file write failed"); rc = FWRITE_ERROR; break; } } #ifndef NO_CLIENT_CACHE /* client cache */ for (i = 0; i < cache_header.rows; ++i) { ret = (int)XFWRITE(ClientCache + i, sizeof(ClientRow), 1, file); if (ret != 1) { WOLFSSL_MSG("Client cache member file write failed"); rc = FWRITE_ERROR; break; } } #endif /* NO_CLIENT_CACHE */ wc_UnLockMutex(&session_mutex); XFCLOSE(file); WOLFSSL_LEAVE("wolfSSL_save_session_cache", rc); return rc; } /* Restore the persistent session cache from file */ /* doesn't use memstore because of additional memory use */ int wolfSSL_restore_session_cache(const char *fname) { XFILE file; int rc = WOLFSSL_SUCCESS; int ret; int i; cache_header_t cache_header; WOLFSSL_ENTER("wolfSSL_restore_session_cache"); file = XFOPEN(fname, "rb"); if (file == XBADFILE) { WOLFSSL_MSG("Couldn't open session cache save file"); return WOLFSSL_BAD_FILE; } /* cache header */ ret = (int)XFREAD(&cache_header, sizeof cache_header, 1, file); if (ret != 1) { WOLFSSL_MSG("Session cache header file read failed"); XFCLOSE(file); return FREAD_ERROR; } if (cache_header.version != WOLFSSL_CACHE_VERSION || cache_header.rows != SESSION_ROWS || cache_header.columns != SESSIONS_PER_ROW || cache_header.sessionSz != (int)sizeof(WOLFSSL_SESSION)) { WOLFSSL_MSG("Session cache header match failed"); XFCLOSE(file); return CACHE_MATCH_ERROR; } if (wc_LockMutex(&session_mutex) != 0) { WOLFSSL_MSG("Session cache mutex lock failed"); XFCLOSE(file); return BAD_MUTEX_E; } /* session cache */ for (i = 0; i < cache_header.rows; ++i) { ret = (int)XFREAD(SessionCache + i, sizeof(SessionRow), 1, file); if (ret != 1) { WOLFSSL_MSG("Session cache member file read failed"); XMEMSET(SessionCache, 0, sizeof SessionCache); rc = FREAD_ERROR; break; } } #ifndef NO_CLIENT_CACHE /* client cache */ for (i = 0; i < cache_header.rows; ++i) { ret = (int)XFREAD(ClientCache + i, sizeof(ClientRow), 1, file); if (ret != 1) { WOLFSSL_MSG("Client cache member file read failed"); XMEMSET(ClientCache, 0, sizeof ClientCache); rc = FREAD_ERROR; break; } } #endif /* NO_CLIENT_CACHE */ wc_UnLockMutex(&session_mutex); XFCLOSE(file); WOLFSSL_LEAVE("wolfSSL_restore_session_cache", rc); return rc; } #endif /* !NO_FILESYSTEM */ #endif /* PERSIST_SESSION_CACHE */ #endif /* NO_SESSION_CACHE */ void wolfSSL_load_error_strings(void) /* compatibility only */ {} int wolfSSL_library_init(void) { WOLFSSL_ENTER("SSL_library_init"); if (wolfSSL_Init() == WOLFSSL_SUCCESS) return WOLFSSL_SUCCESS; else return WOLFSSL_FATAL_ERROR; } #ifdef HAVE_SECRET_CALLBACK int wolfSSL_set_session_secret_cb(WOLFSSL* ssl, SessionSecretCb cb, void* ctx) { WOLFSSL_ENTER("wolfSSL_set_session_secret_cb"); if (ssl == NULL) return WOLFSSL_FATAL_ERROR; ssl->sessionSecretCb = cb; ssl->sessionSecretCtx = ctx; /* If using a pre-set key, assume session resumption. */ ssl->session.sessionIDSz = 0; ssl->options.resuming = 1; return WOLFSSL_SUCCESS; } #endif #ifndef NO_SESSION_CACHE /* on by default if built in but allow user to turn off */ WOLFSSL_ABI long wolfSSL_CTX_set_session_cache_mode(WOLFSSL_CTX* ctx, long mode) { WOLFSSL_ENTER("SSL_CTX_set_session_cache_mode"); if (mode == WOLFSSL_SESS_CACHE_OFF) ctx->sessionCacheOff = 1; if ((mode & WOLFSSL_SESS_CACHE_NO_AUTO_CLEAR) != 0) ctx->sessionCacheFlushOff = 1; #ifdef HAVE_EXT_CACHE if ((mode & WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE) != 0) ctx->internalCacheOff = 1; #endif return WOLFSSL_SUCCESS; } #endif /* NO_SESSION_CACHE */ #if !defined(NO_CERTS) #if defined(PERSIST_CERT_CACHE) #define WOLFSSL_CACHE_CERT_VERSION 1 typedef struct { int version; /* cache cert layout version id */ int rows; /* hash table rows, CA_TABLE_SIZE */ int columns[CA_TABLE_SIZE]; /* columns per row on list */ int signerSz; /* sizeof Signer object */ } CertCacheHeader; /* current cert persistence layout is: 1) CertCacheHeader 2) caTable update WOLFSSL_CERT_CACHE_VERSION if change layout for the following PERSIST_CERT_CACHE functions */ /* Return memory needed to persist this signer, have lock */ static WC_INLINE int GetSignerMemory(Signer* signer) { int sz = sizeof(signer->pubKeySize) + sizeof(signer->keyOID) + sizeof(signer->nameLen) + sizeof(signer->subjectNameHash); #if !defined(NO_SKID) sz += (int)sizeof(signer->subjectKeyIdHash); #endif /* add dynamic bytes needed */ sz += signer->pubKeySize; sz += signer->nameLen; return sz; } /* Return memory needed to persist this row, have lock */ static WC_INLINE int GetCertCacheRowMemory(Signer* row) { int sz = 0; while (row) { sz += GetSignerMemory(row); row = row->next; } return sz; } /* get the size of persist cert cache, have lock */ static WC_INLINE int GetCertCacheMemSize(WOLFSSL_CERT_MANAGER* cm) { int sz; int i; sz = sizeof(CertCacheHeader); for (i = 0; i < CA_TABLE_SIZE; i++) sz += GetCertCacheRowMemory(cm->caTable[i]); return sz; } /* Store cert cache header columns with number of items per list, have lock */ static WC_INLINE void SetCertHeaderColumns(WOLFSSL_CERT_MANAGER* cm, int* columns) { int i; Signer* row; for (i = 0; i < CA_TABLE_SIZE; i++) { int count = 0; row = cm->caTable[i]; while (row) { ++count; row = row->next; } columns[i] = count; } } /* Restore whole cert row from memory, have lock, return bytes consumed, < 0 on error, have lock */ static WC_INLINE int RestoreCertRow(WOLFSSL_CERT_MANAGER* cm, byte* current, int row, int listSz, const byte* end) { int idx = 0; if (listSz < 0) { WOLFSSL_MSG("Row header corrupted, negative value"); return PARSE_ERROR; } while (listSz) { Signer* signer; byte* publicKey; byte* start = current + idx; /* for end checks on this signer */ int minSz = sizeof(signer->pubKeySize) + sizeof(signer->keyOID) + sizeof(signer->nameLen) + sizeof(signer->subjectNameHash); #ifndef NO_SKID minSz += (int)sizeof(signer->subjectKeyIdHash); #endif if (start + minSz > end) { WOLFSSL_MSG("Would overread restore buffer"); return BUFFER_E; } signer = MakeSigner(cm->heap); if (signer == NULL) return MEMORY_E; /* pubKeySize */ XMEMCPY(&signer->pubKeySize, current + idx, sizeof(signer->pubKeySize)); idx += (int)sizeof(signer->pubKeySize); /* keyOID */ XMEMCPY(&signer->keyOID, current + idx, sizeof(signer->keyOID)); idx += (int)sizeof(signer->keyOID); /* pulicKey */ if (start + minSz + signer->pubKeySize > end) { WOLFSSL_MSG("Would overread restore buffer"); FreeSigner(signer, cm->heap); return BUFFER_E; } publicKey = (byte*)XMALLOC(signer->pubKeySize, cm->heap, DYNAMIC_TYPE_KEY); if (publicKey == NULL) { FreeSigner(signer, cm->heap); return MEMORY_E; } XMEMCPY(publicKey, current + idx, signer->pubKeySize); signer->publicKey = publicKey; idx += signer->pubKeySize; /* nameLen */ XMEMCPY(&signer->nameLen, current + idx, sizeof(signer->nameLen)); idx += (int)sizeof(signer->nameLen); /* name */ if (start + minSz + signer->pubKeySize + signer->nameLen > end) { WOLFSSL_MSG("Would overread restore buffer"); FreeSigner(signer, cm->heap); return BUFFER_E; } signer->name = (char*)XMALLOC(signer->nameLen, cm->heap, DYNAMIC_TYPE_SUBJECT_CN); if (signer->name == NULL) { FreeSigner(signer, cm->heap); return MEMORY_E; } XMEMCPY(signer->name, current + idx, signer->nameLen); idx += signer->nameLen; /* subjectNameHash */ XMEMCPY(signer->subjectNameHash, current + idx, SIGNER_DIGEST_SIZE); idx += SIGNER_DIGEST_SIZE; #ifndef NO_SKID /* subjectKeyIdHash */ XMEMCPY(signer->subjectKeyIdHash, current + idx,SIGNER_DIGEST_SIZE); idx += SIGNER_DIGEST_SIZE; #endif signer->next = cm->caTable[row]; cm->caTable[row] = signer; --listSz; } return idx; } /* Store whole cert row into memory, have lock, return bytes added */ static WC_INLINE int StoreCertRow(WOLFSSL_CERT_MANAGER* cm, byte* current, int row) { int added = 0; Signer* list = cm->caTable[row]; while (list) { XMEMCPY(current + added, &list->pubKeySize, sizeof(list->pubKeySize)); added += (int)sizeof(list->pubKeySize); XMEMCPY(current + added, &list->keyOID, sizeof(list->keyOID)); added += (int)sizeof(list->keyOID); XMEMCPY(current + added, list->publicKey, list->pubKeySize); added += list->pubKeySize; XMEMCPY(current + added, &list->nameLen, sizeof(list->nameLen)); added += (int)sizeof(list->nameLen); XMEMCPY(current + added, list->name, list->nameLen); added += list->nameLen; XMEMCPY(current + added, list->subjectNameHash, SIGNER_DIGEST_SIZE); added += SIGNER_DIGEST_SIZE; #ifndef NO_SKID XMEMCPY(current + added, list->subjectKeyIdHash,SIGNER_DIGEST_SIZE); added += SIGNER_DIGEST_SIZE; #endif list = list->next; } return added; } /* Persist cert cache to memory, have lock */ static WC_INLINE int DoMemSaveCertCache(WOLFSSL_CERT_MANAGER* cm, void* mem, int sz) { int realSz; int ret = WOLFSSL_SUCCESS; int i; WOLFSSL_ENTER("DoMemSaveCertCache"); realSz = GetCertCacheMemSize(cm); if (realSz > sz) { WOLFSSL_MSG("Mem output buffer too small"); ret = BUFFER_E; } else { byte* current; CertCacheHeader hdr; hdr.version = WOLFSSL_CACHE_CERT_VERSION; hdr.rows = CA_TABLE_SIZE; SetCertHeaderColumns(cm, hdr.columns); hdr.signerSz = (int)sizeof(Signer); XMEMCPY(mem, &hdr, sizeof(CertCacheHeader)); current = (byte*)mem + sizeof(CertCacheHeader); for (i = 0; i < CA_TABLE_SIZE; ++i) current += StoreCertRow(cm, current, i); } return ret; } #if !defined(NO_FILESYSTEM) /* Persist cert cache to file */ int CM_SaveCertCache(WOLFSSL_CERT_MANAGER* cm, const char* fname) { XFILE file; int rc = WOLFSSL_SUCCESS; int memSz; byte* mem; WOLFSSL_ENTER("CM_SaveCertCache"); file = XFOPEN(fname, "w+b"); if (file == XBADFILE) { WOLFSSL_MSG("Couldn't open cert cache save file"); return WOLFSSL_BAD_FILE; } if (wc_LockMutex(&cm->caLock) != 0) { WOLFSSL_MSG("wc_LockMutex on caLock failed"); XFCLOSE(file); return BAD_MUTEX_E; } memSz = GetCertCacheMemSize(cm); mem = (byte*)XMALLOC(memSz, cm->heap, DYNAMIC_TYPE_TMP_BUFFER); if (mem == NULL) { WOLFSSL_MSG("Alloc for tmp buffer failed"); rc = MEMORY_E; } else { rc = DoMemSaveCertCache(cm, mem, memSz); if (rc == WOLFSSL_SUCCESS) { int ret = (int)XFWRITE(mem, memSz, 1, file); if (ret != 1) { WOLFSSL_MSG("Cert cache file write failed"); rc = FWRITE_ERROR; } } XFREE(mem, cm->heap, DYNAMIC_TYPE_TMP_BUFFER); } wc_UnLockMutex(&cm->caLock); XFCLOSE(file); return rc; } /* Restore cert cache from file */ int CM_RestoreCertCache(WOLFSSL_CERT_MANAGER* cm, const char* fname) { XFILE file; int rc = WOLFSSL_SUCCESS; int ret; int memSz; byte* mem; WOLFSSL_ENTER("CM_RestoreCertCache"); file = XFOPEN(fname, "rb"); if (file == XBADFILE) { WOLFSSL_MSG("Couldn't open cert cache save file"); return WOLFSSL_BAD_FILE; } if(XFSEEK(file, 0, XSEEK_END) != 0) { XFCLOSE(file); return WOLFSSL_BAD_FILE; } memSz = (int)XFTELL(file); XREWIND(file); if (memSz > MAX_WOLFSSL_FILE_SIZE || memSz <= 0) { WOLFSSL_MSG("CM_RestoreCertCache file size error"); XFCLOSE(file); return WOLFSSL_BAD_FILE; } mem = (byte*)XMALLOC(memSz, cm->heap, DYNAMIC_TYPE_TMP_BUFFER); if (mem == NULL) { WOLFSSL_MSG("Alloc for tmp buffer failed"); XFCLOSE(file); return MEMORY_E; } ret = (int)XFREAD(mem, memSz, 1, file); if (ret != 1) { WOLFSSL_MSG("Cert file read error"); rc = FREAD_ERROR; } else { rc = CM_MemRestoreCertCache(cm, mem, memSz); if (rc != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Mem restore cert cache failed"); } } XFREE(mem, cm->heap, DYNAMIC_TYPE_TMP_BUFFER); XFCLOSE(file); return rc; } #endif /* NO_FILESYSTEM */ /* Persist cert cache to memory */ int CM_MemSaveCertCache(WOLFSSL_CERT_MANAGER* cm, void* mem, int sz, int* used) { int ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("CM_MemSaveCertCache"); if (wc_LockMutex(&cm->caLock) != 0) { WOLFSSL_MSG("wc_LockMutex on caLock failed"); return BAD_MUTEX_E; } ret = DoMemSaveCertCache(cm, mem, sz); if (ret == WOLFSSL_SUCCESS) *used = GetCertCacheMemSize(cm); wc_UnLockMutex(&cm->caLock); return ret; } /* Restore cert cache from memory */ int CM_MemRestoreCertCache(WOLFSSL_CERT_MANAGER* cm, const void* mem, int sz) { int ret = WOLFSSL_SUCCESS; int i; CertCacheHeader* hdr = (CertCacheHeader*)mem; byte* current = (byte*)mem + sizeof(CertCacheHeader); byte* end = (byte*)mem + sz; /* don't go over */ WOLFSSL_ENTER("CM_MemRestoreCertCache"); if (current > end) { WOLFSSL_MSG("Cert Cache Memory buffer too small"); return BUFFER_E; } if (hdr->version != WOLFSSL_CACHE_CERT_VERSION || hdr->rows != CA_TABLE_SIZE || hdr->signerSz != (int)sizeof(Signer)) { WOLFSSL_MSG("Cert Cache Memory header mismatch"); return CACHE_MATCH_ERROR; } if (wc_LockMutex(&cm->caLock) != 0) { WOLFSSL_MSG("wc_LockMutex on caLock failed"); return BAD_MUTEX_E; } FreeSignerTable(cm->caTable, CA_TABLE_SIZE, cm->heap); for (i = 0; i < CA_TABLE_SIZE; ++i) { int added = RestoreCertRow(cm, current, i, hdr->columns[i], end); if (added < 0) { WOLFSSL_MSG("RestoreCertRow error"); ret = added; break; } current += added; } wc_UnLockMutex(&cm->caLock); return ret; } /* get how big the the cert cache save buffer needs to be */ int CM_GetCertCacheMemSize(WOLFSSL_CERT_MANAGER* cm) { int sz; WOLFSSL_ENTER("CM_GetCertCacheMemSize"); if (wc_LockMutex(&cm->caLock) != 0) { WOLFSSL_MSG("wc_LockMutex on caLock failed"); return BAD_MUTEX_E; } sz = GetCertCacheMemSize(cm); wc_UnLockMutex(&cm->caLock); return sz; } #endif /* PERSIST_CERT_CACHE */ #endif /* NO_CERTS */ #ifdef OPENSSL_EXTRA /* removes all cipher suites from the list that contain "toRemove" * returns the new list size on success */ static int wolfSSL_remove_ciphers(char* list, int sz, const char* toRemove) { int idx = 0; char* next = (char*)list; int totalSz = sz; if (list == NULL) { return 0; } do { char* current = next; char name[MAX_SUITE_NAME + 1]; word32 length; next = XSTRSTR(next, ":"); length = min(sizeof(name), !next ? (word32)XSTRLEN(current) /* last */ : (word32)(next - current)); XSTRNCPY(name, current, length); name[(length == sizeof(name)) ? length - 1 : length] = 0; if (XSTRSTR(name, toRemove)) { XMEMMOVE(list + idx, list + idx + length, totalSz - (idx + length)); totalSz -= length; list[totalSz] = '\0'; next = current; } else { idx += length; } } while (next++); /* ++ needed to skip ':' */ return totalSz; } /* parse some bulk lists like !eNULL / !aNULL * * returns WOLFSSL_SUCCESS on success and sets the cipher suite list */ static int wolfSSL_parse_cipher_list(WOLFSSL_CTX* ctx, Suites* suites, const char* list) { int ret = 0; const int suiteSz = GetCipherNamesSize(); char* next = (char*)list; const CipherSuiteInfo* names = GetCipherNames(); char* localList = NULL; int sz = 0; if (suites == NULL || list == NULL) { WOLFSSL_MSG("NULL argument"); return WOLFSSL_FAILURE; } /* does list contain eNULL or aNULL? */ if (XSTRSTR(list, "aNULL") || XSTRSTR(list, "eNULL")) { do { char* current = next; char name[MAX_SUITE_NAME + 1]; int i; word32 length; next = XSTRSTR(next, ":"); length = min(sizeof(name), !next ? (word32)XSTRLEN(current) /*last*/ : (word32)(next - current)); XSTRNCPY(name, current, length); name[(length == sizeof(name)) ? length - 1 : length] = 0; /* check for "not" case */ if (name[0] == '!' && suiteSz > 0) { /* populate list with all suites if not already created */ if (localList == NULL) { for (i = 0; i < suiteSz; i++) { sz += (int)XSTRLEN(names[i].name) + 2; } localList = (char*)XMALLOC(sz, ctx->heap, DYNAMIC_TYPE_TMP_BUFFER); if (localList == NULL) { return WOLFSSL_FAILURE; } wolfSSL_get_ciphers(localList, sz); sz = (int)XSTRLEN(localList); } if (XSTRSTR(name, "eNULL")) { wolfSSL_remove_ciphers(localList, sz, "-NULL"); } } } while (next++); /* ++ needed to skip ':' */ ret = SetCipherList(ctx, suites, localList); XFREE(localList, ctx->heap, DYNAMIC_TYPE_TMP_BUFFER); return (ret)? WOLFSSL_SUCCESS : WOLFSSL_FAILURE; } else { return (SetCipherList(ctx, suites, list)) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE; } } #endif int wolfSSL_CTX_set_cipher_list(WOLFSSL_CTX* ctx, const char* list) { WOLFSSL_ENTER("wolfSSL_CTX_set_cipher_list"); if (ctx == NULL) return WOLFSSL_FAILURE; /* alloc/init on demand only */ if (ctx->suites == NULL) { ctx->suites = (Suites*)XMALLOC(sizeof(Suites), ctx->heap, DYNAMIC_TYPE_SUITES); if (ctx->suites == NULL) { WOLFSSL_MSG("Memory alloc for Suites failed"); return WOLFSSL_FAILURE; } XMEMSET(ctx->suites, 0, sizeof(Suites)); } #ifdef OPENSSL_EXTRA return wolfSSL_parse_cipher_list(ctx, ctx->suites, list); #else return (SetCipherList(ctx, ctx->suites, list)) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE; #endif } int wolfSSL_set_cipher_list(WOLFSSL* ssl, const char* list) { WOLFSSL_ENTER("wolfSSL_set_cipher_list"); #ifdef SINGLE_THREADED if (ssl->ctx->suites == ssl->suites) { ssl->suites = (Suites*)XMALLOC(sizeof(Suites), ssl->heap, DYNAMIC_TYPE_SUITES); if (ssl->suites == NULL) { WOLFSSL_MSG("Suites Memory error"); return MEMORY_E; } ssl->options.ownSuites = 1; } #endif #ifdef OPENSSL_EXTRA return wolfSSL_parse_cipher_list(ssl->ctx, ssl->suites, list); #else return (SetCipherList(ssl->ctx, ssl->suites, list)) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE; #endif } int wolfSSL_dtls_get_using_nonblock(WOLFSSL* ssl) { int useNb = 0; if (ssl == NULL) return WOLFSSL_FAILURE; WOLFSSL_ENTER("wolfSSL_dtls_get_using_nonblock"); if (ssl->options.dtls) { #ifdef WOLFSSL_DTLS useNb = ssl->options.dtlsUseNonblock; #endif } else { WOLFSSL_MSG("wolfSSL_dtls_get_using_nonblock() is " "DEPRECATED for non-DTLS use."); } return useNb; } #ifndef WOLFSSL_LEANPSK void wolfSSL_dtls_set_using_nonblock(WOLFSSL* ssl, int nonblock) { (void)nonblock; WOLFSSL_ENTER("wolfSSL_dtls_set_using_nonblock"); if (ssl == NULL) return; if (ssl->options.dtls) { #ifdef WOLFSSL_DTLS ssl->options.dtlsUseNonblock = (nonblock != 0); #endif } else { WOLFSSL_MSG("wolfSSL_dtls_set_using_nonblock() is " "DEPRECATED for non-DTLS use."); } } #ifdef WOLFSSL_DTLS int wolfSSL_dtls_get_current_timeout(WOLFSSL* ssl) { int timeout = 0; if (ssl) timeout = ssl->dtls_timeout; WOLFSSL_LEAVE("wolfSSL_dtls_get_current_timeout()", timeout); return timeout; } int wolfSSL_DTLSv1_get_timeout(WOLFSSL* ssl, WOLFSSL_TIMEVAL* timeleft) { if (ssl && timeleft) { XMEMSET(timeleft, 0, sizeof(WOLFSSL_TIMEVAL)); timeleft->tv_sec = ssl->dtls_timeout; } return 0; } #ifndef NO_WOLFSSL_STUB int wolfSSL_DTLSv1_handle_timeout(WOLFSSL* ssl) { WOLFSSL_STUB("SSL_DTLSv1_handle_timeout"); (void)ssl; return 0; } #endif #ifndef NO_WOLFSSL_STUB void wolfSSL_DTLSv1_set_initial_timeout_duration(WOLFSSL* ssl, word32 duration_ms) { WOLFSSL_STUB("SSL_DTLSv1_set_initial_timeout_duration"); (void)ssl; (void)duration_ms; } #endif /* user may need to alter init dtls recv timeout, WOLFSSL_SUCCESS on ok */ int wolfSSL_dtls_set_timeout_init(WOLFSSL* ssl, int timeout) { if (ssl == NULL || timeout < 0) return BAD_FUNC_ARG; if (timeout > ssl->dtls_timeout_max) { WOLFSSL_MSG("Can't set dtls timeout init greater than dtls timeout max"); return BAD_FUNC_ARG; } ssl->dtls_timeout_init = timeout; ssl->dtls_timeout = timeout; return WOLFSSL_SUCCESS; } /* user may need to alter max dtls recv timeout, WOLFSSL_SUCCESS on ok */ int wolfSSL_dtls_set_timeout_max(WOLFSSL* ssl, int timeout) { if (ssl == NULL || timeout < 0) return BAD_FUNC_ARG; if (timeout < ssl->dtls_timeout_init) { WOLFSSL_MSG("Can't set dtls timeout max less than dtls timeout init"); return BAD_FUNC_ARG; } ssl->dtls_timeout_max = timeout; return WOLFSSL_SUCCESS; } int wolfSSL_dtls_got_timeout(WOLFSSL* ssl) { int result = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_dtls_got_timeout()"); if (ssl == NULL) return WOLFSSL_FATAL_ERROR; if (!ssl->options.handShakeDone && (DtlsMsgPoolTimeout(ssl) < 0 || DtlsMsgPoolSend(ssl, 0) < 0)) { result = WOLFSSL_FATAL_ERROR; } WOLFSSL_LEAVE("wolfSSL_dtls_got_timeout()", result); return result; } /* retransmit all the saves messages, WOLFSSL_SUCCESS on ok */ int wolfSSL_dtls_retransmit(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_dtls_retransmit()"); if (ssl == NULL) return WOLFSSL_FATAL_ERROR; if (!ssl->options.handShakeDone) { int result = DtlsMsgPoolSend(ssl, 0); if (result < 0) { ssl->error = result; WOLFSSL_ERROR(result); return WOLFSSL_FATAL_ERROR; } } return 0; } #endif /* DTLS */ #endif /* LEANPSK */ #if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_SERVER) /* Not an SSL function, return 0 for success, error code otherwise */ /* Prereq: ssl's RNG needs to be initialized. */ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl, const byte* secret, word32 secretSz) { int ret = 0; WOLFSSL_ENTER("wolfSSL_DTLS_SetCookieSecret"); if (ssl == NULL) { WOLFSSL_MSG("need a SSL object"); return BAD_FUNC_ARG; } if (secret != NULL && secretSz == 0) { WOLFSSL_MSG("can't have a new secret without a size"); return BAD_FUNC_ARG; } /* If secretSz is 0, use the default size. */ if (secretSz == 0) secretSz = COOKIE_SECRET_SZ; if (secretSz != ssl->buffers.dtlsCookieSecret.length) { byte* newSecret; if (ssl->buffers.dtlsCookieSecret.buffer != NULL) { ForceZero(ssl->buffers.dtlsCookieSecret.buffer, ssl->buffers.dtlsCookieSecret.length); XFREE(ssl->buffers.dtlsCookieSecret.buffer, ssl->heap, DYNAMIC_TYPE_NONE); } newSecret = (byte*)XMALLOC(secretSz, ssl->heap,DYNAMIC_TYPE_COOKIE_PWD); if (newSecret == NULL) { ssl->buffers.dtlsCookieSecret.buffer = NULL; ssl->buffers.dtlsCookieSecret.length = 0; WOLFSSL_MSG("couldn't allocate new cookie secret"); return MEMORY_ERROR; } ssl->buffers.dtlsCookieSecret.buffer = newSecret; ssl->buffers.dtlsCookieSecret.length = secretSz; } /* If the supplied secret is NULL, randomly generate a new secret. */ if (secret == NULL) { ret = wc_RNG_GenerateBlock(ssl->rng, ssl->buffers.dtlsCookieSecret.buffer, secretSz); } else XMEMCPY(ssl->buffers.dtlsCookieSecret.buffer, secret, secretSz); WOLFSSL_LEAVE("wolfSSL_DTLS_SetCookieSecret", 0); return ret; } #endif /* WOLFSSL_DTLS && !NO_WOLFSSL_SERVER */ /* EITHER SIDE METHODS */ #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EITHER_SIDE) WOLFSSL_METHOD* wolfSSLv23_method(void) { return wolfSSLv23_method_ex(NULL); } WOLFSSL_METHOD* wolfSSLv23_method_ex(void* heap) { WOLFSSL_METHOD* m = NULL; WOLFSSL_ENTER("SSLv23_method"); #if !defined(NO_WOLFSSL_CLIENT) m = wolfSSLv23_client_method_ex(heap); #elif !defined(NO_WOLFSSL_SERVER) m = wolfSSLv23_server_method_ex(heap); #endif if (m != NULL) { m->side = WOLFSSL_NEITHER_END; } return m; } #ifdef WOLFSSL_ALLOW_SSLV3 WOLFSSL_METHOD* wolfSSLv3_method(void) { return wolfSSLv3_method_ex(NULL); } WOLFSSL_METHOD* wolfSSLv3_method_ex(void* heap) { WOLFSSL_METHOD* m = NULL; WOLFSSL_ENTER("SSLv3_method"); #if !defined(NO_WOLFSSL_CLIENT) m = wolfSSLv3_client_method_ex(heap); #elif !defined(NO_WOLFSSL_SERVER) m = wolfSSLv3_server_method_ex(heap); #endif if (m != NULL) { m->side = WOLFSSL_NEITHER_END; } return m; } #endif #endif /* OPENSSL_EXTRA || WOLFSSL_EITHER_SIDE */ /* client only parts */ #ifndef NO_WOLFSSL_CLIENT #ifdef OPENSSL_EXTRA WOLFSSL_METHOD* wolfSSLv2_client_method(void) { WOLFSSL_STUB("wolfSSLv2_client_method"); return NULL; } #endif #ifdef WOLFSSL_ALLOW_SSLV3 WOLFSSL_METHOD* wolfSSLv3_client_method(void) { return wolfSSLv3_client_method_ex(NULL); } WOLFSSL_METHOD* wolfSSLv3_client_method_ex(void* heap) { WOLFSSL_METHOD* method = (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), heap, DYNAMIC_TYPE_METHOD); (void)heap; WOLFSSL_ENTER("SSLv3_client_method_ex"); if (method) InitSSL_Method(method, MakeSSLv3()); return method; } #endif /* WOLFSSL_ALLOW_SSLV3 */ WOLFSSL_METHOD* wolfSSLv23_client_method(void) { return wolfSSLv23_client_method_ex(NULL); } WOLFSSL_METHOD* wolfSSLv23_client_method_ex(void* heap) { WOLFSSL_METHOD* method = (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), heap, DYNAMIC_TYPE_METHOD); (void)heap; WOLFSSL_ENTER("SSLv23_client_method_ex"); if (method) { #if !defined(NO_SHA256) || defined(WOLFSSL_SHA384) || defined(WOLFSSL_SHA512) #if defined(WOLFSSL_TLS13) InitSSL_Method(method, MakeTLSv1_3()); #elif !defined(WOLFSSL_NO_TLS12) InitSSL_Method(method, MakeTLSv1_2()); #elif !defined(NO_OLD_TLS) InitSSL_Method(method, MakeTLSv1_1()); #endif #else #ifndef NO_OLD_TLS InitSSL_Method(method, MakeTLSv1_1()); #endif #endif #if !defined(NO_OLD_TLS) || defined(WOLFSSL_TLS13) method->downgrade = 1; #endif } return method; } #if defined(WOLFSSL_DTLS) || !defined(WOLFSSL_NO_TLS12) || !defined(NO_OLD_TLS) || \ defined(WOLFSSL_ALLOW_SSLV3) /* If SCTP is not enabled returns the state of the dtls option. * If SCTP is enabled returns dtls && !sctp. */ static WC_INLINE int IsDtlsNotSctpMode(WOLFSSL* ssl) { int result = ssl->options.dtls; if (result) { #ifdef WOLFSSL_SCTP result = !ssl->options.dtlsSctp; #endif } return result; } #endif /* WOLFSSL_DTLS || !WOLFSSL_NO_TLS12 || !NO_OLD_TLS */ /* please see note at top of README if you get an error from connect */ WOLFSSL_ABI int wolfSSL_connect(WOLFSSL* ssl) { #if !(defined(WOLFSSL_NO_TLS12) && defined(NO_OLD_TLS) && defined(WOLFSSL_TLS13)) int neededState; #endif WOLFSSL_ENTER("SSL_connect()"); #ifdef HAVE_ERRNO_H errno = 0; #endif if (ssl == NULL) return BAD_FUNC_ARG; #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EITHER_SIDE) if (ssl->options.side == WOLFSSL_NEITHER_END) { ssl->error = InitSSL_Side(ssl, WOLFSSL_CLIENT_END); if (ssl->error != WOLFSSL_SUCCESS) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->error = 0; /* expected to be zero here */ } #ifdef OPENSSL_EXTRA if (ssl->CBIS != NULL) { ssl->CBIS(ssl, SSL_ST_CONNECT, SSL_SUCCESS); ssl->cbmode = SSL_CB_WRITE; } #endif #endif /* OPENSSL_EXTRA || WOLFSSL_EITHER_SIDE */ #if defined(WOLFSSL_NO_TLS12) && defined(NO_OLD_TLS) && defined(WOLFSSL_TLS13) return wolfSSL_connect_TLSv13(ssl); #else #ifdef WOLFSSL_TLS13 if (ssl->options.tls1_3) return wolfSSL_connect_TLSv13(ssl); #endif if (ssl->options.side != WOLFSSL_CLIENT_END) { WOLFSSL_ERROR(ssl->error = SIDE_ERROR); return WOLFSSL_FATAL_ERROR; } #ifdef WOLFSSL_DTLS if (ssl->version.major == DTLS_MAJOR) { ssl->options.dtls = 1; ssl->options.tls = 1; ssl->options.tls1_1 = 1; } #endif if (ssl->buffers.outputBuffer.length > 0 #ifdef WOLFSSL_ASYNC_CRYPT /* do not send buffered or advance state if last error was an async pending operation */ && ssl->error != WC_PENDING_E #endif ) { if ( (ssl->error = SendBuffered(ssl)) == 0) { /* fragOffset is non-zero when sending fragments. On the last * fragment, fragOffset is zero again, and the state can be * advanced. */ if (ssl->fragOffset == 0) { ssl->options.connectState++; WOLFSSL_MSG("connect state: " "Advanced from last buffered fragment send"); } else { WOLFSSL_MSG("connect state: " "Not advanced, more fragments to send"); } } else { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } } switch (ssl->options.connectState) { case CONNECT_BEGIN : /* always send client hello first */ if ( (ssl->error = SendClientHello(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->options.connectState = CLIENT_HELLO_SENT; WOLFSSL_MSG("connect state: CLIENT_HELLO_SENT"); FALL_THROUGH; case CLIENT_HELLO_SENT : neededState = ssl->options.resuming ? SERVER_FINISHED_COMPLETE : SERVER_HELLODONE_COMPLETE; #ifdef WOLFSSL_DTLS /* In DTLS, when resuming, we can go straight to FINISHED, * or do a cookie exchange and then skip to FINISHED, assume * we need the cookie exchange first. */ if (IsDtlsNotSctpMode(ssl)) neededState = SERVER_HELLOVERIFYREQUEST_COMPLETE; #endif /* get response */ while (ssl->options.serverState < neededState) { #ifdef WOLFSSL_TLS13 if (ssl->options.tls1_3) return wolfSSL_connect_TLSv13(ssl); #endif if ( (ssl->error = ProcessReply(ssl)) < 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } /* if resumption failed, reset needed state */ else if (neededState == SERVER_FINISHED_COMPLETE) if (!ssl->options.resuming) { if (!IsDtlsNotSctpMode(ssl)) neededState = SERVER_HELLODONE_COMPLETE; else neededState = SERVER_HELLOVERIFYREQUEST_COMPLETE; } } ssl->options.connectState = HELLO_AGAIN; WOLFSSL_MSG("connect state: HELLO_AGAIN"); FALL_THROUGH; case HELLO_AGAIN : if (ssl->options.certOnly) return WOLFSSL_SUCCESS; #ifdef WOLFSSL_TLS13 if (ssl->options.tls1_3) return wolfSSL_connect_TLSv13(ssl); #endif #ifdef WOLFSSL_DTLS if (ssl->options.serverState == SERVER_HELLOVERIFYREQUEST_COMPLETE) { if (IsDtlsNotSctpMode(ssl)) { /* re-init hashes, exclude first hello and verify request */ if ((ssl->error = InitHandshakeHashes(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } if ( (ssl->error = SendClientHello(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } } } #endif ssl->options.connectState = HELLO_AGAIN_REPLY; WOLFSSL_MSG("connect state: HELLO_AGAIN_REPLY"); FALL_THROUGH; case HELLO_AGAIN_REPLY : #ifdef WOLFSSL_DTLS if (IsDtlsNotSctpMode(ssl)) { neededState = ssl->options.resuming ? SERVER_FINISHED_COMPLETE : SERVER_HELLODONE_COMPLETE; /* get response */ while (ssl->options.serverState < neededState) { if ( (ssl->error = ProcessReply(ssl)) < 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } /* if resumption failed, reset needed state */ if (neededState == SERVER_FINISHED_COMPLETE) { if (!ssl->options.resuming) neededState = SERVER_HELLODONE_COMPLETE; } } } #endif ssl->options.connectState = FIRST_REPLY_DONE; WOLFSSL_MSG("connect state: FIRST_REPLY_DONE"); FALL_THROUGH; case FIRST_REPLY_DONE : #if !defined(NO_CERTS) && !defined(WOLFSSL_NO_CLIENT_AUTH) #ifdef WOLFSSL_TLS13 if (ssl->options.tls1_3) return wolfSSL_connect_TLSv13(ssl); #endif if (ssl->options.sendVerify) { if ( (ssl->error = SendCertificate(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } WOLFSSL_MSG("sent: certificate"); } #endif ssl->options.connectState = FIRST_REPLY_FIRST; WOLFSSL_MSG("connect state: FIRST_REPLY_FIRST"); FALL_THROUGH; case FIRST_REPLY_FIRST : #ifdef WOLFSSL_TLS13 if (ssl->options.tls1_3) return wolfSSL_connect_TLSv13(ssl); #endif if (!ssl->options.resuming) { if ( (ssl->error = SendClientKeyExchange(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } WOLFSSL_MSG("sent: client key exchange"); } ssl->options.connectState = FIRST_REPLY_SECOND; WOLFSSL_MSG("connect state: FIRST_REPLY_SECOND"); FALL_THROUGH; case FIRST_REPLY_SECOND : #if !defined(NO_CERTS) && !defined(WOLFSSL_NO_CLIENT_AUTH) if (ssl->options.sendVerify) { if ( (ssl->error = SendCertificateVerify(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } WOLFSSL_MSG("sent: certificate verify"); } #endif /* !NO_CERTS && !WOLFSSL_NO_CLIENT_AUTH */ ssl->options.connectState = FIRST_REPLY_THIRD; WOLFSSL_MSG("connect state: FIRST_REPLY_THIRD"); FALL_THROUGH; case FIRST_REPLY_THIRD : if ( (ssl->error = SendChangeCipher(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } WOLFSSL_MSG("sent: change cipher spec"); ssl->options.connectState = FIRST_REPLY_FOURTH; WOLFSSL_MSG("connect state: FIRST_REPLY_FOURTH"); FALL_THROUGH; case FIRST_REPLY_FOURTH : if ( (ssl->error = SendFinished(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } WOLFSSL_MSG("sent: finished"); ssl->options.connectState = FINISHED_DONE; WOLFSSL_MSG("connect state: FINISHED_DONE"); FALL_THROUGH; case FINISHED_DONE : /* get response */ while (ssl->options.serverState < SERVER_FINISHED_COMPLETE) if ( (ssl->error = ProcessReply(ssl)) < 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->options.connectState = SECOND_REPLY_DONE; WOLFSSL_MSG("connect state: SECOND_REPLY_DONE"); FALL_THROUGH; case SECOND_REPLY_DONE: #ifndef NO_HANDSHAKE_DONE_CB if (ssl->hsDoneCb) { int cbret = ssl->hsDoneCb(ssl, ssl->hsDoneCtx); if (cbret < 0) { ssl->error = cbret; WOLFSSL_MSG("HandShake Done Cb don't continue error"); return WOLFSSL_FATAL_ERROR; } } #endif /* NO_HANDSHAKE_DONE_CB */ if (!ssl->options.dtls) { if (!ssl->options.keepResources) { FreeHandshakeResources(ssl); } } #ifdef WOLFSSL_DTLS else { ssl->options.dtlsHsRetain = 1; } #endif /* WOLFSSL_DTLS */ WOLFSSL_LEAVE("SSL_connect()", WOLFSSL_SUCCESS); return WOLFSSL_SUCCESS; default: WOLFSSL_MSG("Unknown connect state ERROR"); return WOLFSSL_FATAL_ERROR; /* unknown connect state */ } #endif /* !WOLFSSL_NO_TLS12 */ } #endif /* NO_WOLFSSL_CLIENT */ /* server only parts */ #ifndef NO_WOLFSSL_SERVER #ifdef OPENSSL_EXTRA WOLFSSL_METHOD* wolfSSLv2_server_method(void) { WOLFSSL_STUB("wolfSSLv2_server_method"); return 0; } #endif #ifdef WOLFSSL_ALLOW_SSLV3 WOLFSSL_METHOD* wolfSSLv3_server_method(void) { return wolfSSLv3_server_method_ex(NULL); } WOLFSSL_METHOD* wolfSSLv3_server_method_ex(void* heap) { WOLFSSL_METHOD* method = (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), heap, DYNAMIC_TYPE_METHOD); (void)heap; WOLFSSL_ENTER("SSLv3_server_method_ex"); if (method) { InitSSL_Method(method, MakeSSLv3()); method->side = WOLFSSL_SERVER_END; } return method; } #endif /* WOLFSSL_ALLOW_SSLV3 */ WOLFSSL_METHOD* wolfSSLv23_server_method(void) { return wolfSSLv23_server_method_ex(NULL); } WOLFSSL_METHOD* wolfSSLv23_server_method_ex(void* heap) { WOLFSSL_METHOD* method = (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), heap, DYNAMIC_TYPE_METHOD); (void)heap; WOLFSSL_ENTER("SSLv23_server_method_ex"); if (method) { #if !defined(NO_SHA256) || defined(WOLFSSL_SHA384) || defined(WOLFSSL_SHA512) #ifdef WOLFSSL_TLS13 InitSSL_Method(method, MakeTLSv1_3()); #elif !defined(WOLFSSL_NO_TLS12) InitSSL_Method(method, MakeTLSv1_2()); #elif !defined(NO_OLD_TLS) InitSSL_Method(method, MakeTLSv1_1()); #endif #else #ifndef NO_OLD_TLS InitSSL_Method(method, MakeTLSv1_1()); #else #error Must have SHA256, SHA384 or SHA512 enabled for TLS 1.2 #endif #endif #if !defined(NO_OLD_TLS) || defined(WOLFSSL_TLS13) method->downgrade = 1; #endif method->side = WOLFSSL_SERVER_END; } return method; } int wolfSSL_accept(WOLFSSL* ssl) { #if !(defined(WOLFSSL_NO_TLS12) && defined(NO_OLD_TLS) && defined(WOLFSSL_TLS13)) word16 havePSK = 0; word16 haveAnon = 0; word16 haveMcast = 0; #endif if (ssl == NULL) return WOLFSSL_FATAL_ERROR; #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EITHER_SIDE) if (ssl->options.side == WOLFSSL_NEITHER_END) { WOLFSSL_MSG("Setting WOLFSSL_SSL to be server side"); ssl->error = InitSSL_Side(ssl, WOLFSSL_SERVER_END); if (ssl->error != WOLFSSL_SUCCESS) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->error = 0; /* expected to be zero here */ } #endif /* OPENSSL_EXTRA || WOLFSSL_EITHER_SIDE */ #if defined(WOLFSSL_NO_TLS12) && defined(NO_OLD_TLS) && defined(WOLFSSL_TLS13) return wolfSSL_accept_TLSv13(ssl); #else #ifdef WOLFSSL_TLS13 if (ssl->options.tls1_3) return wolfSSL_accept_TLSv13(ssl); #endif WOLFSSL_ENTER("SSL_accept()"); #ifdef HAVE_ERRNO_H errno = 0; #endif #ifndef NO_PSK havePSK = ssl->options.havePSK; #endif (void)havePSK; #ifdef HAVE_ANON haveAnon = ssl->options.haveAnon; #endif (void)haveAnon; #ifdef WOLFSSL_MULTICAST haveMcast = ssl->options.haveMcast; #endif (void)haveMcast; if (ssl->options.side != WOLFSSL_SERVER_END) { WOLFSSL_ERROR(ssl->error = SIDE_ERROR); return WOLFSSL_FATAL_ERROR; } #ifndef NO_CERTS /* in case used set_accept_state after init */ /* allow no private key if using PK callbacks and CB is set */ if (!havePSK && !haveAnon && !haveMcast) { if (!ssl->buffers.certificate || !ssl->buffers.certificate->buffer) { WOLFSSL_MSG("accept error: server cert required"); WOLFSSL_ERROR(ssl->error = NO_PRIVATE_KEY); return WOLFSSL_FATAL_ERROR; } #ifdef HAVE_PK_CALLBACKS if (wolfSSL_CTX_IsPrivatePkSet(ssl->ctx)) { WOLFSSL_MSG("Using PK for server private key"); } else #endif if (!ssl->buffers.key || !ssl->buffers.key->buffer) { WOLFSSL_MSG("accept error: server key required"); WOLFSSL_ERROR(ssl->error = NO_PRIVATE_KEY); return WOLFSSL_FATAL_ERROR; } } #endif #ifdef WOLFSSL_DTLS if (ssl->version.major == DTLS_MAJOR) { ssl->options.dtls = 1; ssl->options.tls = 1; ssl->options.tls1_1 = 1; } #endif if (ssl->buffers.outputBuffer.length > 0 #ifdef WOLFSSL_ASYNC_CRYPT /* do not send buffered or advance state if last error was an async pending operation */ && ssl->error != WC_PENDING_E #endif ) { if ( (ssl->error = SendBuffered(ssl)) == 0) { /* fragOffset is non-zero when sending fragments. On the last * fragment, fragOffset is zero again, and the state can be * advanced. */ if (ssl->fragOffset == 0) { ssl->options.acceptState++; WOLFSSL_MSG("accept state: " "Advanced from last buffered fragment send"); } else { WOLFSSL_MSG("accept state: " "Not advanced, more fragments to send"); } } else { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } } switch (ssl->options.acceptState) { case ACCEPT_BEGIN : #ifdef HAVE_SECURE_RENEGOTIATION case ACCEPT_BEGIN_RENEG: #endif /* get response */ while (ssl->options.clientState < CLIENT_HELLO_COMPLETE) if ( (ssl->error = ProcessReply(ssl)) < 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } #ifdef WOLFSSL_TLS13 ssl->options.acceptState = ACCEPT_CLIENT_HELLO_DONE; WOLFSSL_MSG("accept state ACCEPT_CLIENT_HELLO_DONE"); FALL_THROUGH; case ACCEPT_CLIENT_HELLO_DONE : if (ssl->options.tls1_3) { return wolfSSL_accept_TLSv13(ssl); } #endif ssl->options.acceptState = ACCEPT_FIRST_REPLY_DONE; WOLFSSL_MSG("accept state ACCEPT_FIRST_REPLY_DONE"); FALL_THROUGH; case ACCEPT_FIRST_REPLY_DONE : if ( (ssl->error = SendServerHello(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->options.acceptState = SERVER_HELLO_SENT; WOLFSSL_MSG("accept state SERVER_HELLO_SENT"); FALL_THROUGH; case SERVER_HELLO_SENT : #ifdef WOLFSSL_TLS13 if (ssl->options.tls1_3) { return wolfSSL_accept_TLSv13(ssl); } #endif #ifndef NO_CERTS if (!ssl->options.resuming) if ( (ssl->error = SendCertificate(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } #endif ssl->options.acceptState = CERT_SENT; WOLFSSL_MSG("accept state CERT_SENT"); FALL_THROUGH; case CERT_SENT : #ifndef NO_CERTS if (!ssl->options.resuming) if ( (ssl->error = SendCertificateStatus(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } #endif ssl->options.acceptState = CERT_STATUS_SENT; WOLFSSL_MSG("accept state CERT_STATUS_SENT"); FALL_THROUGH; case CERT_STATUS_SENT : #ifdef WOLFSSL_TLS13 if (ssl->options.tls1_3) { return wolfSSL_accept_TLSv13(ssl); } #endif if (!ssl->options.resuming) if ( (ssl->error = SendServerKeyExchange(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->options.acceptState = KEY_EXCHANGE_SENT; WOLFSSL_MSG("accept state KEY_EXCHANGE_SENT"); FALL_THROUGH; case KEY_EXCHANGE_SENT : #ifndef NO_CERTS if (!ssl->options.resuming) { if (ssl->options.verifyPeer) { if ( (ssl->error = SendCertificateRequest(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } } } #endif ssl->options.acceptState = CERT_REQ_SENT; WOLFSSL_MSG("accept state CERT_REQ_SENT"); FALL_THROUGH; case CERT_REQ_SENT : if (!ssl->options.resuming) if ( (ssl->error = SendServerHelloDone(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->options.acceptState = SERVER_HELLO_DONE; WOLFSSL_MSG("accept state SERVER_HELLO_DONE"); FALL_THROUGH; case SERVER_HELLO_DONE : if (!ssl->options.resuming) { while (ssl->options.clientState < CLIENT_FINISHED_COMPLETE) if ( (ssl->error = ProcessReply(ssl)) < 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } } ssl->options.acceptState = ACCEPT_SECOND_REPLY_DONE; WOLFSSL_MSG("accept state ACCEPT_SECOND_REPLY_DONE"); FALL_THROUGH; case ACCEPT_SECOND_REPLY_DONE : #ifdef HAVE_SESSION_TICKET if (ssl->options.createTicket) { if ( (ssl->error = SendTicket(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } } #endif /* HAVE_SESSION_TICKET */ ssl->options.acceptState = TICKET_SENT; WOLFSSL_MSG("accept state TICKET_SENT"); FALL_THROUGH; case TICKET_SENT: if ( (ssl->error = SendChangeCipher(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->options.acceptState = CHANGE_CIPHER_SENT; WOLFSSL_MSG("accept state CHANGE_CIPHER_SENT"); FALL_THROUGH; case CHANGE_CIPHER_SENT : if ( (ssl->error = SendFinished(ssl)) != 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->options.acceptState = ACCEPT_FINISHED_DONE; WOLFSSL_MSG("accept state ACCEPT_FINISHED_DONE"); FALL_THROUGH; case ACCEPT_FINISHED_DONE : if (ssl->options.resuming) while (ssl->options.clientState < CLIENT_FINISHED_COMPLETE) if ( (ssl->error = ProcessReply(ssl)) < 0) { WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } ssl->options.acceptState = ACCEPT_THIRD_REPLY_DONE; WOLFSSL_MSG("accept state ACCEPT_THIRD_REPLY_DONE"); FALL_THROUGH; case ACCEPT_THIRD_REPLY_DONE : #ifndef NO_HANDSHAKE_DONE_CB if (ssl->hsDoneCb) { int cbret = ssl->hsDoneCb(ssl, ssl->hsDoneCtx); if (cbret < 0) { ssl->error = cbret; WOLFSSL_MSG("HandShake Done Cb don't continue error"); return WOLFSSL_FATAL_ERROR; } } #endif /* NO_HANDSHAKE_DONE_CB */ if (!ssl->options.dtls) { if (!ssl->options.keepResources) { FreeHandshakeResources(ssl); } } #ifdef WOLFSSL_DTLS else { ssl->options.dtlsHsRetain = 1; } #endif /* WOLFSSL_DTLS */ #ifdef WOLFSSL_SESSION_EXPORT if (ssl->dtls_export) { if ((ssl->error = wolfSSL_send_session(ssl)) != 0) { WOLFSSL_MSG("Export DTLS session error"); WOLFSSL_ERROR(ssl->error); return WOLFSSL_FATAL_ERROR; } } #endif WOLFSSL_LEAVE("SSL_accept()", WOLFSSL_SUCCESS); return WOLFSSL_SUCCESS; default : WOLFSSL_MSG("Unknown accept state ERROR"); return WOLFSSL_FATAL_ERROR; } #endif /* !WOLFSSL_NO_TLS12 */ } #endif /* NO_WOLFSSL_SERVER */ #ifndef NO_HANDSHAKE_DONE_CB int wolfSSL_SetHsDoneCb(WOLFSSL* ssl, HandShakeDoneCb cb, void* user_ctx) { WOLFSSL_ENTER("wolfSSL_SetHsDoneCb"); if (ssl == NULL) return BAD_FUNC_ARG; ssl->hsDoneCb = cb; ssl->hsDoneCtx = user_ctx; return WOLFSSL_SUCCESS; } #endif /* NO_HANDSHAKE_DONE_CB */ WOLFSSL_ABI int wolfSSL_Cleanup(void) { int ret = WOLFSSL_SUCCESS; int release = 0; WOLFSSL_ENTER("wolfSSL_Cleanup"); if (initRefCount == 0) return ret; /* possibly no init yet, but not failure either way */ if (wc_LockMutex(&count_mutex) != 0) { WOLFSSL_MSG("Bad Lock Mutex count"); return BAD_MUTEX_E; } release = initRefCount-- == 1; if (initRefCount < 0) initRefCount = 0; wc_UnLockMutex(&count_mutex); if (!release) return ret; #ifdef OPENSSL_EXTRA if (bn_one) { wolfSSL_BN_free(bn_one); bn_one = NULL; } #endif #ifndef NO_SESSION_CACHE if (wc_FreeMutex(&session_mutex) != 0) ret = BAD_MUTEX_E; #endif if (wc_FreeMutex(&count_mutex) != 0) ret = BAD_MUTEX_E; #ifdef OPENSSL_EXTRA wolfSSL_RAND_Cleanup(); #endif if (wolfCrypt_Cleanup() != 0) { WOLFSSL_MSG("Error with wolfCrypt_Cleanup call"); ret = WC_CLEANUP_E; } return ret; } #ifndef NO_SESSION_CACHE /* some session IDs aren't random after all, let's make them random */ static WC_INLINE word32 HashSession(const byte* sessionID, word32 len, int* error) { byte digest[WC_MAX_DIGEST_SIZE]; #ifndef NO_MD5 *error = wc_Md5Hash(sessionID, len, digest); #elif !defined(NO_SHA) *error = wc_ShaHash(sessionID, len, digest); #elif !defined(NO_SHA256) *error = wc_Sha256Hash(sessionID, len, digest); #else #error "We need a digest to hash the session IDs" #endif return *error == 0 ? MakeWordFromHash(digest) : 0; /* 0 on failure */ } WOLFSSL_ABI void wolfSSL_flush_sessions(WOLFSSL_CTX* ctx, long tm) { /* static table now, no flushing needed */ (void)ctx; (void)tm; } /* set ssl session timeout in seconds */ WOLFSSL_ABI int wolfSSL_set_timeout(WOLFSSL* ssl, unsigned int to) { if (ssl == NULL) return BAD_FUNC_ARG; if (to == 0) to = WOLFSSL_SESSION_TIMEOUT; ssl->timeout = to; return WOLFSSL_SUCCESS; } /* set ctx session timeout in seconds */ WOLFSSL_ABI int wolfSSL_CTX_set_timeout(WOLFSSL_CTX* ctx, unsigned int to) { if (ctx == NULL) return BAD_FUNC_ARG; if (to == 0) to = WOLFSSL_SESSION_TIMEOUT; ctx->timeout = to; return WOLFSSL_SUCCESS; } #ifndef NO_CLIENT_CACHE /* Get Session from Client cache based on id/len, return NULL on failure */ WOLFSSL_SESSION* GetSessionClient(WOLFSSL* ssl, const byte* id, int len) { WOLFSSL_SESSION* ret = NULL; word32 row; int idx; int count; int error = 0; WOLFSSL_ENTER("GetSessionClient"); if (ssl->ctx->sessionCacheOff) return NULL; if (ssl->options.side == WOLFSSL_SERVER_END) return NULL; len = min(SERVER_ID_LEN, (word32)len); #ifdef HAVE_EXT_CACHE if (ssl->ctx->get_sess_cb != NULL) { int copy = 0; ret = ssl->ctx->get_sess_cb(ssl, (byte*)id, len, ©); if (ret != NULL) return ret; } if (ssl->ctx->internalCacheOff) return NULL; #endif row = HashSession(id, len, &error) % SESSION_ROWS; if (error != 0) { WOLFSSL_MSG("Hash session failed"); return NULL; } if (wc_LockMutex(&session_mutex) != 0) { WOLFSSL_MSG("Lock session mutex failed"); return NULL; } /* start from most recently used */ count = min((word32)ClientCache[row].totalCount, SESSIONS_PER_ROW); idx = ClientCache[row].nextIdx - 1; if (idx < 0) idx = SESSIONS_PER_ROW - 1; /* if back to front, the previous was end */ for (; count > 0; --count, idx = idx ? idx - 1 : SESSIONS_PER_ROW - 1) { WOLFSSL_SESSION* current; ClientSession clSess; if (idx >= SESSIONS_PER_ROW || idx < 0) { /* sanity check */ WOLFSSL_MSG("Bad idx"); break; } clSess = ClientCache[row].Clients[idx]; current = &SessionCache[clSess.serverRow].Sessions[clSess.serverIdx]; if (XMEMCMP(current->serverID, id, len) == 0) { WOLFSSL_MSG("Found a serverid match for client"); if (LowResTimer() < (current->bornOn + current->timeout)) { WOLFSSL_MSG("Session valid"); ret = current; break; } else { WOLFSSL_MSG("Session timed out"); /* could have more for id */ } } else { WOLFSSL_MSG("ServerID not a match from client table"); } } wc_UnLockMutex(&session_mutex); return ret; } #endif /* NO_CLIENT_CACHE */ /* Restore the master secret and session information for certificates. * * ssl The SSL/TLS object. * session The cached session to restore. * masterSecret The master secret from the cached session. * restoreSessionCerts Restoring session certificates is required. */ static WC_INLINE void RestoreSession(WOLFSSL* ssl, WOLFSSL_SESSION* session, byte* masterSecret, byte restoreSessionCerts) { (void)ssl; (void)restoreSessionCerts; if (masterSecret) XMEMCPY(masterSecret, session->masterSecret, SECRET_LEN); #ifdef SESSION_CERTS /* If set, we should copy the session certs into the ssl object * from the session we are returning so we can resume */ if (restoreSessionCerts) { ssl->session.chain = session->chain; ssl->session.version = session->version; #ifdef NO_RESUME_SUITE_CHECK ssl->session.cipherSuite0 = session->cipherSuite0; ssl->session.cipherSuite = session->cipherSuite; #endif } #endif /* SESSION_CERTS */ #if !defined(NO_RESUME_SUITE_CHECK) || \ (defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)) ssl->session.cipherSuite0 = session->cipherSuite0; ssl->session.cipherSuite = session->cipherSuite; #endif } WOLFSSL_SESSION* GetSession(WOLFSSL* ssl, byte* masterSecret, byte restoreSessionCerts) { WOLFSSL_SESSION* ret = 0; const byte* id = NULL; word32 row; int idx; int count; int error = 0; (void) restoreSessionCerts; if (ssl->options.sessionCacheOff) return NULL; if (ssl->options.haveSessionId == 0) return NULL; #ifdef HAVE_SESSION_TICKET if (ssl->options.side == WOLFSSL_SERVER_END && ssl->options.useTicket == 1) return NULL; #endif if (!ssl->options.tls1_3 && ssl->arrays != NULL) id = ssl->arrays->sessionID; else id = ssl->session.sessionID; #ifdef HAVE_EXT_CACHE if (ssl->ctx->get_sess_cb != NULL) { int copy = 0; /* Attempt to retrieve the session from the external cache. */ ret = ssl->ctx->get_sess_cb(ssl, (byte*)id, ID_LEN, ©); if (ret != NULL) { RestoreSession(ssl, ret, masterSecret, restoreSessionCerts); return ret; } } if (ssl->ctx->internalCacheOff) return NULL; #endif row = HashSession(id, ID_LEN, &error) % SESSION_ROWS; if (error != 0) { WOLFSSL_MSG("Hash session failed"); return NULL; } if (wc_LockMutex(&session_mutex) != 0) return 0; /* start from most recently used */ count = min((word32)SessionCache[row].totalCount, SESSIONS_PER_ROW); idx = SessionCache[row].nextIdx - 1; if (idx < 0) idx = SESSIONS_PER_ROW - 1; /* if back to front, the previous was end */ for (; count > 0; --count, idx = idx ? idx - 1 : SESSIONS_PER_ROW - 1) { WOLFSSL_SESSION* current; if (idx >= SESSIONS_PER_ROW || idx < 0) { /* sanity check */ WOLFSSL_MSG("Bad idx"); break; } current = &SessionCache[row].Sessions[idx]; if (XMEMCMP(current->sessionID, id, ID_LEN) == 0) { WOLFSSL_MSG("Found a session match"); if (LowResTimer() < (current->bornOn + current->timeout)) { WOLFSSL_MSG("Session valid"); ret = current; RestoreSession(ssl, ret, masterSecret, restoreSessionCerts); } else { WOLFSSL_MSG("Session timed out"); } break; /* no more sessionIDs whether valid or not that match */ } else { WOLFSSL_MSG("SessionID not a match at this idx"); } } wc_UnLockMutex(&session_mutex); return ret; } static int GetDeepCopySession(WOLFSSL* ssl, WOLFSSL_SESSION* copyFrom) { WOLFSSL_SESSION* copyInto = &ssl->session; void* tmpBuff = NULL; int ticketLen = 0; int doDynamicCopy = 0; int ret = WOLFSSL_SUCCESS; (void)ticketLen; (void)doDynamicCopy; (void)tmpBuff; if (!ssl || !copyFrom) return BAD_FUNC_ARG; #ifdef HAVE_SESSION_TICKET /* Free old dynamic ticket if we had one to avoid leak */ if (copyInto->isDynamic) { XFREE(copyInto->ticket, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); copyInto->ticket = copyInto->staticTicket; copyInto->isDynamic = 0; } #endif if (wc_LockMutex(&session_mutex) != 0) return BAD_MUTEX_E; #ifdef HAVE_SESSION_TICKET /* Size of ticket to alloc if needed; Use later for alloc outside lock */ doDynamicCopy = copyFrom->isDynamic; ticketLen = copyFrom->ticketLen; #endif *copyInto = *copyFrom; /* Default ticket to non dynamic. This will avoid crash if we fail below */ #ifdef HAVE_SESSION_TICKET copyInto->ticket = copyInto->staticTicket; copyInto->isDynamic = 0; #endif #ifndef NO_RESUME_SUITE_CHECK copyInto->cipherSuite0 = copyFrom->cipherSuite0; copyInto->cipherSuite = copyFrom->cipherSuite; #endif if (wc_UnLockMutex(&session_mutex) != 0) { return BAD_MUTEX_E; } #ifdef HAVE_SESSION_TICKET #ifdef WOLFSSL_TLS13 if (wc_LockMutex(&session_mutex) != 0) { XFREE(tmpBuff, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); return BAD_MUTEX_E; } #ifdef NO_RESUME_SUITE_CHECK copyInto->cipherSuite0 = copyFrom->cipherSuite0; copyInto->cipherSuite = copyFrom->cipherSuite; #endif copyInto->namedGroup = copyFrom->namedGroup; copyInto->ticketSeen = copyFrom->ticketSeen; copyInto->ticketAdd = copyFrom->ticketAdd; #ifndef WOLFSSL_TLS13_DRAFT_18 XMEMCPY(©Into->ticketNonce, ©From->ticketNonce, sizeof(TicketNonce)); #endif #ifdef WOLFSSL_EARLY_DATA copyInto->maxEarlyDataSz = copyFrom->maxEarlyDataSz; #endif XMEMCPY(copyInto->masterSecret, copyFrom->masterSecret, SECRET_LEN); if (wc_UnLockMutex(&session_mutex) != 0) { if (ret == WOLFSSL_SUCCESS) ret = BAD_MUTEX_E; } #endif /* If doing dynamic copy, need to alloc outside lock, then inside a lock * confirm the size still matches and memcpy */ if (doDynamicCopy) { tmpBuff = (byte*)XMALLOC(ticketLen, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); if (!tmpBuff) return MEMORY_ERROR; if (wc_LockMutex(&session_mutex) != 0) { XFREE(tmpBuff, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); return BAD_MUTEX_E; } if ((word16)ticketLen != copyFrom->ticketLen) { /* Another thread modified the ssl-> session ticket during alloc. * Treat as error, since ticket different than when copy requested */ ret = VAR_STATE_CHANGE_E; } if (ret == WOLFSSL_SUCCESS) { copyInto->ticket = (byte*)tmpBuff; copyInto->isDynamic = 1; XMEMCPY(copyInto->ticket, copyFrom->ticket, ticketLen); } } else { /* Need to ensure ticket pointer gets updated to own buffer * and is not pointing to buff of session copied from */ copyInto->ticket = copyInto->staticTicket; } if (doDynamicCopy) { if (wc_UnLockMutex(&session_mutex) != 0) { if (ret == WOLFSSL_SUCCESS) ret = BAD_MUTEX_E; } } if (ret != WOLFSSL_SUCCESS) { /* cleanup */ if (tmpBuff) XFREE(tmpBuff, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); copyInto->ticket = copyInto->staticTicket; copyInto->isDynamic = 0; } #endif /* HAVE_SESSION_TICKET */ return ret; } int SetSession(WOLFSSL* ssl, WOLFSSL_SESSION* session) { if (ssl->options.sessionCacheOff) return WOLFSSL_FAILURE; #ifdef OPENSSL_EXTRA /* check for application context id */ if (ssl->sessionCtxSz > 0) { if (XMEMCMP(ssl->sessionCtx, session->sessionCtx, ssl->sessionCtxSz)) { /* context id did not match! */ WOLFSSL_MSG("Session context did not match"); return SSL_FAILURE; } } #endif /* OPENSSL_EXTRA */ if (LowResTimer() < (session->bornOn + session->timeout)) { int ret = GetDeepCopySession(ssl, session); if (ret == WOLFSSL_SUCCESS) { ssl->options.resuming = 1; #if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \ defined(HAVE_SESSION_TICKET)) ssl->version = session->version; #endif #if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \ (defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)) ssl->options.cipherSuite0 = session->cipherSuite0; ssl->options.cipherSuite = session->cipherSuite; #endif } return ret; } return WOLFSSL_FAILURE; /* session timed out */ } #ifdef WOLFSSL_SESSION_STATS static int get_locked_session_stats(word32* active, word32* total, word32* peak); #endif int AddSession(WOLFSSL* ssl) { word32 row = 0; word32 idx = 0; int error = 0; #ifdef HAVE_SESSION_TICKET byte* tmpBuff = NULL; int ticLen = 0; #endif WOLFSSL_SESSION* session; int i; int overwrite = 0; if (ssl->options.sessionCacheOff) return 0; if (ssl->options.haveSessionId == 0) return 0; #ifdef HAVE_SESSION_TICKET if (ssl->options.side == WOLFSSL_SERVER_END && ssl->options.useTicket == 1) return 0; #endif #ifdef HAVE_SESSION_TICKET ticLen = ssl->session.ticketLen; /* Alloc Memory here so if Malloc fails can exit outside of lock */ if(ticLen > SESSION_TICKET_LEN) { tmpBuff = (byte*)XMALLOC(ticLen, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); if(!tmpBuff) return MEMORY_E; } #endif #ifdef HAVE_EXT_CACHE if (ssl->options.internalCacheOff) { /* Create a new session object to be stored. */ session = (WOLFSSL_SESSION*)XMALLOC(sizeof(WOLFSSL_SESSION), NULL, DYNAMIC_TYPE_OPENSSL); if (session == NULL) { #ifdef HAVE_SESSION_TICKET XFREE(tmpBuff, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); #endif return MEMORY_E; } XMEMSET(session, 0, sizeof(WOLFSSL_SESSION)); session->isAlloced = 1; } else #endif { /* Use the session object in the cache for external cache if required. */ #if defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET) if (ssl->options.tls1_3) { row = HashSession(ssl->session.sessionID, ID_LEN, &error) % SESSION_ROWS; } else #endif { row = HashSession(ssl->arrays->sessionID, ID_LEN, &error) % SESSION_ROWS; } if (error != 0) { WOLFSSL_MSG("Hash session failed"); #ifdef HAVE_SESSION_TICKET XFREE(tmpBuff, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); #endif return error; } if (wc_LockMutex(&session_mutex) != 0) { #ifdef HAVE_SESSION_TICKET XFREE(tmpBuff, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); #endif return BAD_MUTEX_E; } for (i=0; ioptions.tls1_3) { if (XMEMCMP(ssl->session.sessionID, SessionCache[row].Sessions[i].sessionID, ID_LEN) == 0) { WOLFSSL_MSG("Session already exists. Overwriting."); overwrite = 1; idx = i; break; } } else { if (XMEMCMP(ssl->arrays->sessionID, SessionCache[row].Sessions[i].sessionID, ID_LEN) == 0) { WOLFSSL_MSG("Session already exists. Overwriting."); overwrite = 1; idx = i; break; } } } if (!overwrite) { idx = SessionCache[row].nextIdx++; } #ifdef SESSION_INDEX ssl->sessionIndex = (row << SESSIDX_ROW_SHIFT) | idx; #endif session = &SessionCache[row].Sessions[idx]; } if (!ssl->options.tls1_3) XMEMCPY(session->masterSecret, ssl->arrays->masterSecret, SECRET_LEN); else XMEMCPY(session->masterSecret, ssl->session.masterSecret, SECRET_LEN); session->haveEMS = ssl->options.haveEMS; #if defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET) if (ssl->options.tls1_3) { XMEMCPY(session->sessionID, ssl->session.sessionID, ID_LEN); session->sessionIDSz = ID_LEN; } else #endif { XMEMCPY(session->sessionID, ssl->arrays->sessionID, ID_LEN); session->sessionIDSz = ssl->arrays->sessionIDSz; } #ifdef OPENSSL_EXTRA /* If using compatibility layer then check for and copy over session context * id. */ if (ssl->sessionCtxSz > 0 && ssl->sessionCtxSz < ID_LEN) { XMEMCPY(session->sessionCtx, ssl->sessionCtx, ssl->sessionCtxSz); } #endif session->timeout = ssl->timeout; session->bornOn = LowResTimer(); #ifdef HAVE_SESSION_TICKET /* Check if another thread modified ticket since alloc */ if ((word16)ticLen != ssl->session.ticketLen) { error = VAR_STATE_CHANGE_E; } if (error == 0) { /* Cleanup cache row's old Dynamic buff if exists */ if(session->isDynamic) { XFREE(session->ticket, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); session->ticket = NULL; } /* If too large to store in static buffer, use dyn buffer */ if (ticLen > SESSION_TICKET_LEN) { session->ticket = tmpBuff; session->isDynamic = 1; } else { session->ticket = session->staticTicket; session->isDynamic = 0; } session->ticketLen = (word16)ticLen; XMEMCPY(session->ticket, ssl->session.ticket, ticLen); } else { /* cleanup, reset state */ session->ticket = session->staticTicket; session->isDynamic = 0; session->ticketLen = 0; if (tmpBuff) { XFREE(tmpBuff, ssl->heap, DYNAMIC_TYPE_SESSION_TICK); tmpBuff = NULL; } } #endif #ifdef SESSION_CERTS if (error == 0) { if (!overwrite || ssl->session.chain.count > 0) { /* * If we are overwriting and no certs present in ssl->session.chain * then keep the old chain. */ session->chain.count = ssl->session.chain.count; XMEMCPY(session->chain.certs, ssl->session.chain.certs, sizeof(x509_buffer) * session->chain.count); } } #endif /* SESSION_CERTS */ #if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \ defined(HAVE_SESSION_TICKET)) if (error == 0) { session->version = ssl->version; } #endif /* SESSION_CERTS || (WOLFSSL_TLS13 & HAVE_SESSION_TICKET) */ #if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \ (defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)) if (error == 0) { session->cipherSuite0 = ssl->options.cipherSuite0; session->cipherSuite = ssl->options.cipherSuite; } #endif #if defined(WOLFSSL_TLS13) if (error == 0) { session->namedGroup = ssl->session.namedGroup; } #endif #if defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET) if (error == 0) { session->ticketSeen = ssl->session.ticketSeen; session->ticketAdd = ssl->session.ticketAdd; #ifndef WOLFSSL_TLS13_DRAFT_18 XMEMCPY(&session->ticketNonce, &ssl->session.ticketNonce, sizeof(TicketNonce)); #endif #ifdef WOLFSSL_EARLY_DATA session->maxEarlyDataSz = ssl->session.maxEarlyDataSz; #endif } #endif /* WOLFSSL_TLS13 && HAVE_SESSION_TICKET */ #ifdef HAVE_EXT_CACHE if (!ssl->options.internalCacheOff) #endif { if (error == 0) { SessionCache[row].totalCount++; if (SessionCache[row].nextIdx == SESSIONS_PER_ROW) SessionCache[row].nextIdx = 0; } } #ifndef NO_CLIENT_CACHE if (error == 0) { if (ssl->options.side == WOLFSSL_CLIENT_END && ssl->session.idLen) { word32 clientRow, clientIdx; WOLFSSL_MSG("Adding client cache entry"); session->idLen = ssl->session.idLen; XMEMCPY(session->serverID, ssl->session.serverID, ssl->session.idLen); #ifdef HAVE_EXT_CACHE if (!ssl->options.internalCacheOff) #endif { clientRow = HashSession(ssl->session.serverID, ssl->session.idLen, &error) % SESSION_ROWS; if (error != 0) { WOLFSSL_MSG("Hash session failed"); } else { clientIdx = ClientCache[clientRow].nextIdx++; ClientCache[clientRow].Clients[clientIdx].serverRow = (word16)row; ClientCache[clientRow].Clients[clientIdx].serverIdx = (word16)idx; ClientCache[clientRow].totalCount++; if (ClientCache[clientRow].nextIdx == SESSIONS_PER_ROW) ClientCache[clientRow].nextIdx = 0; } } } else session->idLen = 0; } #endif /* NO_CLIENT_CACHE */ #if defined(WOLFSSL_SESSION_STATS) && defined(WOLFSSL_PEAK_SESSIONS) #ifdef HAVE_EXT_CACHE if (!ssl->options.internalCacheOff) #endif { if (error == 0) { word32 active = 0; error = get_locked_session_stats(&active, NULL, NULL); if (error == WOLFSSL_SUCCESS) { error = 0; /* back to this function ok */ if (active > PeakSessions) PeakSessions = active; } } } #endif /* defined(WOLFSSL_SESSION_STATS) && defined(WOLFSSL_PEAK_SESSIONS) */ #ifdef HAVE_EXT_CACHE if (!ssl->options.internalCacheOff) #endif { if (wc_UnLockMutex(&session_mutex) != 0) return BAD_MUTEX_E; } #ifdef HAVE_EXT_CACHE if (error == 0 && ssl->ctx->new_sess_cb != NULL) ssl->ctx->new_sess_cb(ssl, session); if (ssl->options.internalCacheOff) wolfSSL_SESSION_free(session); #endif return error; } #ifdef SESSION_INDEX int wolfSSL_GetSessionIndex(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_GetSessionIndex"); WOLFSSL_LEAVE("wolfSSL_GetSessionIndex", ssl->sessionIndex); return ssl->sessionIndex; } int wolfSSL_GetSessionAtIndex(int idx, WOLFSSL_SESSION* session) { int row, col, result = WOLFSSL_FAILURE; WOLFSSL_ENTER("wolfSSL_GetSessionAtIndex"); row = idx >> SESSIDX_ROW_SHIFT; col = idx & SESSIDX_IDX_MASK; if (wc_LockMutex(&session_mutex) != 0) { return BAD_MUTEX_E; } if (row < SESSION_ROWS && col < (int)min(SessionCache[row].totalCount, SESSIONS_PER_ROW)) { XMEMCPY(session, &SessionCache[row].Sessions[col], sizeof(WOLFSSL_SESSION)); result = WOLFSSL_SUCCESS; } if (wc_UnLockMutex(&session_mutex) != 0) result = BAD_MUTEX_E; WOLFSSL_LEAVE("wolfSSL_GetSessionAtIndex", result); return result; } #endif /* SESSION_INDEX */ #if defined(SESSION_CERTS) WOLFSSL_X509_CHAIN* wolfSSL_SESSION_get_peer_chain(WOLFSSL_SESSION* session) { WOLFSSL_X509_CHAIN* chain = NULL; WOLFSSL_ENTER("wolfSSL_SESSION_get_peer_chain"); if (session) chain = &session->chain; WOLFSSL_LEAVE("wolfSSL_SESSION_get_peer_chain", chain ? 1 : 0); return chain; } #ifdef OPENSSL_EXTRA /* gets the peer certificate associated with the session passed in * returns null on failure, the caller should not free the returned pointer */ WOLFSSL_X509* wolfSSL_SESSION_get0_peer(WOLFSSL_SESSION* session) { WOLFSSL_ENTER("wolfSSL_SESSION_get_peer_chain"); if (session) { int count; count = wolfSSL_get_chain_count(&session->chain); if (count < 1 || count >= MAX_CHAIN_DEPTH) { WOLFSSL_MSG("bad count found"); return NULL; } if (session->peer == NULL) { session->peer = wolfSSL_get_chain_X509(&session->chain, 0); } return session->peer; } WOLFSSL_MSG("No session passed in"); return NULL; } #endif /* OPENSSL_EXTRA */ #endif /* SESSION_INDEX && SESSION_CERTS */ #ifdef WOLFSSL_SESSION_STATS /* requires session_mutex lock held, WOLFSSL_SUCCESS on ok */ static int get_locked_session_stats(word32* active, word32* total, word32* peak) { int result = WOLFSSL_SUCCESS; int i; int count; int idx; word32 now = 0; word32 seen = 0; word32 ticks = LowResTimer(); (void)peak; WOLFSSL_ENTER("get_locked_session_stats"); for (i = 0; i < SESSION_ROWS; i++) { seen += SessionCache[i].totalCount; if (active == NULL) continue; /* no need to calculate what we can't set */ count = min((word32)SessionCache[i].totalCount, SESSIONS_PER_ROW); idx = SessionCache[i].nextIdx - 1; if (idx < 0) idx = SESSIONS_PER_ROW - 1; /* if back to front previous was end */ for (; count > 0; --count, idx = idx ? idx - 1 : SESSIONS_PER_ROW - 1) { if (idx >= SESSIONS_PER_ROW || idx < 0) { /* sanity check */ WOLFSSL_MSG("Bad idx"); break; } /* if not expired then good */ if (ticks < (SessionCache[i].Sessions[idx].bornOn + SessionCache[i].Sessions[idx].timeout) ) { now++; } } } if (active) *active = now; if (total) *total = seen; #ifdef WOLFSSL_PEAK_SESSIONS if (peak) *peak = PeakSessions; #endif WOLFSSL_LEAVE("get_locked_session_stats", result); return result; } /* return WOLFSSL_SUCCESS on ok */ int wolfSSL_get_session_stats(word32* active, word32* total, word32* peak, word32* maxSessions) { int result = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_get_session_stats"); if (maxSessions) { *maxSessions = SESSIONS_PER_ROW * SESSION_ROWS; if (active == NULL && total == NULL && peak == NULL) return result; /* we're done */ } /* user must provide at least one query value */ if (active == NULL && total == NULL && peak == NULL) return BAD_FUNC_ARG; if (wc_LockMutex(&session_mutex) != 0) { return BAD_MUTEX_E; } result = get_locked_session_stats(active, total, peak); if (wc_UnLockMutex(&session_mutex) != 0) result = BAD_MUTEX_E; WOLFSSL_LEAVE("wolfSSL_get_session_stats", result); return result; } #endif /* WOLFSSL_SESSION_STATS */ #ifdef PRINT_SESSION_STATS /* WOLFSSL_SUCCESS on ok */ int wolfSSL_PrintSessionStats(void) { word32 totalSessionsSeen = 0; word32 totalSessionsNow = 0; word32 peak = 0; word32 maxSessions = 0; int i; int ret; double E; /* expected freq */ double chiSquare = 0; ret = wolfSSL_get_session_stats(&totalSessionsNow, &totalSessionsSeen, &peak, &maxSessions); if (ret != WOLFSSL_SUCCESS) return ret; printf("Total Sessions Seen = %d\n", totalSessionsSeen); printf("Total Sessions Now = %d\n", totalSessionsNow); #ifdef WOLFSSL_PEAK_SESSIONS printf("Peak Sessions = %d\n", peak); #endif printf("Max Sessions = %d\n", maxSessions); E = (double)totalSessionsSeen / SESSION_ROWS; for (i = 0; i < SESSION_ROWS; i++) { double diff = SessionCache[i].totalCount - E; diff *= diff; /* square */ diff /= E; /* normalize */ chiSquare += diff; } printf(" chi-square = %5.1f, d.f. = %d\n", chiSquare, SESSION_ROWS - 1); #if (SESSION_ROWS == 11) printf(" .05 p value = 18.3, chi-square should be less\n"); #elif (SESSION_ROWS == 211) printf(".05 p value = 244.8, chi-square should be less\n"); #elif (SESSION_ROWS == 5981) printf(".05 p value = 6161.0, chi-square should be less\n"); #elif (SESSION_ROWS == 3) printf(".05 p value = 6.0, chi-square should be less\n"); #elif (SESSION_ROWS == 2861) printf(".05 p value = 2985.5, chi-square should be less\n"); #endif printf("\n"); return ret; } #endif /* SESSION_STATS */ #else /* NO_SESSION_CACHE */ /* No session cache version */ WOLFSSL_SESSION* GetSession(WOLFSSL* ssl, byte* masterSecret, byte restoreSessionCerts) { (void)ssl; (void)masterSecret; (void)restoreSessionCerts; return NULL; } #endif /* NO_SESSION_CACHE */ /* call before SSL_connect, if verifying will add name check to date check and signature check */ WOLFSSL_ABI int wolfSSL_check_domain_name(WOLFSSL* ssl, const char* dn) { WOLFSSL_ENTER("wolfSSL_check_domain_name"); if (ssl == NULL || dn == NULL) { WOLFSSL_MSG("Bad function argument: NULL"); return WOLFSSL_FAILURE; } if (ssl->buffers.domainName.buffer) XFREE(ssl->buffers.domainName.buffer, ssl->heap, DYNAMIC_TYPE_DOMAIN); ssl->buffers.domainName.length = (word32)XSTRLEN(dn); ssl->buffers.domainName.buffer = (byte*)XMALLOC( ssl->buffers.domainName.length + 1, ssl->heap, DYNAMIC_TYPE_DOMAIN); if (ssl->buffers.domainName.buffer) { unsigned char* domainName = ssl->buffers.domainName.buffer; XMEMCPY(domainName, dn, ssl->buffers.domainName.length); domainName[ssl->buffers.domainName.length] = '\0'; return WOLFSSL_SUCCESS; } else { ssl->error = MEMORY_ERROR; return WOLFSSL_FAILURE; } } /* turn on wolfSSL zlib compression returns WOLFSSL_SUCCESS for success, else error (not built in) */ int wolfSSL_set_compression(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_set_compression"); (void)ssl; #ifdef HAVE_LIBZ ssl->options.usingCompression = 1; return WOLFSSL_SUCCESS; #else return NOT_COMPILED_IN; #endif } #ifndef USE_WINDOWS_API #ifndef NO_WRITEV /* simulate writev semantics, doesn't actually do block at a time though because of SSL_write behavior and because front adds may be small */ int wolfSSL_writev(WOLFSSL* ssl, const struct iovec* iov, int iovcnt) { #ifdef WOLFSSL_SMALL_STACK byte staticBuffer[1]; /* force heap usage */ #else byte staticBuffer[FILE_BUFFER_SIZE]; #endif byte* myBuffer = staticBuffer; int dynamic = 0; int sending = 0; int idx = 0; int i; int ret; WOLFSSL_ENTER("wolfSSL_writev"); for (i = 0; i < iovcnt; i++) sending += (int)iov[i].iov_len; if (sending > (int)sizeof(staticBuffer)) { myBuffer = (byte*)XMALLOC(sending, ssl->heap, DYNAMIC_TYPE_WRITEV); if (!myBuffer) return MEMORY_ERROR; dynamic = 1; } for (i = 0; i < iovcnt; i++) { XMEMCPY(&myBuffer[idx], iov[i].iov_base, iov[i].iov_len); idx += (int)iov[i].iov_len; } ret = wolfSSL_write(ssl, myBuffer, sending); if (dynamic) XFREE(myBuffer, ssl->heap, DYNAMIC_TYPE_WRITEV); return ret; } #endif #endif #ifdef WOLFSSL_CALLBACKS typedef struct itimerval Itimerval; /* don't keep calling simple functions while setting up timer and signals if no inlining these are the next best */ #define AddTimes(a, b, c) \ do { \ c.tv_sec = a.tv_sec + b.tv_sec; \ c.tv_usec = a.tv_usec + b.tv_usec; \ if (c.tv_usec >= 1000000) { \ c.tv_sec++; \ c.tv_usec -= 1000000; \ } \ } while (0) #define SubtractTimes(a, b, c) \ do { \ c.tv_sec = a.tv_sec - b.tv_sec; \ c.tv_usec = a.tv_usec - b.tv_usec; \ if (c.tv_usec < 0) { \ c.tv_sec--; \ c.tv_usec += 1000000; \ } \ } while (0) #define CmpTimes(a, b, cmp) \ ((a.tv_sec == b.tv_sec) ? \ (a.tv_usec cmp b.tv_usec) : \ (a.tv_sec cmp b.tv_sec)) \ /* do nothing handler */ static void myHandler(int signo) { (void)signo; return; } static int wolfSSL_ex_wrapper(WOLFSSL* ssl, HandShakeCallBack hsCb, TimeoutCallBack toCb, WOLFSSL_TIMEVAL timeout) { int ret = WOLFSSL_FATAL_ERROR; int oldTimerOn = 0; /* was timer already on */ WOLFSSL_TIMEVAL startTime; WOLFSSL_TIMEVAL endTime; WOLFSSL_TIMEVAL totalTime; Itimerval myTimeout; Itimerval oldTimeout; /* if old timer adjust from total time to reset */ struct sigaction act, oact; #define ERR_OUT(x) { ssl->hsInfoOn = 0; ssl->toInfoOn = 0; return x; } if (hsCb) { ssl->hsInfoOn = 1; InitHandShakeInfo(&ssl->handShakeInfo, ssl); } if (toCb) { ssl->toInfoOn = 1; InitTimeoutInfo(&ssl->timeoutInfo); if (gettimeofday(&startTime, 0) < 0) ERR_OUT(GETTIME_ERROR); /* use setitimer to simulate getitimer, init 0 myTimeout */ myTimeout.it_interval.tv_sec = 0; myTimeout.it_interval.tv_usec = 0; myTimeout.it_value.tv_sec = 0; myTimeout.it_value.tv_usec = 0; if (setitimer(ITIMER_REAL, &myTimeout, &oldTimeout) < 0) ERR_OUT(SETITIMER_ERROR); if (oldTimeout.it_value.tv_sec || oldTimeout.it_value.tv_usec) { oldTimerOn = 1; /* is old timer going to expire before ours */ if (CmpTimes(oldTimeout.it_value, timeout, <)) { timeout.tv_sec = oldTimeout.it_value.tv_sec; timeout.tv_usec = oldTimeout.it_value.tv_usec; } } myTimeout.it_value.tv_sec = timeout.tv_sec; myTimeout.it_value.tv_usec = timeout.tv_usec; /* set up signal handler, don't restart socket send/recv */ act.sa_handler = myHandler; sigemptyset(&act.sa_mask); act.sa_flags = 0; #ifdef SA_INTERRUPT act.sa_flags |= SA_INTERRUPT; #endif if (sigaction(SIGALRM, &act, &oact) < 0) ERR_OUT(SIGACT_ERROR); if (setitimer(ITIMER_REAL, &myTimeout, 0) < 0) ERR_OUT(SETITIMER_ERROR); } /* do main work */ #ifndef NO_WOLFSSL_CLIENT if (ssl->options.side == WOLFSSL_CLIENT_END) ret = wolfSSL_connect(ssl); #endif #ifndef NO_WOLFSSL_SERVER if (ssl->options.side == WOLFSSL_SERVER_END) ret = wolfSSL_accept(ssl); #endif /* do callbacks */ if (toCb) { if (oldTimerOn) { gettimeofday(&endTime, 0); SubtractTimes(endTime, startTime, totalTime); /* adjust old timer for elapsed time */ if (CmpTimes(totalTime, oldTimeout.it_value, <)) SubtractTimes(oldTimeout.it_value, totalTime, oldTimeout.it_value); else { /* reset value to interval, may be off */ oldTimeout.it_value.tv_sec = oldTimeout.it_interval.tv_sec; oldTimeout.it_value.tv_usec =oldTimeout.it_interval.tv_usec; } /* keep iter the same whether there or not */ } /* restore old handler */ if (sigaction(SIGALRM, &oact, 0) < 0) ret = SIGACT_ERROR; /* more pressing error, stomp */ else /* use old settings which may turn off (expired or not there) */ if (setitimer(ITIMER_REAL, &oldTimeout, 0) < 0) ret = SETITIMER_ERROR; /* if we had a timeout call callback */ if (ssl->timeoutInfo.timeoutName[0]) { ssl->timeoutInfo.timeoutValue.tv_sec = timeout.tv_sec; ssl->timeoutInfo.timeoutValue.tv_usec = timeout.tv_usec; (toCb)(&ssl->timeoutInfo); } /* clean up */ FreeTimeoutInfo(&ssl->timeoutInfo, ssl->heap); ssl->toInfoOn = 0; } if (hsCb) { FinishHandShakeInfo(&ssl->handShakeInfo); (hsCb)(&ssl->handShakeInfo); ssl->hsInfoOn = 0; } return ret; } #ifndef NO_WOLFSSL_CLIENT int wolfSSL_connect_ex(WOLFSSL* ssl, HandShakeCallBack hsCb, TimeoutCallBack toCb, WOLFSSL_TIMEVAL timeout) { WOLFSSL_ENTER("wolfSSL_connect_ex"); return wolfSSL_ex_wrapper(ssl, hsCb, toCb, timeout); } #endif #ifndef NO_WOLFSSL_SERVER int wolfSSL_accept_ex(WOLFSSL* ssl, HandShakeCallBack hsCb, TimeoutCallBack toCb, WOLFSSL_TIMEVAL timeout) { WOLFSSL_ENTER("wolfSSL_accept_ex"); return wolfSSL_ex_wrapper(ssl, hsCb, toCb, timeout); } #endif #endif /* WOLFSSL_CALLBACKS */ #ifndef NO_PSK void wolfSSL_CTX_set_psk_client_callback(WOLFSSL_CTX* ctx, wc_psk_client_callback cb) { WOLFSSL_ENTER("SSL_CTX_set_psk_client_callback"); if (ctx == NULL) return; ctx->havePSK = 1; ctx->client_psk_cb = cb; } void wolfSSL_set_psk_client_callback(WOLFSSL* ssl,wc_psk_client_callback cb) { byte haveRSA = 1; int keySz = 0; WOLFSSL_ENTER("SSL_set_psk_client_callback"); if (ssl == NULL) return; ssl->options.havePSK = 1; ssl->options.client_psk_cb = cb; #ifdef NO_RSA haveRSA = 0; #endif #ifndef NO_CERTS keySz = ssl->buffers.keySz; #endif InitSuites(ssl->suites, ssl->version, keySz, haveRSA, TRUE, ssl->options.haveDH, ssl->options.haveNTRU, ssl->options.haveECDSAsig, ssl->options.haveECC, ssl->options.haveStaticECC, ssl->options.side); } void wolfSSL_CTX_set_psk_server_callback(WOLFSSL_CTX* ctx, wc_psk_server_callback cb) { WOLFSSL_ENTER("SSL_CTX_set_psk_server_callback"); if (ctx == NULL) return; ctx->havePSK = 1; ctx->server_psk_cb = cb; } void wolfSSL_set_psk_server_callback(WOLFSSL* ssl,wc_psk_server_callback cb) { byte haveRSA = 1; int keySz = 0; WOLFSSL_ENTER("SSL_set_psk_server_callback"); if (ssl == NULL) return; ssl->options.havePSK = 1; ssl->options.server_psk_cb = cb; #ifdef NO_RSA haveRSA = 0; #endif #ifndef NO_CERTS keySz = ssl->buffers.keySz; #endif InitSuites(ssl->suites, ssl->version, keySz, haveRSA, TRUE, ssl->options.haveDH, ssl->options.haveNTRU, ssl->options.haveECDSAsig, ssl->options.haveECC, ssl->options.haveStaticECC, ssl->options.side); } const char* wolfSSL_get_psk_identity_hint(const WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_get_psk_identity_hint"); if (ssl == NULL || ssl->arrays == NULL) return NULL; return ssl->arrays->server_hint; } const char* wolfSSL_get_psk_identity(const WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_get_psk_identity"); if (ssl == NULL || ssl->arrays == NULL) return NULL; return ssl->arrays->client_identity; } int wolfSSL_CTX_use_psk_identity_hint(WOLFSSL_CTX* ctx, const char* hint) { WOLFSSL_ENTER("SSL_CTX_use_psk_identity_hint"); if (hint == 0) ctx->server_hint[0] = '\0'; else { /* Qt does not call CTX_set_*_psk_callbacks where havePSK is set */ #ifdef WOLFSSL_QT ctx->havePSK=1; #endif XSTRNCPY(ctx->server_hint, hint, MAX_PSK_ID_LEN); ctx->server_hint[MAX_PSK_ID_LEN] = '\0'; /* null term */ } return WOLFSSL_SUCCESS; } int wolfSSL_use_psk_identity_hint(WOLFSSL* ssl, const char* hint) { WOLFSSL_ENTER("SSL_use_psk_identity_hint"); if (ssl == NULL || ssl->arrays == NULL) return WOLFSSL_FAILURE; if (hint == 0) ssl->arrays->server_hint[0] = 0; else { XSTRNCPY(ssl->arrays->server_hint, hint, sizeof(ssl->arrays->server_hint)-1); ssl->arrays->server_hint[sizeof(ssl->arrays->server_hint)-1] = '\0'; } return WOLFSSL_SUCCESS; } #endif /* NO_PSK */ #ifdef HAVE_ANON int wolfSSL_CTX_allow_anon_cipher(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_allow_anon_cipher"); if (ctx == NULL) return WOLFSSL_FAILURE; ctx->haveAnon = 1; return WOLFSSL_SUCCESS; } #endif /* HAVE_ANON */ #ifndef NO_CERTS /* used to be defined on NO_FILESYSTEM only, but are generally useful */ int wolfSSL_CTX_load_verify_buffer_ex(WOLFSSL_CTX* ctx, const unsigned char* in, long sz, int format, int userChain, word32 flags) { int verify; WOLFSSL_ENTER("wolfSSL_CTX_load_verify_buffer_ex"); verify = GET_VERIFY_SETTING_CTX(ctx); if (flags & WOLFSSL_LOAD_FLAG_DATE_ERR_OKAY) verify = VERIFY_SKIP_DATE; if (format == WOLFSSL_FILETYPE_PEM) return ProcessChainBuffer(ctx, in, sz, format, CA_TYPE, NULL, verify); else return ProcessBuffer(ctx, in, sz, format, CA_TYPE, NULL, NULL, userChain, verify); } /* wolfSSL extension allows DER files to be loaded from buffers as well */ int wolfSSL_CTX_load_verify_buffer(WOLFSSL_CTX* ctx, const unsigned char* in, long sz, int format) { return wolfSSL_CTX_load_verify_buffer_ex(ctx, in, sz, format, 0, WOLFSSL_LOAD_VERIFY_DEFAULT_FLAGS); } int wolfSSL_CTX_load_verify_chain_buffer_format(WOLFSSL_CTX* ctx, const unsigned char* in, long sz, int format) { return wolfSSL_CTX_load_verify_buffer_ex(ctx, in, sz, format, 1, WOLFSSL_LOAD_VERIFY_DEFAULT_FLAGS); } #ifdef WOLFSSL_TRUST_PEER_CERT int wolfSSL_CTX_trust_peer_buffer(WOLFSSL_CTX* ctx, const unsigned char* in, long sz, int format) { WOLFSSL_ENTER("wolfSSL_CTX_trust_peer_buffer"); /* sanity check on arguments */ if (sz < 0 || in == NULL || ctx == NULL) { return BAD_FUNC_ARG; } if (format == WOLFSSL_FILETYPE_PEM) return ProcessChainBuffer(ctx, in, sz, format, TRUSTED_PEER_TYPE, NULL, GET_VERIFY_SETTING_CTX(ctx)); else return ProcessBuffer(ctx, in, sz, format, TRUSTED_PEER_TYPE, NULL, NULL, 0, GET_VERIFY_SETTING_CTX(ctx)); } #endif /* WOLFSSL_TRUST_PEER_CERT */ int wolfSSL_CTX_use_certificate_buffer(WOLFSSL_CTX* ctx, const unsigned char* in, long sz, int format) { WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_buffer"); return ProcessBuffer(ctx, in, sz, format, CERT_TYPE, NULL, NULL, 0, GET_VERIFY_SETTING_CTX(ctx)); } int wolfSSL_CTX_use_PrivateKey_buffer(WOLFSSL_CTX* ctx, const unsigned char* in, long sz, int format) { WOLFSSL_ENTER("wolfSSL_CTX_use_PrivateKey_buffer"); return ProcessBuffer(ctx, in, sz, format, PRIVATEKEY_TYPE, NULL, NULL, 0, GET_VERIFY_SETTING_CTX(ctx)); } #ifdef HAVE_PKCS11 int wolfSSL_CTX_use_PrivateKey_id(WOLFSSL_CTX* ctx, const unsigned char* id, long sz, int devId, long keySz) { int ret = WOLFSSL_FAILURE; FreeDer(&ctx->privateKey); if (AllocDer(&ctx->privateKey, (word32)sz, PRIVATEKEY_TYPE, ctx->heap) == 0) { XMEMCPY(ctx->privateKey->buffer, id, sz); ctx->privateKeyId = 1; ctx->privateKeySz = (word32)keySz; if (devId != INVALID_DEVID) ctx->privateKeyDevId = devId; else ctx->privateKeyDevId = ctx->devId; ret = WOLFSSL_SUCCESS; } return ret; } #endif int wolfSSL_CTX_use_certificate_chain_buffer_format(WOLFSSL_CTX* ctx, const unsigned char* in, long sz, int format) { WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_chain_buffer_format"); return ProcessBuffer(ctx, in, sz, format, CERT_TYPE, NULL, NULL, 1, GET_VERIFY_SETTING_CTX(ctx)); } int wolfSSL_CTX_use_certificate_chain_buffer(WOLFSSL_CTX* ctx, const unsigned char* in, long sz) { return wolfSSL_CTX_use_certificate_chain_buffer_format(ctx, in, sz, WOLFSSL_FILETYPE_PEM); } #ifndef NO_DH /* server wrapper for ctx or ssl Diffie-Hellman parameters */ static int wolfSSL_SetTmpDH_buffer_wrapper(WOLFSSL_CTX* ctx, WOLFSSL* ssl, const unsigned char* buf, long sz, int format) { DerBuffer* der = NULL; int ret = 0; word32 pSz = MAX_DH_SIZE; word32 gSz = MAX_DH_SIZE; #ifdef WOLFSSL_SMALL_STACK byte* p = NULL; byte* g = NULL; #else byte p[MAX_DH_SIZE]; byte g[MAX_DH_SIZE]; #endif if (ctx == NULL || buf == NULL) return BAD_FUNC_ARG; ret = AllocDer(&der, 0, DH_PARAM_TYPE, ctx->heap); if (ret != 0) { return ret; } der->buffer = (byte*)buf; der->length = (word32)sz; #ifdef WOLFSSL_SMALL_STACK p = (byte*)XMALLOC(pSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); g = (byte*)XMALLOC(gSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); if (p == NULL || g == NULL) { XFREE(p, NULL, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(g, NULL, DYNAMIC_TYPE_PUBLIC_KEY); return MEMORY_E; } #endif if (format != WOLFSSL_FILETYPE_ASN1 && format != WOLFSSL_FILETYPE_PEM) ret = WOLFSSL_BAD_FILETYPE; else { if (format == WOLFSSL_FILETYPE_PEM) { #ifdef WOLFSSL_PEM_TO_DER FreeDer(&der); ret = PemToDer(buf, sz, DH_PARAM_TYPE, &der, ctx->heap, NULL, NULL); #ifdef WOLFSSL_WPAS #ifndef NO_DSA if (ret < 0) { ret = PemToDer(buf, sz, DSA_PARAM_TYPE, &der, ctx->heap, NULL, NULL); } #endif #endif /* WOLFSSL_WPAS */ #else ret = NOT_COMPILED_IN; #endif /* WOLFSSL_PEM_TO_DER */ } if (ret == 0) { if (wc_DhParamsLoad(der->buffer, der->length, p, &pSz, g, &gSz) < 0) ret = WOLFSSL_BAD_FILETYPE; else if (ssl) ret = wolfSSL_SetTmpDH(ssl, p, pSz, g, gSz); else ret = wolfSSL_CTX_SetTmpDH(ctx, p, pSz, g, gSz); } } FreeDer(&der); #ifdef WOLFSSL_SMALL_STACK XFREE(p, NULL, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(g, NULL, DYNAMIC_TYPE_PUBLIC_KEY); #endif return ret; } /* server Diffie-Hellman parameters, WOLFSSL_SUCCESS on ok */ int wolfSSL_SetTmpDH_buffer(WOLFSSL* ssl, const unsigned char* buf, long sz, int format) { if (ssl == NULL) return BAD_FUNC_ARG; return wolfSSL_SetTmpDH_buffer_wrapper(ssl->ctx, ssl, buf, sz, format); } /* server ctx Diffie-Hellman parameters, WOLFSSL_SUCCESS on ok */ int wolfSSL_CTX_SetTmpDH_buffer(WOLFSSL_CTX* ctx, const unsigned char* buf, long sz, int format) { return wolfSSL_SetTmpDH_buffer_wrapper(ctx, NULL, buf, sz, format); } #endif /* NO_DH */ int wolfSSL_use_certificate_buffer(WOLFSSL* ssl, const unsigned char* in, long sz, int format) { WOLFSSL_ENTER("wolfSSL_use_certificate_buffer"); if (ssl == NULL) return BAD_FUNC_ARG; return ProcessBuffer(ssl->ctx, in, sz, format, CERT_TYPE, ssl, NULL, 0, GET_VERIFY_SETTING_SSL(ssl)); } int wolfSSL_use_PrivateKey_buffer(WOLFSSL* ssl, const unsigned char* in, long sz, int format) { WOLFSSL_ENTER("wolfSSL_use_PrivateKey_buffer"); if (ssl == NULL) return BAD_FUNC_ARG; return ProcessBuffer(ssl->ctx, in, sz, format, PRIVATEKEY_TYPE, ssl, NULL, 0, GET_VERIFY_SETTING_SSL(ssl)); } #ifdef HAVE_PKCS11 int wolfSSL_use_PrivateKey_id(WOLFSSL* ssl, const unsigned char* id, long sz, int devId, long keySz) { int ret = WOLFSSL_FAILURE; if (ssl->buffers.weOwnKey) FreeDer(&ssl->buffers.key); if (AllocDer(&ssl->buffers.key, (word32)sz, PRIVATEKEY_TYPE, ssl->heap) == 0) { XMEMCPY(ssl->buffers.key->buffer, id, sz); ssl->buffers.weOwnKey = 1; ssl->buffers.keyId = 1; ssl->buffers.keySz = (word32)keySz; if (devId != INVALID_DEVID) ssl->buffers.keyDevId = devId; else ssl->buffers.keyDevId = ssl->devId; ret = WOLFSSL_SUCCESS; } return ret; } #endif int wolfSSL_use_certificate_chain_buffer_format(WOLFSSL* ssl, const unsigned char* in, long sz, int format) { WOLFSSL_ENTER("wolfSSL_use_certificate_chain_buffer_format"); if (ssl == NULL) return BAD_FUNC_ARG; return ProcessBuffer(ssl->ctx, in, sz, format, CERT_TYPE, ssl, NULL, 1, GET_VERIFY_SETTING_SSL(ssl)); } int wolfSSL_use_certificate_chain_buffer(WOLFSSL* ssl, const unsigned char* in, long sz) { return wolfSSL_use_certificate_chain_buffer_format(ssl, in, sz, WOLFSSL_FILETYPE_PEM); } /* unload any certs or keys that SSL owns, leave CTX as is WOLFSSL_SUCCESS on ok */ int wolfSSL_UnloadCertsKeys(WOLFSSL* ssl) { if (ssl == NULL) { WOLFSSL_MSG("Null function arg"); return BAD_FUNC_ARG; } if (ssl->buffers.weOwnCert && !ssl->keepCert) { WOLFSSL_MSG("Unloading cert"); FreeDer(&ssl->buffers.certificate); #ifdef KEEP_OUR_CERT FreeX509(ssl->ourCert); if (ssl->ourCert) { XFREE(ssl->ourCert, ssl->heap, DYNAMIC_TYPE_X509); ssl->ourCert = NULL; } #endif ssl->buffers.weOwnCert = 0; } if (ssl->buffers.weOwnCertChain) { WOLFSSL_MSG("Unloading cert chain"); FreeDer(&ssl->buffers.certChain); ssl->buffers.weOwnCertChain = 0; } if (ssl->buffers.weOwnKey) { WOLFSSL_MSG("Unloading key"); FreeDer(&ssl->buffers.key); ssl->buffers.weOwnKey = 0; } return WOLFSSL_SUCCESS; } int wolfSSL_CTX_UnloadCAs(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_UnloadCAs"); if (ctx == NULL) return BAD_FUNC_ARG; return wolfSSL_CertManagerUnloadCAs(ctx->cm); } #ifdef WOLFSSL_TRUST_PEER_CERT int wolfSSL_CTX_Unload_trust_peers(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_Unload_trust_peers"); if (ctx == NULL) return BAD_FUNC_ARG; return wolfSSL_CertManagerUnload_trust_peers(ctx->cm); } #endif /* WOLFSSL_TRUST_PEER_CERT */ /* old NO_FILESYSTEM end */ #endif /* !NO_CERTS */ #ifdef OPENSSL_EXTRA int wolfSSL_add_all_algorithms(void) { WOLFSSL_ENTER("wolfSSL_add_all_algorithms"); if (wolfSSL_Init() == WOLFSSL_SUCCESS) return WOLFSSL_SUCCESS; else return WOLFSSL_FATAL_ERROR; } int wolfSSL_OpenSSL_add_all_algorithms_noconf(void) { WOLFSSL_ENTER("wolfSSL_OpenSSL_add_all_algorithms_noconf"); if (wolfSSL_add_all_algorithms() == WOLFSSL_FATAL_ERROR) return WOLFSSL_FATAL_ERROR; return WOLFSSL_SUCCESS; } int wolfSSL_OpenSSL_add_all_algorithms_conf(void) { WOLFSSL_ENTER("wolfSSL_OpenSSL_add_all_algorithms_conf"); /* This function is currently the same as wolfSSL_OpenSSL_add_all_algorithms_noconf since we do not employ the use of a wolfssl.cnf type configuration file and is only used for OpenSSL compatability. */ if (wolfSSL_add_all_algorithms() == WOLFSSL_FATAL_ERROR) { return WOLFSSL_FATAL_ERROR; } return WOLFSSL_SUCCESS; } /* returns previous set cache size which stays constant */ long wolfSSL_CTX_sess_set_cache_size(WOLFSSL_CTX* ctx, long sz) { /* cache size fixed at compile time in wolfSSL */ (void)ctx; (void)sz; WOLFSSL_MSG("session cache is set at compile time"); #ifndef NO_SESSION_CACHE return (long)(SESSIONS_PER_ROW * SESSION_ROWS); #else return 0; #endif } #endif #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EXTRA) void wolfSSL_CTX_set_quiet_shutdown(WOLFSSL_CTX* ctx, int mode) { WOLFSSL_ENTER("wolfSSL_CTX_set_quiet_shutdown"); if (mode) ctx->quietShutdown = 1; } void wolfSSL_set_quiet_shutdown(WOLFSSL* ssl, int mode) { WOLFSSL_ENTER("wolfSSL_CTX_set_quiet_shutdown"); if (mode) ssl->options.quietShutdown = 1; } #endif #ifdef OPENSSL_EXTRA void wolfSSL_set_bio(WOLFSSL* ssl, WOLFSSL_BIO* rd, WOLFSSL_BIO* wr) { WOLFSSL_ENTER("wolfSSL_set_bio"); if (ssl == NULL) { WOLFSSL_MSG("Bad argument, ssl was NULL"); return; } /* if WOLFSSL_BIO is socket type then set WOLFSSL socket to use */ if (rd != NULL && rd->type == WOLFSSL_BIO_SOCKET) { wolfSSL_set_rfd(ssl, rd->num); } if (wr != NULL && wr->type == WOLFSSL_BIO_SOCKET) { wolfSSL_set_wfd(ssl, wr->num); } /* free any existing WOLFSSL_BIOs in use */ if (ssl->biord != NULL) { if (ssl->biord != ssl->biowr) { if (ssl->biowr != NULL) { wolfSSL_BIO_free(ssl->biowr); ssl->biowr = NULL; } } wolfSSL_BIO_free(ssl->biord); ssl->biord = NULL; } ssl->biord = rd; ssl->biowr = wr; /* set SSL to use BIO callbacks instead */ if (((ssl->cbioFlag & WOLFSSL_CBIO_RECV) == 0) && (rd != NULL && rd->type != WOLFSSL_BIO_SOCKET)) { ssl->CBIORecv = BioReceive; } if (((ssl->cbioFlag & WOLFSSL_CBIO_SEND) == 0) && (wr != NULL && wr->type != WOLFSSL_BIO_SOCKET)) { ssl->CBIOSend = BioSend; } /* User programs should always retry reading from these BIOs */ if (rd) { /* User writes to rd */ BIO_set_retry_write(rd); } if (wr) { /* User reads from wr */ BIO_set_retry_read(wr); } } #endif #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EXTRA) || defined(HAVE_WEBSERVER) void wolfSSL_CTX_set_client_CA_list(WOLFSSL_CTX* ctx, WOLF_STACK_OF(WOLFSSL_X509_NAME)* names) { WOLFSSL_ENTER("wolfSSL_CTX_set_client_CA_list"); #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EXTRA) if (ctx != NULL) ctx->ca_names = names; #else (void)ctx; (void)names; #endif } /* returns the CA's set on server side or the CA's sent from server when * on client side */ #if defined(SESSION_CERTS) && defined(OPENSSL_ALL) WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_get_client_CA_list( const WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_client_CA_list"); if (ssl == NULL) { WOLFSSL_MSG("Bad argument passed to wolfSSL_get_client_CA_list"); return NULL; } /* return list of CAs sent from the server */ if (ssl->options.side == WOLFSSL_CLIENT_END) { WOLF_STACK_OF(WOLFSSL_X509)* sk; sk = wolfSSL_get_peer_cert_chain(ssl); if (sk != NULL) { WOLF_STACK_OF(WOLFSSL_X509_NAME)* ret; WOLFSSL_X509* x509; ret = wolfSSL_sk_X509_NAME_new(NULL); do { x509 = wolfSSL_sk_X509_pop(sk); if (x509 != NULL) { if (wolfSSL_X509_get_isCA(x509)) { if (wolfSSL_sk_X509_NAME_push(ret, wolfSSL_X509_get_subject_name(x509)) != 0) { WOLFSSL_MSG("Error pushing X509 name to stack"); /* continue on to try other certificates and * do not fail out here */ } } wolfSSL_X509_free(x509); } } while (x509 != NULL); wolfSSL_sk_X509_free(sk); return ret; } return NULL; } else { /* currently only can be set in the CTX */ return ssl->ctx->ca_names; } } #endif /* SESSION_CERTS */ #if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA) || \ defined(WOLFSSL_NGINX) || defined (WOLFSSL_HAPROXY) /* registers client cert callback, called during handshake if server requests client auth but user has not loaded client cert/key */ void wolfSSL_CTX_set_client_cert_cb(WOLFSSL_CTX *ctx, client_cert_cb cb) { WOLFSSL_ENTER("wolfSSL_CTX_set_client_cert_cb"); if (ctx != NULL) { ctx->CBClientCert = cb; } } #endif /* OPENSSL_ALL || OPENSSL_EXTRA || WOLFSSL_NGINX || WOLFSSL_HAPROXY */ #endif /* OPENSSL_EXTRA || WOLFSSL_EXTRA || HAVE_WEBSERVER */ #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EXTRA) WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_CTX_get_client_CA_list( const WOLFSSL_CTX *s) { WOLFSSL_ENTER("wolfSSL_CTX_get_client_CA_list"); if (s == NULL) return NULL; return s->ca_names; } #endif #if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER) #if !defined(NO_RSA) && !defined(NO_CERTS) WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_load_client_CA_file(const char* fname) { /* The webserver build is using this to load a CA into the server * for client authentication as an option. Have this return NULL in * that case. If OPENSSL_EXTRA is enabled, go ahead and include * the function. */ #ifdef OPENSSL_EXTRA WOLFSSL_STACK *list = NULL; WOLFSSL_STACK *node; WOLFSSL_BIO* bio; WOLFSSL_X509 *cert = NULL; WOLFSSL_X509_NAME *subjectName = NULL; unsigned long err; WOLFSSL_ENTER("wolfSSL_load_client_CA_file"); bio = wolfSSL_BIO_new_file(fname, "r"); if (bio == NULL) return NULL; /* Read each certificate in the chain out of the file. */ while (wolfSSL_PEM_read_bio_X509(bio, &cert, NULL, NULL) != NULL) { subjectName = wolfSSL_X509_get_subject_name(cert); if (subjectName == NULL) break; node = wolfSSL_sk_new_node(NULL); if (node == NULL) break; node->type = STACK_TYPE_X509_NAME; /* Need a persistent copy of the subject name. */ node->data.name = wolfSSL_X509_NAME_dup(subjectName); /* * Original cert will be freed so make sure not to try to access * it in the future. */ node->data.name->x509 = NULL; /* Put node on the front of the list. */ node->num = (list == NULL) ? 1 : list->num + 1; node->next = list; list = node; wolfSSL_X509_free(cert); cert = NULL; } err = wolfSSL_ERR_peek_last_error(); if (ERR_GET_LIB(err) == ERR_LIB_PEM && ERR_GET_REASON(err) == PEM_R_NO_START_LINE) { /* * wolfSSL_PEM_read_bio_X509 pushes an ASN_NO_PEM_HEADER error * to the error queue on file end. This should not be left * for the caller to find so we clear the last error. */ wc_RemoveErrorNode(-1); } wolfSSL_X509_free(cert); wolfSSL_BIO_free(bio); return list; #else (void)fname; return NULL; #endif } #endif #endif #ifdef OPENSSL_EXTRA #if !defined(NO_RSA) && !defined(NO_CERTS) int wolfSSL_CTX_add_client_CA(WOLFSSL_CTX* ctx, WOLFSSL_X509* x509) { WOLFSSL_STACK *node = NULL; WOLFSSL_X509_NAME *subjectName = NULL; WOLFSSL_ENTER("wolfSSL_CTX_add_client_CA"); if (ctx == NULL || x509 == NULL){ WOLFSSL_MSG("Bad argument"); return SSL_FAILURE; } subjectName = wolfSSL_X509_get_subject_name(x509); if (subjectName == NULL){ WOLFSSL_MSG("invalid x509 data"); return SSL_FAILURE; } /* Alloc stack struct */ node = (WOLF_STACK_OF(WOLFSSL_X509_NAME)*)XMALLOC( sizeof(WOLF_STACK_OF(WOLFSSL_X509_NAME)), NULL, DYNAMIC_TYPE_OPENSSL); if (node == NULL){ WOLFSSL_MSG("memory allocation error"); return SSL_FAILURE; } XMEMSET(node, 0, sizeof(WOLF_STACK_OF(WOLFSSL_X509_NAME))); /* Alloc and copy WOLFSSL_X509_NAME */ node->data.name = (WOLFSSL_X509_NAME*)XMALLOC( sizeof(WOLFSSL_X509_NAME), NULL, DYNAMIC_TYPE_OPENSSL); if (node->data.name == NULL) { XFREE(node, NULL, DYNAMIC_TYPE_OPENSSL); WOLFSSL_MSG("memory allocation error"); return SSL_FAILURE; } XMEMCPY(node->data.name, subjectName, sizeof(WOLFSSL_X509_NAME)); XMEMSET(subjectName, 0, sizeof(WOLFSSL_X509_NAME)); /* push new node onto head of stack */ node->num = (ctx->ca_names == NULL) ? 1 : ctx->ca_names->num + 1; node->next = ctx->ca_names; ctx->ca_names = node; return SSL_SUCCESS; } #endif #ifndef NO_WOLFSSL_STUB int wolfSSL_CTX_set_default_verify_paths(WOLFSSL_CTX* ctx) { /* TODO:, not needed in goahead */ (void)ctx; WOLFSSL_STUB("SSL_CTX_set_default_verify_paths"); return SSL_NOT_IMPLEMENTED; } #endif #if defined(WOLFCRYPT_HAVE_SRP) && !defined(NO_SHA256) \ && !defined(WC_NO_RNG) static const byte srp_N[] = { 0xEE, 0xAF, 0x0A, 0xB9, 0xAD, 0xB3, 0x8D, 0xD6, 0x9C, 0x33, 0xF8, 0x0A, 0xFA, 0x8F, 0xC5, 0xE8, 0x60, 0x72, 0x61, 0x87, 0x75, 0xFF, 0x3C, 0x0B, 0x9E, 0xA2, 0x31, 0x4C, 0x9C, 0x25, 0x65, 0x76, 0xD6, 0x74, 0xDF, 0x74, 0x96, 0xEA, 0x81, 0xD3, 0x38, 0x3B, 0x48, 0x13, 0xD6, 0x92, 0xC6, 0xE0, 0xE0, 0xD5, 0xD8, 0xE2, 0x50, 0xB9, 0x8B, 0xE4, 0x8E, 0x49, 0x5C, 0x1D, 0x60, 0x89, 0xDA, 0xD1, 0x5D, 0xC7, 0xD7, 0xB4, 0x61, 0x54, 0xD6, 0xB6, 0xCE, 0x8E, 0xF4, 0xAD, 0x69, 0xB1, 0x5D, 0x49, 0x82, 0x55, 0x9B, 0x29, 0x7B, 0xCF, 0x18, 0x85, 0xC5, 0x29, 0xF5, 0x66, 0x66, 0x0E, 0x57, 0xEC, 0x68, 0xED, 0xBC, 0x3C, 0x05, 0x72, 0x6C, 0xC0, 0x2F, 0xD4, 0xCB, 0xF4, 0x97, 0x6E, 0xAA, 0x9A, 0xFD, 0x51, 0x38, 0xFE, 0x83, 0x76, 0x43, 0x5B, 0x9F, 0xC6, 0x1D, 0x2F, 0xC0, 0xEB, 0x06, 0xE3 }; static const byte srp_g[] = { 0x02 }; int wolfSSL_CTX_set_srp_username(WOLFSSL_CTX* ctx, char* username) { int r = 0; SrpSide srp_side = SRP_CLIENT_SIDE; WC_RNG rng; byte salt[SRP_SALT_SIZE]; WOLFSSL_ENTER("wolfSSL_CTX_set_srp_username"); if (ctx == NULL || ctx->srp == NULL || username==NULL) return SSL_FAILURE; if (ctx->method->side == WOLFSSL_SERVER_END){ srp_side = SRP_SERVER_SIDE; } else if (ctx->method->side == WOLFSSL_CLIENT_END){ srp_side = SRP_CLIENT_SIDE; } else { WOLFSSL_MSG("Init CTX failed"); return SSL_FAILURE; } if (wc_SrpInit(ctx->srp, SRP_TYPE_SHA256, srp_side) < 0){ WOLFSSL_MSG("Init CTX failed"); XFREE(ctx->srp, ctx->heap, DYNAMIC_TYPE_SRP); wolfSSL_CTX_free(ctx); return SSL_FAILURE; } r = wc_SrpSetUsername(ctx->srp, (const byte*)username, (word32)XSTRLEN(username)); if (r < 0) { WOLFSSL_MSG("fail to set srp username."); return SSL_FAILURE; } /* if wolfSSL_CTX_set_srp_password has already been called, */ /* execute wc_SrpSetPassword here */ if (ctx->srp_password != NULL){ if (wc_InitRng(&rng) < 0){ WOLFSSL_MSG("wc_InitRng failed"); return SSL_FAILURE; } XMEMSET(salt, 0, sizeof(salt)/sizeof(salt[0])); if (wc_RNG_GenerateBlock(&rng, salt, sizeof(salt)/sizeof(salt[0])) < 0){ WOLFSSL_MSG("wc_RNG_GenerateBlock failed"); wc_FreeRng(&rng); return SSL_FAILURE; } if (wc_SrpSetParams(ctx->srp, srp_N, sizeof(srp_N)/sizeof(srp_N[0]), srp_g, sizeof(srp_g)/sizeof(srp_g[0]), salt, sizeof(salt)/sizeof(salt[0])) < 0){ WOLFSSL_MSG("wc_SrpSetParam failed"); wc_FreeRng(&rng); return SSL_FAILURE; } r = wc_SrpSetPassword(ctx->srp, (const byte*)ctx->srp_password, (word32)XSTRLEN((char *)ctx->srp_password)); if (r < 0) { WOLFSSL_MSG("fail to set srp password."); return SSL_FAILURE; } wc_FreeRng(&rng); XFREE(ctx->srp_password, ctx->heap, DYNAMIC_TYPE_SRP); ctx->srp_password = NULL; } return SSL_SUCCESS; } int wolfSSL_CTX_set_srp_password(WOLFSSL_CTX* ctx, char* password) { int r; WC_RNG rng; byte salt[SRP_SALT_SIZE]; WOLFSSL_ENTER("wolfSSL_CTX_set_srp_password"); if (ctx == NULL || ctx->srp == NULL || password == NULL) return SSL_FAILURE; if (ctx->srp->user != NULL){ if (wc_InitRng(&rng) < 0){ WOLFSSL_MSG("wc_InitRng failed"); return SSL_FAILURE; } XMEMSET(salt, 0, sizeof(salt)/sizeof(salt[0])); if (wc_RNG_GenerateBlock(&rng, salt, sizeof(salt)/sizeof(salt[0])) < 0){ WOLFSSL_MSG("wc_RNG_GenerateBlock failed"); wc_FreeRng(&rng); return SSL_FAILURE; } if (wc_SrpSetParams(ctx->srp, srp_N, sizeof(srp_N)/sizeof(srp_N[0]), srp_g, sizeof(srp_g)/sizeof(srp_g[0]), salt, sizeof(salt)/sizeof(salt[0])) < 0){ WOLFSSL_MSG("wc_SrpSetParam failed"); wc_FreeRng(&rng); return SSL_FAILURE; } r = wc_SrpSetPassword(ctx->srp, (const byte*)password, (word32)XSTRLEN(password)); if (r < 0) { WOLFSSL_MSG("wc_SrpSetPassword failed."); wc_FreeRng(&rng); return SSL_FAILURE; } if (ctx->srp_password != NULL){ XFREE(ctx->srp_password,NULL, DYNAMIC_TYPE_SRP); ctx->srp_password = NULL; } wc_FreeRng(&rng); } else { /* save password for wolfSSL_set_srp_username */ if (ctx->srp_password != NULL) XFREE(ctx->srp_password,ctx->heap, DYNAMIC_TYPE_SRP); ctx->srp_password = (byte*)XMALLOC(XSTRLEN(password) + 1, ctx->heap, DYNAMIC_TYPE_SRP); if (ctx->srp_password == NULL){ WOLFSSL_MSG("memory allocation error"); return SSL_FAILURE; } XMEMCPY(ctx->srp_password, password, XSTRLEN(password) + 1); } return SSL_SUCCESS; } #endif /* WOLFCRYPT_HAVE_SRP && !NO_SHA256 && !WC_NO_RNG */ /* keyblock size in bytes or -1 */ int wolfSSL_get_keyblock_size(WOLFSSL* ssl) { if (ssl == NULL) return WOLFSSL_FATAL_ERROR; return 2 * (ssl->specs.key_size + ssl->specs.iv_size + ssl->specs.hash_size); } /* store keys returns WOLFSSL_SUCCESS or -1 on error */ int wolfSSL_get_keys(WOLFSSL* ssl, unsigned char** ms, unsigned int* msLen, unsigned char** sr, unsigned int* srLen, unsigned char** cr, unsigned int* crLen) { if (ssl == NULL || ssl->arrays == NULL) return WOLFSSL_FATAL_ERROR; *ms = ssl->arrays->masterSecret; *sr = ssl->arrays->serverRandom; *cr = ssl->arrays->clientRandom; *msLen = SECRET_LEN; *srLen = RAN_LEN; *crLen = RAN_LEN; return WOLFSSL_SUCCESS; } #endif /* OPENSSL_EXTRA */ #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EXTRA) void wolfSSL_set_accept_state(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_set_accept_state"); if (ssl->options.side == WOLFSSL_CLIENT_END) { #ifdef HAVE_ECC ecc_key key; word32 idx = 0; if (ssl->options.haveStaticECC && ssl->buffers.key != NULL) { if (wc_ecc_init(&key) >= 0) { if (wc_EccPrivateKeyDecode(ssl->buffers.key->buffer, &idx, &key, ssl->buffers.key->length) != 0) { ssl->options.haveECDSAsig = 0; ssl->options.haveECC = 0; ssl->options.haveStaticECC = 0; } wc_ecc_free(&key); } } #endif #ifndef NO_DH if (!ssl->options.haveDH && ssl->ctx->haveDH) { ssl->buffers.serverDH_P = ssl->ctx->serverDH_P; ssl->buffers.serverDH_G = ssl->ctx->serverDH_G; ssl->options.haveDH = 1; } #endif } if (InitSSL_Side(ssl, WOLFSSL_SERVER_END) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error initializing server side"); } } #endif /* OPENSSL_EXTRA || WOLFSSL_EXTRA */ /* return true if connection established */ int wolfSSL_is_init_finished(WOLFSSL* ssl) { if (ssl == NULL) return 0; if (ssl->options.handShakeState == HANDSHAKE_DONE) return 1; return 0; } #ifdef OPENSSL_EXTRA void wolfSSL_CTX_set_tmp_rsa_callback(WOLFSSL_CTX* ctx, WOLFSSL_RSA*(*f)(WOLFSSL*, int, int)) { /* wolfSSL verifies all these internally */ (void)ctx; (void)f; } void wolfSSL_set_shutdown(WOLFSSL* ssl, int opt) { WOLFSSL_ENTER("wolfSSL_set_shutdown"); if(ssl==NULL) { WOLFSSL_MSG("Shutdown not set. ssl is null"); return; } ssl->options.sentNotify = (opt&WOLFSSL_SENT_SHUTDOWN) > 0; ssl->options.closeNotify = (opt&WOLFSSL_RECEIVED_SHUTDOWN) > 0; } long wolfSSL_CTX_get_options(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_get_options"); WOLFSSL_MSG("wolfSSL options are set through API calls and macros"); if(ctx == NULL) return BAD_FUNC_ARG; return ctx->mask; } #endif #if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER) static long wolf_set_options(long old_op, long op); long wolfSSL_CTX_set_options(WOLFSSL_CTX* ctx, long opt) { WOLFSSL_ENTER("SSL_CTX_set_options"); if (ctx == NULL) return BAD_FUNC_ARG; ctx->mask = wolf_set_options(ctx->mask, opt); return ctx->mask; } #endif #ifdef OPENSSL_EXTRA long wolfSSL_CTX_clear_options(WOLFSSL_CTX* ctx, long opt) { WOLFSSL_ENTER("SSL_CTX_clear_options"); if(ctx == NULL) return BAD_FUNC_ARG; ctx->mask &= ~opt; return ctx->mask; } int wolfSSL_set_rfd(WOLFSSL* ssl, int rfd) { WOLFSSL_ENTER("SSL_set_rfd"); ssl->rfd = rfd; /* not used directly to allow IO callbacks */ ssl->IOCB_ReadCtx = &ssl->rfd; return WOLFSSL_SUCCESS; } int wolfSSL_set_wfd(WOLFSSL* ssl, int wfd) { WOLFSSL_ENTER("SSL_set_wfd"); ssl->wfd = wfd; /* not used directly to allow IO callbacks */ ssl->IOCB_WriteCtx = &ssl->wfd; return WOLFSSL_SUCCESS; } #ifndef NO_CERTS WOLFSSL_X509_STORE* wolfSSL_CTX_get_cert_store(WOLFSSL_CTX* ctx) { if (ctx == NULL) { return NULL; } return &ctx->x509_store; } void wolfSSL_CTX_set_cert_store(WOLFSSL_CTX* ctx, WOLFSSL_X509_STORE* str) { if (ctx == NULL || str == NULL) { return; } /* free cert manager if have one */ if (ctx->cm != NULL) { wolfSSL_CertManagerFree(ctx->cm); } ctx->cm = str->cm; /* free existing store if it exists */ if (ctx->x509_store_pt != NULL) { /* cert manager was free'd a little earlier in this function */ ctx->x509_store_pt->cm = NULL; } wolfSSL_X509_STORE_free(ctx->x509_store_pt); ctx->x509_store.cache = str->cache; ctx->x509_store_pt = str; /* take ownership of store and free it with CTX free */ } WOLFSSL_X509* wolfSSL_X509_STORE_CTX_get_current_cert( WOLFSSL_X509_STORE_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_get_current_cert"); if (ctx) return ctx->current_cert; return NULL; } int wolfSSL_X509_STORE_CTX_get_error(WOLFSSL_X509_STORE_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_get_error"); if (ctx != NULL) return ctx->error; return 0; } int wolfSSL_X509_STORE_CTX_get_error_depth(WOLFSSL_X509_STORE_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_get_error_depth"); if(ctx) return ctx->error_depth; return WOLFSSL_FATAL_ERROR; } void wolfSSL_X509_STORE_CTX_set_verify_cb(WOLFSSL_X509_STORE_CTX *ctx, WOLFSSL_X509_STORE_CTX_verify_cb verify_cb) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_set_verify_cb"); if(ctx == NULL) return; ctx->verify_cb = verify_cb; } #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) void wolfSSL_X509_STORE_set_verify_cb(WOLFSSL_X509_STORE *st, WOLFSSL_X509_STORE_CTX_verify_cb verify_cb) { WOLFSSL_ENTER("WOLFSSL_X509_STORE_set_verify_cb"); if (st != NULL) { st->verify_cb = verify_cb; } } #endif #endif /* !NO_CERTS */ WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_md(void) { static WOLFSSL_BIO_METHOD meth; WOLFSSL_ENTER("wolfSSL_BIO_f_md"); meth.type = WOLFSSL_BIO_MD; return &meth; } /* return the context and initialize the BIO state */ int wolfSSL_BIO_get_md_ctx(WOLFSSL_BIO *bio, WOLFSSL_EVP_MD_CTX **mdcp) { int ret = WOLFSSL_FAILURE; if ((bio != NULL) && (mdcp != NULL)) { *mdcp = (WOLFSSL_EVP_MD_CTX*)bio->ptr; ret = WOLFSSL_SUCCESS; } return ret; } WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_buffer(void) { static WOLFSSL_BIO_METHOD meth; WOLFSSL_ENTER("BIO_f_buffer"); meth.type = WOLFSSL_BIO_BUFFER; return &meth; } #ifndef NO_WOLFSSL_STUB long wolfSSL_BIO_set_write_buffer_size(WOLFSSL_BIO* bio, long size) { /* wolfSSL has internal buffer, compatibility only */ WOLFSSL_ENTER("BIO_set_write_buffer_size"); WOLFSSL_STUB("BIO_set_write_buffer_size"); (void)bio; return size; } #endif WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_bio(void) { static WOLFSSL_BIO_METHOD bio_meth; WOLFSSL_ENTER("wolfSSL_BIO_s_bio"); bio_meth.type = WOLFSSL_BIO_BIO; return &bio_meth; } #ifndef NO_FILESYSTEM WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_file(void) { static WOLFSSL_BIO_METHOD file_meth; WOLFSSL_ENTER("wolfSSL_BIO_s_file"); file_meth.type = WOLFSSL_BIO_FILE; return &file_meth; } #endif WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_ssl(void) { static WOLFSSL_BIO_METHOD meth; WOLFSSL_ENTER("wolfSSL_BIO_f_ssl"); meth.type = WOLFSSL_BIO_SSL; return &meth; } WOLFSSL_BIO_METHOD *wolfSSL_BIO_s_socket(void) { static WOLFSSL_BIO_METHOD meth; WOLFSSL_ENTER("wolfSSL_BIO_s_socket"); meth.type = WOLFSSL_BIO_SOCKET; return &meth; } WOLFSSL_BIO* wolfSSL_BIO_new_socket(int sfd, int closeF) { WOLFSSL_BIO* bio = wolfSSL_BIO_new(wolfSSL_BIO_s_socket()); WOLFSSL_ENTER("BIO_new_socket"); if (bio) { bio->type = WOLFSSL_BIO_SOCKET; bio->shutdown = (byte)closeF; bio->num = sfd; } return bio; } int wolfSSL_BIO_eof(WOLFSSL_BIO* b) { WOLFSSL_ENTER("BIO_eof"); if ((b != NULL) && (b->eof)) return 1; return 0; } long wolfSSL_BIO_set_ssl(WOLFSSL_BIO* b, WOLFSSL* ssl, int closeF) { WOLFSSL_ENTER("wolfSSL_BIO_set_ssl"); if (b != NULL) { b->ptr = ssl; b->shutdown = (byte)closeF; /* add to ssl for bio free if SSL_free called before/instead of free_all? */ } return 0; } #ifndef NO_FILESYSTEM long wolfSSL_BIO_set_fd(WOLFSSL_BIO* b, int fd, int closeF) { WOLFSSL_ENTER("wolfSSL_BIO_set_fd"); if (b != NULL) { b->num = fd; b->shutdown = (byte)closeF; } return WOLFSSL_SUCCESS; } #endif /* Sets the close flag */ int wolfSSL_BIO_set_close(WOLFSSL_BIO *b, long flag) { WOLFSSL_ENTER("wolfSSL_BIO_set_close"); if (b != NULL) { b->shutdown = (byte)flag; } return WOLFSSL_SUCCESS; } WOLFSSL_BIO* wolfSSL_BIO_new(WOLFSSL_BIO_METHOD* method) { WOLFSSL_BIO* bio; WOLFSSL_ENTER("wolfSSL_BIO_new"); if (method == NULL) { WOLFSSL_MSG("Bad method pointer passed in"); return NULL; } bio = (WOLFSSL_BIO*) XMALLOC(sizeof(WOLFSSL_BIO), 0, DYNAMIC_TYPE_OPENSSL); if (bio) { XMEMSET(bio, 0, sizeof(WOLFSSL_BIO)); bio->type = (byte)method->type; bio->method = method; bio->shutdown = BIO_CLOSE; /* default to close things */ bio->init = 1; if (method->type != WOLFSSL_BIO_FILE && method->type != WOLFSSL_BIO_SOCKET && method->type != WOLFSSL_BIO_MD) { bio->mem_buf =(WOLFSSL_BUF_MEM*)XMALLOC(sizeof(WOLFSSL_BUF_MEM), 0, DYNAMIC_TYPE_OPENSSL); if (bio->mem_buf == NULL) { WOLFSSL_MSG("Memory error"); wolfSSL_BIO_free(bio); return NULL; } bio->mem_buf->data = (char*)bio->ptr; } if (method->type == WOLFSSL_BIO_MD) { bio->ptr = wolfSSL_EVP_MD_CTX_new(); if (bio->ptr == NULL) { WOLFSSL_MSG("Memory error"); wolfSSL_BIO_free(bio); return NULL; } } /* check if is custom method */ if (method->createCb) { method->createCb(bio); } } return bio; } WOLFSSL_BIO* wolfSSL_BIO_new_mem_buf(const void* buf, int len) { WOLFSSL_BIO* bio = NULL; if (buf == NULL || len < 0) { return bio; } bio = wolfSSL_BIO_new(wolfSSL_BIO_s_mem()); if (bio == NULL) { return bio; } bio->num = bio->wrSz = len; bio->ptr = (byte*)XMALLOC(len, 0, DYNAMIC_TYPE_OPENSSL); if (bio->ptr == NULL) { wolfSSL_BIO_free(bio); return NULL; } if (bio->mem_buf != NULL) { bio->mem_buf->data = (char*)bio->ptr; bio->mem_buf->length = bio->num; } XMEMCPY(bio->ptr, buf, len); return bio; } /* * Note : If the flag BIO_NOCLOSE is set then freeing memory buffers is up * to the application. * Returns 1 on success, 0 on failure */ int wolfSSL_BIO_free(WOLFSSL_BIO* bio) { int ret; /* unchain?, doesn't matter in goahead since from free all */ WOLFSSL_ENTER("wolfSSL_BIO_free"); if (bio) { if (bio->infoCb) { /* info callback is called before free */ ret = (int)bio->infoCb(bio, WOLFSSL_BIO_CB_FREE, NULL, 0, 0, 1); if (ret <= 0) { return ret; } } /* call custom set free callback */ if (bio->method && bio->method->freeCb) { bio->method->freeCb(bio); } /* remove from pair by setting the paired bios pair to NULL */ if (bio->pair != NULL) { bio->pair->pair = NULL; } if (bio->shutdown) { if (bio->type == WOLFSSL_BIO_SSL && bio->ptr) wolfSSL_free((WOLFSSL*)bio->ptr); #ifdef CloseSocket if (bio->type == WOLFSSL_BIO_SOCKET && bio->num) CloseSocket(bio->num); #endif } #ifndef NO_FILESYSTEM if (bio->type == WOLFSSL_BIO_FILE && bio->shutdown == BIO_CLOSE) { if (bio->ptr) { XFCLOSE((XFILE)bio->ptr); } } #endif if (bio->shutdown != BIO_NOCLOSE) { if (bio->type == WOLFSSL_BIO_MEMORY && bio->ptr != NULL) { if (bio->mem_buf != NULL) { if (bio->mem_buf->data != (char*)bio->ptr) { XFREE(bio->ptr, bio->heap, DYNAMIC_TYPE_OPENSSL); bio->ptr = NULL; } } else { XFREE(bio->ptr, bio->heap, DYNAMIC_TYPE_OPENSSL); bio->ptr = NULL; } } if (bio->mem_buf != NULL) { wolfSSL_BUF_MEM_free(bio->mem_buf); bio->mem_buf = NULL; } } if (bio->type == WOLFSSL_BIO_MD) { wolfSSL_EVP_MD_CTX_free((WOLFSSL_EVP_MD_CTX*)bio->ptr); } XFREE(bio, 0, DYNAMIC_TYPE_OPENSSL); } return 1; } /* like BIO_free, but no return value */ void wolfSSL_BIO_vfree(WOLFSSL_BIO* bio) { wolfSSL_BIO_free(bio); } int wolfSSL_BIO_free_all(WOLFSSL_BIO* bio) { WOLFSSL_ENTER("BIO_free_all"); while (bio) { WOLFSSL_BIO* next = bio->next; wolfSSL_BIO_free(bio); bio = next; } return 0; } WOLFSSL_BIO* wolfSSL_BIO_push(WOLFSSL_BIO* top, WOLFSSL_BIO* append) { WOLFSSL_ENTER("BIO_push"); top->next = append; append->prev = top; return top; } #endif /* OPENSSL_EXTRA */ #ifdef WOLFSSL_ENCRYPTED_KEYS void wolfSSL_CTX_set_default_passwd_cb_userdata(WOLFSSL_CTX* ctx, void* userdata) { WOLFSSL_ENTER("SSL_CTX_set_default_passwd_cb_userdata"); if (ctx) ctx->passwd_userdata = userdata; } void wolfSSL_CTX_set_default_passwd_cb(WOLFSSL_CTX* ctx,pem_password_cb* cb) { WOLFSSL_ENTER("SSL_CTX_set_default_passwd_cb"); if (ctx) ctx->passwd_cb = cb; } pem_password_cb* wolfSSL_CTX_get_default_passwd_cb(WOLFSSL_CTX *ctx) { if (ctx == NULL || ctx->passwd_cb == NULL) { return NULL; } return ctx->passwd_cb; } void* wolfSSL_CTX_get_default_passwd_cb_userdata(WOLFSSL_CTX *ctx) { if (ctx == NULL) { return NULL; } return ctx->passwd_userdata; } #endif /* WOLFSSL_ENCRYPTED_KEYS */ #if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER) int wolfSSL_num_locks(void) { return 0; } void wolfSSL_set_locking_callback(void (*f)(int, int, const char*, int)) { WOLFSSL_ENTER("wolfSSL_set_locking_callback"); if (wc_SetMutexCb(f) != 0) { WOLFSSL_MSG("Error when setting mutex call back"); } } typedef unsigned long (idCb)(void); static idCb* inner_idCb = NULL; unsigned long wolfSSL_thread_id(void) { if (inner_idCb != NULL) { return inner_idCb(); } else { return 0; } } void wolfSSL_set_id_callback(unsigned long (*f)(void)) { inner_idCb = f; } unsigned long wolfSSL_ERR_get_error(void) { WOLFSSL_ENTER("wolfSSL_ERR_get_error"); #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) { unsigned long ret = wolfSSL_ERR_peek_error_line_data(NULL, NULL, NULL, NULL); wc_RemoveErrorNode(-1); return ret; } #elif (defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)) { int ret = wc_PullErrorNode(NULL, NULL, NULL); if (ret < 0) { if (ret == BAD_STATE_E) return 0; /* no errors in queue */ WOLFSSL_MSG("Error with pulling error node!"); WOLFSSL_LEAVE("wolfSSL_ERR_get_error", ret); ret = 0 - ret; /* return absolute value of error */ /* panic and try to clear out nodes */ wc_ClearErrorNodes(); } return (unsigned long)ret; } #else return (unsigned long)(0 - NOT_COMPILED_IN); #endif } #if (defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)) /* print out and clear all errors */ void wolfSSL_ERR_print_errors(WOLFSSL_BIO* bio) { const char* file = NULL; const char* reason = NULL; int ret; int line = 0; char buf[WOLFSSL_MAX_ERROR_SZ * 2]; WOLFSSL_ENTER("wolfSSL_ERR_print_errors"); if (bio == NULL) { WOLFSSL_MSG("BIO passed in was null"); return; } do { ret = wc_PeekErrorNode(0, &file, &reason, &line); if (ret >= 0) { const char* r = wolfSSL_ERR_reason_error_string(0 - ret); XSNPRINTF(buf, sizeof(buf), "error:%d:wolfSSL library:%s:%s:%d\n", ret, r, file, line); wolfSSL_BIO_write(bio, buf, (int)XSTRLEN(buf)); wc_RemoveErrorNode(0); } } while (ret >= 0); } #endif /* OPENSSL_EXTRA || DEBUG_WOLFSSL_VERBOSE */ #endif /* OPENSSL_EXTRA || HAVE_WEBSERVER */ #ifdef OPENSSL_EXTRA #if !defined(NO_WOLFSSL_SERVER) size_t wolfSSL_get_server_random(const WOLFSSL *ssl, unsigned char *out, size_t outSz) { size_t size; /* return max size of buffer */ if (outSz == 0) { return RAN_LEN; } if (ssl == NULL || out == NULL) { return 0; } if (ssl->options.saveArrays == 0 || ssl->arrays == NULL) { WOLFSSL_MSG("Arrays struct not saved after handshake"); return 0; } if (outSz > RAN_LEN) { size = RAN_LEN; } else { size = outSz; } XMEMCPY(out, ssl->arrays->serverRandom, size); return size; } /* Used to get the peer ephemeral public key sent during the connection * NOTE: currently wolfSSL_KeepHandshakeResources(WOLFSSL* ssl) must be called * before the ephemeral key is stored. * return WOLFSSL_SUCCESS on success */ int wolfSSL_get_server_tmp_key(const WOLFSSL* ssl, WOLFSSL_EVP_PKEY** pkey) { WOLFSSL_EVP_PKEY* ret = NULL; WOLFSSL_ENTER("wolfSSL_get_server_tmp_key"); if (ssl == NULL || pkey == NULL) { WOLFSSL_MSG("Bad argument passed in"); return WOLFSSL_FAILURE; } #ifdef HAVE_ECC if (ssl->peerEccKey != NULL) { unsigned char* der; const unsigned char* pt; unsigned int derSz = 0; int sz; if (wc_ecc_export_x963(ssl->peerEccKey, NULL, &derSz) != LENGTH_ONLY_E) { WOLFSSL_MSG("get ecc der size failed"); return WOLFSSL_FAILURE; } derSz += MAX_SEQ_SZ + (2 * MAX_ALGO_SZ) + MAX_SEQ_SZ + TRAILING_ZERO; der = (unsigned char*)XMALLOC(derSz, ssl->heap, DYNAMIC_TYPE_KEY); if (der == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } if ((sz = wc_EccPublicKeyToDer(ssl->peerEccKey, der, derSz, 1)) <= 0) { WOLFSSL_MSG("get ecc der failed"); XFREE(der, ssl->heap, DYNAMIC_TYPE_KEY); return WOLFSSL_FAILURE; } pt = der; /* in case pointer gets advanced */ ret = wolfSSL_d2i_PUBKEY(NULL, &pt, sz); XFREE(der, ssl->heap, DYNAMIC_TYPE_KEY); } #endif *pkey = ret; if (ret == NULL) return WOLFSSL_FAILURE; else return WOLFSSL_SUCCESS; } #endif /* !NO_WOLFSSL_SERVER */ int wolfSSL_CTX_set_min_proto_version(WOLFSSL_CTX* ctx, int version) { WOLFSSL_ENTER("wolfSSL_CTX_set_min_proto_version"); if (ctx == NULL) { return BAD_FUNC_ARG; } switch (version) { #if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS) case SSL3_VERSION: ctx->minDowngrade = SSLv3_MINOR; break; #endif #ifndef NO_TLS #ifndef NO_OLD_TLS #ifdef WOLFSSL_ALLOW_TLSV10 case TLS1_VERSION: ctx->minDowngrade = TLSv1_MINOR; break; #endif case TLS1_1_VERSION: ctx->minDowngrade = TLSv1_1_MINOR; break; #endif #ifndef WOLFSSL_NO_TLS12 case TLS1_2_VERSION: ctx->minDowngrade = TLSv1_2_MINOR; break; #endif #ifdef WOLFSSL_TLS13 case TLS1_3_VERSION: ctx->minDowngrade = TLSv1_3_MINOR; break; #endif #endif #ifdef WOLFSSL_DTLS #ifndef NO_OLD_TLS case DTLS1_VERSION: ctx->minDowngrade = DTLS_MINOR; break; #endif case DTLS1_2_VERSION: ctx->minDowngrade = DTLSv1_2_MINOR; break; #endif default: return BAD_FUNC_ARG; } return WOLFSSL_SUCCESS; } int wolfSSL_CTX_set_max_proto_version(WOLFSSL_CTX* ctx, int ver) { WOLFSSL_ENTER("wolfSSL_CTX_set_max_proto_version"); /* supported only at compile-time only */ (void)ctx; (void)ver; return WOLFSSL_SUCCESS; } #if !defined(NO_WOLFSSL_CLIENT) /* Return the amount of random bytes copied over or error case. * ssl : ssl struct after handshake * out : buffer to hold random bytes * outSz : either 0 (return max buffer sz) or size of out buffer * * NOTE: wolfSSL_KeepArrays(ssl) must be called to retain handshake information. */ size_t wolfSSL_get_client_random(const WOLFSSL* ssl, unsigned char* out, size_t outSz) { size_t size; /* return max size of buffer */ if (outSz == 0) { return RAN_LEN; } if (ssl == NULL || out == NULL) { return 0; } if (ssl->options.saveArrays == 0 || ssl->arrays == NULL) { WOLFSSL_MSG("Arrays struct not saved after handshake"); return 0; } if (outSz > RAN_LEN) { size = RAN_LEN; } else { size = outSz; } XMEMCPY(out, ssl->arrays->clientRandom, size); return size; } #endif /* !NO_WOLFSSL_CLIENT */ unsigned long wolfSSLeay(void) { return SSLEAY_VERSION_NUMBER; } unsigned long wolfSSL_OpenSSL_version_num(void) { return OPENSSL_VERSION_NUMBER; } const char* wolfSSLeay_version(int type) { static const char* version = "SSLeay wolfSSL compatibility"; (void)type; return version; } #ifndef NO_MD5 int wolfSSL_MD5_Init(WOLFSSL_MD5_CTX* md5) { int ret; typedef char md5_test[sizeof(MD5_CTX) >= sizeof(wc_Md5) ? 1 : -1]; (void)sizeof(md5_test); WOLFSSL_ENTER("MD5_Init"); ret = wc_InitMd5((wc_Md5*)md5); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_MD5_Update(WOLFSSL_MD5_CTX* md5, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("wolfSSL_MD5_Update"); ret = wc_Md5Update((wc_Md5*)md5, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_MD5_Final(byte* input, WOLFSSL_MD5_CTX* md5) { int ret; WOLFSSL_ENTER("MD5_Final"); ret = wc_Md5Final((wc_Md5*)md5, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } #endif /* !NO_MD5 */ #ifndef NO_SHA int wolfSSL_SHA_Init(WOLFSSL_SHA_CTX* sha) { int ret; typedef char sha_test[sizeof(SHA_CTX) >= sizeof(wc_Sha) ? 1 : -1]; (void)sizeof(sha_test); WOLFSSL_ENTER("SHA_Init"); ret = wc_InitSha((wc_Sha*)sha); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA_Update(WOLFSSL_SHA_CTX* sha, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("SHA_Update"); ret = wc_ShaUpdate((wc_Sha*)sha, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA_Final(byte* input, WOLFSSL_SHA_CTX* sha) { int ret; WOLFSSL_ENTER("SHA_Final"); ret = wc_ShaFinal((wc_Sha*)sha, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA1_Init(WOLFSSL_SHA_CTX* sha) { WOLFSSL_ENTER("SHA1_Init"); return SHA_Init(sha); } int wolfSSL_SHA1_Update(WOLFSSL_SHA_CTX* sha, const void* input, unsigned long sz) { WOLFSSL_ENTER("SHA1_Update"); return SHA_Update(sha, input, sz); } int wolfSSL_SHA1_Final(byte* input, WOLFSSL_SHA_CTX* sha) { WOLFSSL_ENTER("SHA1_Final"); return SHA_Final(input, sha); } #endif /* !NO_SHA */ #ifdef WOLFSSL_SHA224 int wolfSSL_SHA224_Init(WOLFSSL_SHA224_CTX* sha) { int ret; typedef char sha_test[sizeof(SHA224_CTX) >= sizeof(wc_Sha224) ? 1 : -1]; (void)sizeof(sha_test); WOLFSSL_ENTER("SHA224_Init"); ret = wc_InitSha224((wc_Sha224*)sha); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA224_Update(WOLFSSL_SHA224_CTX* sha, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("SHA224_Update"); ret = wc_Sha224Update((wc_Sha224*)sha, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA224_Final(byte* input, WOLFSSL_SHA224_CTX* sha) { int ret; WOLFSSL_ENTER("SHA224_Final"); ret = wc_Sha224Final((wc_Sha224*)sha, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } #endif /* WOLFSSL_SHA224 */ int wolfSSL_SHA256_Init(WOLFSSL_SHA256_CTX* sha256) { int ret; typedef char sha_test[sizeof(SHA256_CTX) >= sizeof(wc_Sha256) ? 1 : -1]; (void)sizeof(sha_test); WOLFSSL_ENTER("SHA256_Init"); ret = wc_InitSha256((wc_Sha256*)sha256); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA256_Update(WOLFSSL_SHA256_CTX* sha, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("SHA256_Update"); ret = wc_Sha256Update((wc_Sha256*)sha, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA256_Final(byte* input, WOLFSSL_SHA256_CTX* sha) { int ret; WOLFSSL_ENTER("SHA256_Final"); ret = wc_Sha256Final((wc_Sha256*)sha, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } #ifdef WOLFSSL_SHA384 int wolfSSL_SHA384_Init(WOLFSSL_SHA384_CTX* sha) { int ret; typedef char sha_test[sizeof(SHA384_CTX) >= sizeof(wc_Sha384) ? 1 : -1]; (void)sizeof(sha_test); WOLFSSL_ENTER("SHA384_Init"); ret = wc_InitSha384((wc_Sha384*)sha); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA384_Update(WOLFSSL_SHA384_CTX* sha, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("SHA384_Update"); ret = wc_Sha384Update((wc_Sha384*)sha, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA384_Final(byte* input, WOLFSSL_SHA384_CTX* sha) { int ret; WOLFSSL_ENTER("SHA384_Final"); ret = wc_Sha384Final((wc_Sha384*)sha, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } #endif /* WOLFSSL_SHA384 */ #ifdef WOLFSSL_SHA512 int wolfSSL_SHA512_Init(WOLFSSL_SHA512_CTX* sha) { int ret; typedef char sha_test[sizeof(SHA512_CTX) >= sizeof(wc_Sha512) ? 1 : -1]; (void)sizeof(sha_test); WOLFSSL_ENTER("SHA512_Init"); ret = wc_InitSha512((wc_Sha512*)sha); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA512_Update(WOLFSSL_SHA512_CTX* sha, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("SHA512_Update"); ret = wc_Sha512Update((wc_Sha512*)sha, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA512_Final(byte* input, WOLFSSL_SHA512_CTX* sha) { int ret; WOLFSSL_ENTER("SHA512_Final"); ret = wc_Sha512Final((wc_Sha512*)sha, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } #endif /* WOLFSSL_SHA512 */ #ifdef WOLFSSL_SHA3 #ifndef WOLFSSL_NOSHA3_224 int wolfSSL_SHA3_224_Init(WOLFSSL_SHA3_224_CTX* sha) { int ret; typedef char sha_test[sizeof(SHA3_224_CTX) >= sizeof(wc_Sha3) ? 1 : -1]; (void)sizeof(sha_test); WOLFSSL_ENTER("SHA3_224_Init"); ret = wc_InitSha3_224((wc_Sha3*)sha, NULL, 0); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA3_224_Update(WOLFSSL_SHA3_224_CTX* sha, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("SHA3_224_Update"); ret = wc_Sha3_224_Update((wc_Sha3*)sha, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA3_224_Final(byte* input, WOLFSSL_SHA3_224_CTX* sha) { int ret; WOLFSSL_ENTER("SHA3_224_Final"); ret = wc_Sha3_224_Final((wc_Sha3*)sha, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } #endif /* WOLFSSL_NOSHA3_224 */ #ifndef WOLFSSL_NOSHA3_256 int wolfSSL_SHA3_256_Init(WOLFSSL_SHA3_256_CTX* sha3_256) { int ret; typedef char sha_test[sizeof(SHA3_256_CTX) >= sizeof(wc_Sha3) ? 1 : -1]; (void)sizeof(sha_test); WOLFSSL_ENTER("SHA3_256_Init"); ret = wc_InitSha3_256((wc_Sha3*)sha3_256, NULL, 0); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA3_256_Update(WOLFSSL_SHA3_256_CTX* sha, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("SHA3_256_Update"); ret = wc_Sha3_256_Update((wc_Sha3*)sha, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA3_256_Final(byte* input, WOLFSSL_SHA3_256_CTX* sha) { int ret; WOLFSSL_ENTER("SHA3_256_Final"); ret = wc_Sha3_256_Final((wc_Sha3*)sha, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } #endif /* WOLFSSL_NOSHA3_256 */ int wolfSSL_SHA3_384_Init(WOLFSSL_SHA3_384_CTX* sha) { int ret; typedef char sha_test[sizeof(SHA3_384_CTX) >= sizeof(wc_Sha3) ? 1 : -1]; (void)sizeof(sha_test); WOLFSSL_ENTER("SHA3_384_Init"); ret = wc_InitSha3_384((wc_Sha3*)sha, NULL, 0); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA3_384_Update(WOLFSSL_SHA3_384_CTX* sha, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("SHA3_384_Update"); ret = wc_Sha3_384_Update((wc_Sha3*)sha, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA3_384_Final(byte* input, WOLFSSL_SHA3_384_CTX* sha) { int ret; WOLFSSL_ENTER("SHA3_384_Final"); ret = wc_Sha3_384_Final((wc_Sha3*)sha, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } #ifndef WOLFSSL_NOSHA3_512 int wolfSSL_SHA3_512_Init(WOLFSSL_SHA3_512_CTX* sha) { int ret; typedef char sha_test[sizeof(SHA3_512_CTX) >= sizeof(wc_Sha3) ? 1 : -1]; (void)sizeof(sha_test); WOLFSSL_ENTER("SHA3_512_Init"); ret = wc_InitSha3_512((wc_Sha3*)sha, NULL, 0); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA3_512_Update(WOLFSSL_SHA3_512_CTX* sha, const void* input, unsigned long sz) { int ret; WOLFSSL_ENTER("SHA3_512_Update"); ret = wc_Sha3_512_Update((wc_Sha3*)sha, (const byte*)input, (word32)sz); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } int wolfSSL_SHA3_512_Final(byte* input, WOLFSSL_SHA3_512_CTX* sha) { int ret; WOLFSSL_ENTER("SHA3_512_Final"); ret = wc_Sha3_512_Final((wc_Sha3*)sha, input); /* return 1 on success, 0 otherwise */ if (ret == 0) return 1; return 0; } #endif /* WOLFSSL_NOSHA3_512 */ #endif /* WOLFSSL_SHA3 */ /* store for external read of iv, WOLFSSL_SUCCESS on success */ int wolfSSL_StoreExternalIV(WOLFSSL_EVP_CIPHER_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_StoreExternalIV"); if (ctx == NULL) { WOLFSSL_MSG("Bad function argument"); return WOLFSSL_FATAL_ERROR; } switch (ctx->cipherType) { #ifndef NO_AES #ifdef HAVE_AES_CBC case AES_128_CBC_TYPE : case AES_192_CBC_TYPE : case AES_256_CBC_TYPE : WOLFSSL_MSG("AES CBC"); XMEMCPY(ctx->iv, &ctx->cipher.aes.reg, AES_BLOCK_SIZE); break; #endif #ifdef HAVE_AESGCM case AES_128_GCM_TYPE : case AES_192_GCM_TYPE : case AES_256_GCM_TYPE : WOLFSSL_MSG("AES GCM"); XMEMCPY(ctx->iv, &ctx->cipher.aes.reg, AES_BLOCK_SIZE); break; #endif /* HAVE_AESGCM */ #ifdef HAVE_AES_ECB case AES_128_ECB_TYPE : case AES_192_ECB_TYPE : case AES_256_ECB_TYPE : WOLFSSL_MSG("AES ECB"); break; #endif #ifdef WOLFSSL_AES_COUNTER case AES_128_CTR_TYPE : case AES_192_CTR_TYPE : case AES_256_CTR_TYPE : WOLFSSL_MSG("AES CTR"); XMEMCPY(ctx->iv, &ctx->cipher.aes.reg, AES_BLOCK_SIZE); break; #endif /* WOLFSSL_AES_COUNTER */ #ifdef WOLFSSL_AES_CFB #if !defined(HAVE_SELFTEST) && !defined(HAVE_FIPS) case AES_128_CFB1_TYPE: case AES_192_CFB1_TYPE: case AES_256_CFB1_TYPE: WOLFSSL_MSG("AES CFB1"); break; case AES_128_CFB8_TYPE: case AES_192_CFB8_TYPE: case AES_256_CFB8_TYPE: WOLFSSL_MSG("AES CFB8"); break; #endif /* !HAVE_SELFTEST && !HAVE_FIPS */ case AES_128_CFB128_TYPE: case AES_192_CFB128_TYPE: case AES_256_CFB128_TYPE: WOLFSSL_MSG("AES CFB128"); break; #endif /* WOLFSSL_AES_CFB */ #if defined(WOLFSSL_AES_OFB) case AES_128_OFB_TYPE: case AES_192_OFB_TYPE: case AES_256_OFB_TYPE: WOLFSSL_MSG("AES OFB"); break; #endif /* WOLFSSL_AES_OFB */ #ifdef WOLFSSL_AES_XTS case AES_128_XTS_TYPE: case AES_256_XTS_TYPE: WOLFSSL_MSG("AES XTS"); break; #endif /* WOLFSSL_AES_XTS */ #endif /* NO_AES */ #ifndef NO_DES3 case DES_CBC_TYPE : WOLFSSL_MSG("DES CBC"); XMEMCPY(ctx->iv, &ctx->cipher.des.reg, DES_BLOCK_SIZE); break; case DES_EDE3_CBC_TYPE : WOLFSSL_MSG("DES EDE3 CBC"); XMEMCPY(ctx->iv, &ctx->cipher.des3.reg, DES_BLOCK_SIZE); break; #endif #ifdef WOLFSSL_DES_ECB case DES_ECB_TYPE : WOLFSSL_MSG("DES ECB"); break; case DES_EDE3_ECB_TYPE : WOLFSSL_MSG("DES3 ECB"); break; #endif #ifdef HAVE_IDEA case IDEA_CBC_TYPE : WOLFSSL_MSG("IDEA CBC"); XMEMCPY(ctx->iv, &ctx->cipher.idea.reg, IDEA_BLOCK_SIZE); break; #endif case ARC4_TYPE : WOLFSSL_MSG("ARC4"); break; case NULL_CIPHER_TYPE : WOLFSSL_MSG("NULL"); break; default: { WOLFSSL_MSG("bad type"); return WOLFSSL_FATAL_ERROR; } } return WOLFSSL_SUCCESS; } /* set internal IV from external, WOLFSSL_SUCCESS on success */ int wolfSSL_SetInternalIV(WOLFSSL_EVP_CIPHER_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_SetInternalIV"); if (ctx == NULL) { WOLFSSL_MSG("Bad function argument"); return WOLFSSL_FATAL_ERROR; } switch (ctx->cipherType) { #ifndef NO_AES #ifdef HAVE_AES_CBC case AES_128_CBC_TYPE : case AES_192_CBC_TYPE : case AES_256_CBC_TYPE : WOLFSSL_MSG("AES CBC"); XMEMCPY(&ctx->cipher.aes.reg, ctx->iv, AES_BLOCK_SIZE); break; #endif #ifdef HAVE_AESGCM case AES_128_GCM_TYPE : case AES_192_GCM_TYPE : case AES_256_GCM_TYPE : WOLFSSL_MSG("AES GCM"); XMEMCPY(&ctx->cipher.aes.reg, ctx->iv, AES_BLOCK_SIZE); break; #endif #ifdef HAVE_AES_ECB case AES_128_ECB_TYPE : case AES_192_ECB_TYPE : case AES_256_ECB_TYPE : WOLFSSL_MSG("AES ECB"); break; #endif #ifdef WOLFSSL_AES_COUNTER case AES_128_CTR_TYPE : case AES_192_CTR_TYPE : case AES_256_CTR_TYPE : WOLFSSL_MSG("AES CTR"); XMEMCPY(&ctx->cipher.aes.reg, ctx->iv, AES_BLOCK_SIZE); break; #endif #endif /* NO_AES */ #ifndef NO_DES3 case DES_CBC_TYPE : WOLFSSL_MSG("DES CBC"); XMEMCPY(&ctx->cipher.des.reg, ctx->iv, DES_BLOCK_SIZE); break; case DES_EDE3_CBC_TYPE : WOLFSSL_MSG("DES EDE3 CBC"); XMEMCPY(&ctx->cipher.des3.reg, ctx->iv, DES_BLOCK_SIZE); break; #endif #ifdef WOLFSSL_DES_ECB case DES_ECB_TYPE : WOLFSSL_MSG("DES ECB"); break; case DES_EDE3_ECB_TYPE : WOLFSSL_MSG("DES3 ECB"); break; #endif #ifdef HAVE_IDEA case IDEA_CBC_TYPE : WOLFSSL_MSG("IDEA CBC"); XMEMCPY(&ctx->cipher.idea.reg, ctx->iv, IDEA_BLOCK_SIZE); break; #endif case ARC4_TYPE : WOLFSSL_MSG("ARC4"); break; case NULL_CIPHER_TYPE : WOLFSSL_MSG("NULL"); break; default: { WOLFSSL_MSG("bad type"); return WOLFSSL_FATAL_ERROR; } } return WOLFSSL_SUCCESS; } unsigned char* wolfSSL_HMAC(const WOLFSSL_EVP_MD* evp_md, const void* key, int key_len, const unsigned char* d, int n, unsigned char* md, unsigned int* md_len) { int type; int mdlen; unsigned char* ret = NULL; #ifdef WOLFSSL_SMALL_STACK Hmac* hmac = NULL; #else Hmac hmac[1]; #endif void* heap = NULL; WOLFSSL_ENTER("wolfSSL_HMAC"); if (!md) { WOLFSSL_MSG("Static buffer not supported, pass in md buffer"); return NULL; /* no static buffer support */ } #ifndef NO_MD5 if (XSTRNCMP(evp_md, "MD5", 3) == 0) { type = WC_MD5; mdlen = WC_MD5_DIGEST_SIZE; } else #endif #ifdef WOLFSSL_SHA224 if (XSTRNCMP(evp_md, "SHA224", 6) == 0) { type = WC_SHA224; mdlen = WC_SHA224_DIGEST_SIZE; } else #endif #ifndef NO_SHA256 if (XSTRNCMP(evp_md, "SHA256", 6) == 0) { type = WC_SHA256; mdlen = WC_SHA256_DIGEST_SIZE; } else #endif #ifdef WOLFSSL_SHA384 if (XSTRNCMP(evp_md, "SHA384", 6) == 0) { type = WC_SHA384; mdlen = WC_SHA384_DIGEST_SIZE; } else #endif #ifdef WOLFSSL_SHA512 if (XSTRNCMP(evp_md, "SHA512", 6) == 0) { type = WC_SHA512; mdlen = WC_SHA512_DIGEST_SIZE; } else #endif #ifdef WOLFSSL_SHA3 #ifndef WOLFSSL_NOSHA3_224 if (XSTRNCMP(evp_md, "SHA3_224", 8) == 0) { type = WC_SHA3_224; mdlen = WC_SHA3_224_DIGEST_SIZE; } else #endif #ifndef WOLFSSL_NOSHA3_256 if (XSTRNCMP(evp_md, "SHA3_256", 8) == 0) { type = WC_SHA3_256; mdlen = WC_SHA3_256_DIGEST_SIZE; } else #endif if (XSTRNCMP(evp_md, "SHA3_384", 8) == 0) { type = WC_SHA3_384; mdlen = WC_SHA3_384_DIGEST_SIZE; } else #ifndef WOLFSSL_NOSHA3_512 if (XSTRNCMP(evp_md, "SHA3_512", 8) == 0) { type = WC_SHA3_512; mdlen = WC_SHA3_512_DIGEST_SIZE; } else #endif #endif #ifndef NO_SHA if (XSTRNCMP(evp_md, "SHA", 3) == 0) { type = WC_SHA; mdlen = WC_SHA_DIGEST_SIZE; } else #endif { return NULL; } #ifdef WOLFSSL_SMALL_STACK hmac = (Hmac*)XMALLOC(sizeof(Hmac), heap, DYNAMIC_TYPE_HMAC); if (hmac == NULL) return NULL; #endif if (wc_HmacInit(hmac, heap, INVALID_DEVID) == 0) { if (wc_HmacSetKey(hmac, type, (const byte*)key, key_len) == 0) { if (wc_HmacUpdate(hmac, d, n) == 0) { if (wc_HmacFinal(hmac, md) == 0) { if (md_len) *md_len = mdlen; ret = md; } } } wc_HmacFree(hmac); } #ifdef WOLFSSL_SMALL_STACK XFREE(hmac, heap, DYNAMIC_TYPE_HMAC); #endif (void)evp_md; return ret; } void wolfSSL_ERR_clear_error(void) { WOLFSSL_ENTER("wolfSSL_ERR_clear_error"); #if defined(DEBUG_WOLFSSL) || defined(WOLFSSL_NGINX) || \ defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE) wc_ClearErrorNodes(); #endif } int wolfSSL_RAND_status(void) { return WOLFSSL_SUCCESS; /* wolfCrypt provides enough seed internally */ } #ifndef NO_WOLFSSL_STUB void wolfSSL_RAND_add(const void* add, int len, double entropy) { (void)add; (void)len; (void)entropy; WOLFSSL_STUB("RAND_add"); /* wolfSSL seeds/adds internally, use explicit RNG if you want to take control */ } #endif #ifndef NO_DES3 /* 0 on ok */ int wolfSSL_DES_key_sched(WOLFSSL_const_DES_cblock* key, WOLFSSL_DES_key_schedule* schedule) { WOLFSSL_ENTER("wolfSSL_DES_key_sched"); if (key == NULL || schedule == NULL) { WOLFSSL_MSG("Null argument passed in"); } else { XMEMCPY(schedule, key, sizeof(WOLFSSL_const_DES_cblock)); } return 0; } /* intended to behave similar to Kerberos mit_des_cbc_cksum * return the last 4 bytes of cipher text */ WOLFSSL_DES_LONG wolfSSL_DES_cbc_cksum(const unsigned char* in, WOLFSSL_DES_cblock* out, long length, WOLFSSL_DES_key_schedule* sc, WOLFSSL_const_DES_cblock* iv) { WOLFSSL_DES_LONG ret; unsigned char* tmp; unsigned char* data = (unsigned char*)in; long dataSz = length; byte dynamicFlag = 0; /* when padding the buffer created needs free'd */ WOLFSSL_ENTER("wolfSSL_DES_cbc_cksum"); if (in == NULL || out == NULL || sc == NULL || iv == NULL) { WOLFSSL_MSG("Bad argument passed in"); return 0; } /* if input length is not a multiple of DES_BLOCK_SIZE pad with 0s */ if (dataSz % DES_BLOCK_SIZE) { dataSz += DES_BLOCK_SIZE - (dataSz % DES_BLOCK_SIZE); data = (unsigned char*)XMALLOC(dataSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (data == NULL) { WOLFSSL_MSG("Issue creating temporary buffer"); return 0; } dynamicFlag = 1; /* set to free buffer at end */ XMEMCPY(data, in, length); XMEMSET(data + length, 0, dataSz - length); /* padding */ } tmp = (unsigned char*)XMALLOC(dataSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (tmp == NULL) { WOLFSSL_MSG("Issue creating temporary buffer"); if (dynamicFlag == 1) { XFREE(data, NULL, DYNAMIC_TYPE_TMP_BUFFER); } return 0; } wolfSSL_DES_cbc_encrypt(data, tmp, dataSz, sc, (WOLFSSL_DES_cblock*)iv, 1); XMEMCPY((unsigned char*)out, tmp + (dataSz - DES_BLOCK_SIZE), DES_BLOCK_SIZE); ret = (((*((unsigned char*)out + 4) & 0xFF) << 24)| ((*((unsigned char*)out + 5) & 0xFF) << 16)| ((*((unsigned char*)out + 6) & 0xFF) << 8) | (*((unsigned char*)out + 7) & 0xFF)); XFREE(tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (dynamicFlag == 1) { XFREE(data, NULL, DYNAMIC_TYPE_TMP_BUFFER); } return ret; } void wolfSSL_DES_cbc_encrypt(const unsigned char* input, unsigned char* output, long length, WOLFSSL_DES_key_schedule* schedule, WOLFSSL_DES_cblock* ivec, int enc) { Des myDes; byte lastblock[DES_BLOCK_SIZE]; int lb_sz; long blk; WOLFSSL_ENTER("DES_cbc_encrypt"); /* OpenSSL compat, no ret */ wc_Des_SetKey(&myDes, (const byte*)schedule, (const byte*)ivec, !enc); lb_sz = length%DES_BLOCK_SIZE; blk = length/DES_BLOCK_SIZE; if (enc){ wc_Des_CbcEncrypt(&myDes, output, input, (word32)blk*DES_BLOCK_SIZE); if(lb_sz){ XMEMSET(lastblock, 0, DES_BLOCK_SIZE); XMEMCPY(lastblock, input+length-lb_sz, lb_sz); wc_Des_CbcEncrypt(&myDes, output+blk*DES_BLOCK_SIZE, lastblock, (word32)DES_BLOCK_SIZE); } } else { wc_Des_CbcDecrypt(&myDes, output, input, (word32)blk*DES_BLOCK_SIZE); if(lb_sz){ wc_Des_CbcDecrypt(&myDes, lastblock, input+length-lb_sz, (word32)DES_BLOCK_SIZE); XMEMCPY(output+length-lb_sz, lastblock, lb_sz); } } } /* WOLFSSL_DES_key_schedule is a unsigned char array of size 8 */ void wolfSSL_DES_ede3_cbc_encrypt(const unsigned char* input, unsigned char* output, long sz, WOLFSSL_DES_key_schedule* ks1, WOLFSSL_DES_key_schedule* ks2, WOLFSSL_DES_key_schedule* ks3, WOLFSSL_DES_cblock* ivec, int enc) { int ret; Des3 des; byte key[24];/* EDE uses 24 size key */ byte lastblock[DES_BLOCK_SIZE]; int lb_sz; long blk; WOLFSSL_ENTER("wolfSSL_DES_ede3_cbc_encrypt"); XMEMSET(key, 0, sizeof(key)); XMEMCPY(key, *ks1, DES_BLOCK_SIZE); XMEMCPY(&key[DES_BLOCK_SIZE], *ks2, DES_BLOCK_SIZE); XMEMCPY(&key[DES_BLOCK_SIZE * 2], *ks3, DES_BLOCK_SIZE); lb_sz = sz%DES_BLOCK_SIZE; blk = sz/DES_BLOCK_SIZE; /* OpenSSL compat, no ret */ (void)wc_Des3Init(&des, NULL, INVALID_DEVID); if (enc) { wc_Des3_SetKey(&des, key, (const byte*)ivec, DES_ENCRYPTION); ret = wc_Des3_CbcEncrypt(&des, output, input, (word32)blk*DES_BLOCK_SIZE); #if defined(WOLFSSL_ASYNC_CRYPT) ret = wc_AsyncWait(ret, &des.asyncDev, WC_ASYNC_FLAG_NONE); #endif (void)ret; /* ignore return codes for processing */ if(lb_sz){ XMEMSET(lastblock, 0, DES_BLOCK_SIZE); XMEMCPY(lastblock, input+sz-lb_sz, lb_sz); ret = wc_Des3_CbcEncrypt(&des, output+blk*DES_BLOCK_SIZE, lastblock, (word32)DES_BLOCK_SIZE); #if defined(WOLFSSL_ASYNC_CRYPT) ret = wc_AsyncWait(ret, &des.asyncDev, WC_ASYNC_FLAG_NONE); #endif (void)ret; /* ignore return codes for processing */ } } else { wc_Des3_SetKey(&des, key, (const byte*)ivec, DES_DECRYPTION); ret = wc_Des3_CbcDecrypt(&des, output, input, (word32)blk*DES_BLOCK_SIZE); #if defined(WOLFSSL_ASYNC_CRYPT) ret = wc_AsyncWait(ret, &des.asyncDev, WC_ASYNC_FLAG_NONE); #endif (void)ret; /* ignore return codes for processing */ if(lb_sz){ ret = wc_Des3_CbcDecrypt(&des, lastblock, input+sz-lb_sz, (word32)DES_BLOCK_SIZE); #if defined(WOLFSSL_ASYNC_CRYPT) ret = wc_AsyncWait(ret, &des.asyncDev, WC_ASYNC_FLAG_NONE); #endif (void)ret; /* ignore return codes for processing */ XMEMCPY(output+sz-lb_sz, lastblock, lb_sz); } } wc_Des3Free(&des); } /* correctly sets ivec for next call */ void wolfSSL_DES_ncbc_encrypt(const unsigned char* input, unsigned char* output, long length, WOLFSSL_DES_key_schedule* schedule, WOLFSSL_DES_cblock* ivec, int enc) { Des myDes; byte lastblock[DES_BLOCK_SIZE]; int lb_sz; long idx = length; long blk; WOLFSSL_ENTER("DES_ncbc_encrypt"); /* OpenSSL compat, no ret */ wc_Des_SetKey(&myDes, (const byte*)schedule, (const byte*)ivec, !enc); lb_sz = length%DES_BLOCK_SIZE; blk = length/DES_BLOCK_SIZE; idx -= sizeof(DES_cblock); if (lb_sz) { idx += DES_BLOCK_SIZE - lb_sz; } if (enc){ wc_Des_CbcEncrypt(&myDes, output, input, (word32)blk * DES_BLOCK_SIZE); if (lb_sz){ XMEMSET(lastblock, 0, DES_BLOCK_SIZE); XMEMCPY(lastblock, input+length-lb_sz, lb_sz); wc_Des_CbcEncrypt(&myDes, output + blk * DES_BLOCK_SIZE, lastblock, (word32)DES_BLOCK_SIZE); } XMEMCPY(ivec, output + idx, sizeof(DES_cblock)); } else { WOLFSSL_DES_cblock tmp; XMEMCPY(tmp, input + idx, sizeof(DES_cblock)); wc_Des_CbcDecrypt(&myDes, output, input, (word32)blk * DES_BLOCK_SIZE); if (lb_sz){ wc_Des_CbcDecrypt(&myDes, lastblock, input + length - lb_sz, (word32)DES_BLOCK_SIZE); XMEMCPY(output+length-lb_sz, lastblock, lb_sz); } XMEMCPY(ivec, tmp, sizeof(WOLFSSL_DES_cblock)); } } #endif /* NO_DES3 */ void wolfSSL_ERR_free_strings(void) { /* handled internally */ } void wolfSSL_cleanup_all_ex_data(void) { /* nothing to do here */ } int wolfSSL_clear(WOLFSSL* ssl) { if (ssl == NULL) { return WOLFSSL_FAILURE; } ssl->options.isClosed = 0; ssl->options.connReset = 0; ssl->options.sentNotify = 0; ssl->options.sendVerify = 0; ssl->options.serverState = NULL_STATE; ssl->options.clientState = NULL_STATE; ssl->options.connectState = CONNECT_BEGIN; ssl->options.acceptState = ACCEPT_BEGIN; ssl->options.handShakeState = NULL_STATE; ssl->options.handShakeDone = 0; /* ssl->options.processReply = doProcessInit; */ ssl->keys.encryptionOn = 0; XMEMSET(&ssl->msgsReceived, 0, sizeof(ssl->msgsReceived)); if (ssl->hsHashes != NULL) { #ifndef NO_OLD_TLS #ifndef NO_MD5 if (wc_InitMd5_ex(&ssl->hsHashes->hashMd5, ssl->heap, ssl->devId) != 0) { return WOLFSSL_FAILURE; } #if defined(WOLFSSL_HASH_FLAGS) || defined(WOLF_CRYPTO_CB) wc_Md5SetFlags(&ssl->hsHashes->hashMd5, WC_HASH_FLAG_WILLCOPY); #endif #endif #ifndef NO_SHA if (wc_InitSha_ex(&ssl->hsHashes->hashSha, ssl->heap, ssl->devId) != 0) { return WOLFSSL_FAILURE; } #if defined(WOLFSSL_HASH_FLAGS) || defined(WOLF_CRYPTO_CB) wc_ShaSetFlags(&ssl->hsHashes->hashSha, WC_HASH_FLAG_WILLCOPY); #endif #endif #endif #ifndef NO_SHA256 if (wc_InitSha256_ex(&ssl->hsHashes->hashSha256, ssl->heap, ssl->devId) != 0) { return WOLFSSL_FAILURE; } #if defined(WOLFSSL_HASH_FLAGS) || defined(WOLF_CRYPTO_CB) wc_Sha256SetFlags(&ssl->hsHashes->hashSha256, WC_HASH_FLAG_WILLCOPY); #endif #endif #ifdef WOLFSSL_SHA384 if (wc_InitSha384_ex(&ssl->hsHashes->hashSha384, ssl->heap, ssl->devId) != 0) { return WOLFSSL_FAILURE; } #if defined(WOLFSSL_HASH_FLAGS) || defined(WOLF_CRYPTO_CB) wc_Sha384SetFlags(&ssl->hsHashes->hashSha384, WC_HASH_FLAG_WILLCOPY); #endif #endif #ifdef WOLFSSL_SHA512 if (wc_InitSha512_ex(&ssl->hsHashes->hashSha512, ssl->heap, ssl->devId) != 0) { return WOLFSSL_FAILURE; } #if defined(WOLFSSL_HASH_FLAGS) || defined(WOLF_CRYPTO_CB) wc_Sha512SetFlags(&ssl->hsHashes->hashSha512, WC_HASH_FLAG_WILLCOPY); #endif #endif } #ifdef SESSION_CERTS ssl->session.chain.count = 0; #endif #ifdef KEEP_PEER_CERT FreeX509(&ssl->peerCert); InitX509(&ssl->peerCert, 0, ssl->heap); #endif return WOLFSSL_SUCCESS; } long wolfSSL_SSL_SESSION_set_timeout(WOLFSSL_SESSION* ses, long t) { word32 tmptime; if (!ses || t < 0) return BAD_FUNC_ARG; tmptime = t & 0xFFFFFFFF; ses->timeout = tmptime; return WOLFSSL_SUCCESS; } #endif #if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER) long wolfSSL_CTX_set_mode(WOLFSSL_CTX* ctx, long mode) { /* WOLFSSL_MODE_ACCEPT_MOVING_WRITE_BUFFER is wolfSSL default mode */ WOLFSSL_ENTER("SSL_CTX_set_mode"); switch(mode) { case SSL_MODE_ENABLE_PARTIAL_WRITE: ctx->partialWrite = 1; break; #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) case SSL_MODE_RELEASE_BUFFERS: WOLFSSL_MSG("SSL_MODE_RELEASE_BUFFERS not implemented."); break; #endif default: WOLFSSL_MSG("Mode Not Implemented"); } /* SSL_MODE_AUTO_RETRY * Should not return -1 with renegotiation on read/write */ return mode; } #endif #ifdef OPENSSL_EXTRA #ifndef NO_WOLFSSL_STUB long wolfSSL_SSL_get_mode(WOLFSSL* ssl) { /* TODO: */ (void)ssl; WOLFSSL_STUB("SSL_get_mode"); return 0; } #endif #ifndef NO_WOLFSSL_STUB long wolfSSL_CTX_get_mode(WOLFSSL_CTX* ctx) { /* TODO: */ (void)ctx; WOLFSSL_STUB("SSL_CTX_get_mode"); return 0; } #endif #ifndef NO_WOLFSSL_STUB void wolfSSL_CTX_set_default_read_ahead(WOLFSSL_CTX* ctx, int m) { /* TODO: maybe? */ (void)ctx; (void)m; WOLFSSL_STUB("SSL_CTX_set_default_read_ahead"); } #endif /* Storing app session context id, this value is inherited by WOLFSSL * objects created from WOLFSSL_CTX. Any session that is imported with a * different session context id will be rejected. * * ctx structure to set context in * sid_ctx value of context to set * sid_ctx_len length of sid_ctx buffer * * Returns SSL_SUCCESS in success case and SSL_FAILURE when failing */ int wolfSSL_CTX_set_session_id_context(WOLFSSL_CTX* ctx, const unsigned char* sid_ctx, unsigned int sid_ctx_len) { WOLFSSL_ENTER("SSL_CTX_set_session_id_context"); /* No application specific context needed for wolfSSL */ if (sid_ctx_len > ID_LEN || ctx == NULL || sid_ctx == NULL) { return SSL_FAILURE; } XMEMCPY(ctx->sessionCtx, sid_ctx, sid_ctx_len); ctx->sessionCtxSz = (byte)sid_ctx_len; return SSL_SUCCESS; } /* Storing app session context id. Any session that is imported with a * different session context id will be rejected. * * ssl structure to set context in * id value of context to set * len length of sid_ctx buffer * * Returns SSL_SUCCESS in success case and SSL_FAILURE when failing */ int wolfSSL_set_session_id_context(WOLFSSL* ssl, const unsigned char* id, unsigned int len) { WOLFSSL_ENTER("wolfSSL_set_session_id_context"); if (len > ID_LEN || ssl == NULL || id == NULL) { return SSL_FAILURE; } XMEMCPY(ssl->sessionCtx, id, len); ssl->sessionCtxSz = (byte)len; return SSL_SUCCESS; } long wolfSSL_CTX_sess_get_cache_size(WOLFSSL_CTX* ctx) { (void)ctx; #ifndef NO_SESSION_CACHE return (long)(SESSIONS_PER_ROW * SESSION_ROWS); #else return 0; #endif } /* returns the unsigned error value and increments the pointer into the * error queue. * * file pointer to file name * line gets set to line number of error when not NULL */ unsigned long wolfSSL_ERR_get_error_line(const char** file, int* line) { #ifdef DEBUG_WOLFSSL int ret = wc_PullErrorNode(file, NULL, line); if (ret < 0) { if (ret == BAD_STATE_E) return 0; /* no errors in queue */ WOLFSSL_MSG("Issue getting error node"); WOLFSSL_LEAVE("wolfSSL_ERR_get_error_line", ret); ret = 0 - ret; /* return absolute value of error */ /* panic and try to clear out nodes */ wc_ClearErrorNodes(); } return (unsigned long)ret; #else (void)file; (void)line; return 0; #endif } #if (defined(DEBUG_WOLFSSL) || defined(OPENSSL_EXTRA)) && \ (!defined(_WIN32) && !defined(NO_ERROR_QUEUE)) static const char WOLFSSL_SYS_ACCEPT_T[] = "accept"; static const char WOLFSSL_SYS_BIND_T[] = "bind"; static const char WOLFSSL_SYS_CONNECT_T[] = "connect"; static const char WOLFSSL_SYS_FOPEN_T[] = "fopen"; static const char WOLFSSL_SYS_FREAD_T[] = "fread"; static const char WOLFSSL_SYS_GETADDRINFO_T[] = "getaddrinfo"; static const char WOLFSSL_SYS_GETSOCKOPT_T[] = "getsockopt"; static const char WOLFSSL_SYS_GETSOCKNAME_T[] = "getsockname"; static const char WOLFSSL_SYS_GETHOSTBYNAME_T[] = "gethostbyname"; static const char WOLFSSL_SYS_GETNAMEINFO_T[] = "getnameinfo"; static const char WOLFSSL_SYS_GETSERVBYNAME_T[] = "getservbyname"; static const char WOLFSSL_SYS_IOCTLSOCKET_T[] = "ioctlsocket"; static const char WOLFSSL_SYS_LISTEN_T[] = "listen"; static const char WOLFSSL_SYS_OPENDIR_T[] = "opendir"; static const char WOLFSSL_SYS_SETSOCKOPT_T[] = "setsockopt"; static const char WOLFSSL_SYS_SOCKET_T[] = "socket"; /* switch with int mapped to function name for compatibility */ static const char* wolfSSL_ERR_sys_func(int fun) { switch (fun) { case WOLFSSL_SYS_ACCEPT: return WOLFSSL_SYS_ACCEPT_T; case WOLFSSL_SYS_BIND: return WOLFSSL_SYS_BIND_T; case WOLFSSL_SYS_CONNECT: return WOLFSSL_SYS_CONNECT_T; case WOLFSSL_SYS_FOPEN: return WOLFSSL_SYS_FOPEN_T; case WOLFSSL_SYS_FREAD: return WOLFSSL_SYS_FREAD_T; case WOLFSSL_SYS_GETADDRINFO: return WOLFSSL_SYS_GETADDRINFO_T; case WOLFSSL_SYS_GETSOCKOPT: return WOLFSSL_SYS_GETSOCKOPT_T; case WOLFSSL_SYS_GETSOCKNAME: return WOLFSSL_SYS_GETSOCKNAME_T; case WOLFSSL_SYS_GETHOSTBYNAME: return WOLFSSL_SYS_GETHOSTBYNAME_T; case WOLFSSL_SYS_GETNAMEINFO: return WOLFSSL_SYS_GETNAMEINFO_T; case WOLFSSL_SYS_GETSERVBYNAME: return WOLFSSL_SYS_GETSERVBYNAME_T; case WOLFSSL_SYS_IOCTLSOCKET: return WOLFSSL_SYS_IOCTLSOCKET_T; case WOLFSSL_SYS_LISTEN: return WOLFSSL_SYS_LISTEN_T; case WOLFSSL_SYS_OPENDIR: return WOLFSSL_SYS_OPENDIR_T; case WOLFSSL_SYS_SETSOCKOPT: return WOLFSSL_SYS_SETSOCKOPT_T; case WOLFSSL_SYS_SOCKET: return WOLFSSL_SYS_SOCKET_T; default: return "NULL"; } } #endif /* DEBUG_WOLFSSL */ /* @TODO when having an error queue this needs to push to the queue */ void wolfSSL_ERR_put_error(int lib, int fun, int err, const char* file, int line) { WOLFSSL_ENTER("wolfSSL_ERR_put_error"); #if !defined(DEBUG_WOLFSSL) && !defined(OPENSSL_EXTRA) (void)fun; (void)err; (void)file; (void)line; WOLFSSL_MSG("Not compiled in debug mode"); #elif defined(OPENSSL_EXTRA) && \ (defined(_WIN32) || defined(NO_ERROR_QUEUE)) (void)fun; (void)file; (void)line; WOLFSSL_ERROR(err); #else WOLFSSL_ERROR_LINE(err, wolfSSL_ERR_sys_func(fun), (unsigned int)line, file, NULL); #endif (void)lib; } /* Similar to wolfSSL_ERR_get_error_line but takes in a flags argument for * more flexibility. * * file output pointer to file where error happened * line output to line number of error * data output data. Is a string if ERR_TXT_STRING flag is used * flags bit flag to adjust data output * * Returns the error value or 0 if no errors are in the queue */ unsigned long wolfSSL_ERR_get_error_line_data(const char** file, int* line, const char** data, int *flags) { int ret; WOLFSSL_STUB("wolfSSL_ERR_get_error_line_data"); if (flags != NULL) { if ((*flags & ERR_TXT_STRING) == ERR_TXT_STRING) { ret = wc_PullErrorNode(file, data, line); if (ret < 0) { if (ret == BAD_STATE_E) return 0; /* no errors in queue */ WOLFSSL_MSG("Error with pulling error node!"); WOLFSSL_LEAVE("wolfSSL_ERR_get_error_line_data", ret); ret = 0 - ret; /* return absolute value of error */ /* panic and try to clear out nodes */ wc_ClearErrorNodes(); } return (unsigned long)ret; } } ret = wc_PullErrorNode(file, NULL, line); if (ret < 0) { if (ret == BAD_STATE_E) return 0; /* no errors in queue */ WOLFSSL_MSG("Error with pulling error node!"); WOLFSSL_LEAVE("wolfSSL_ERR_get_error_line_data", ret); ret = 0 - ret; /* return absolute value of error */ /* panic and try to clear out nodes */ wc_ClearErrorNodes(); } return (unsigned long)ret; } #endif /* OPENSSL_EXTRA */ #if (defined(KEEP_PEER_CERT) && defined(SESSION_CERTS)) || \ (defined(OPENSSL_ALL) && defined(HAVE_PKCS7)) /* Decode the X509 DER encoded certificate into a WOLFSSL_X509 object. * * x509 WOLFSSL_X509 object to decode into. * in X509 DER data. * len Length of the X509 DER data. * returns the new certificate on success, otherwise NULL. */ static int DecodeToX509(WOLFSSL_X509* x509, const byte* in, int len) { int ret; #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert; #else DecodedCert cert[1]; #endif if (x509 == NULL || in == NULL || len <= 0) return BAD_FUNC_ARG; #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (cert == NULL) return MEMORY_E; #endif /* Create a DecodedCert object and copy fields into WOLFSSL_X509 object. */ InitDecodedCert(cert, (byte*)in, len, NULL); if ((ret = ParseCertRelative(cert, CERT_TYPE, 0, NULL)) == 0) { /* Check if x509 was not previously initialized by wolfSSL_X509_new() */ if (x509->dynamicMemory != TRUE) InitX509(x509, 0, NULL); ret = CopyDecodedToX509(x509, cert); FreeDecodedCert(cert); } #ifdef WOLFSSL_SMALL_STACK XFREE(cert, NULL, DYNAMIC_TYPE_DCERT); #endif return ret; } #endif /* (KEEP_PEER_CERT && SESSION_CERTS) || (OPENSSL_ALL && HAVE_PKCS7) */ #ifdef KEEP_PEER_CERT WOLFSSL_ABI WOLFSSL_X509* wolfSSL_get_peer_certificate(WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_get_peer_certificate"); if (ssl == NULL) return NULL; if (ssl->peerCert.issuer.sz) return &ssl->peerCert; #ifdef SESSION_CERTS else if (ssl->session.chain.count > 0) { if (DecodeToX509(&ssl->peerCert, ssl->session.chain.certs[0].buffer, ssl->session.chain.certs[0].length) == 0) { return &ssl->peerCert; } } #endif return 0; } #endif /* KEEP_PEER_CERT */ #if defined(SESSION_CERTS) /* Return stack of peer certs. * If Qt or OPENSSL_ALL is defined then return ssl->peerCertChain. * All other cases return &ssl->session.chain * ssl->peerCertChain is type WOLFSSL_STACK* * ssl->session.chain is type WOLFSSL_X509_CHAIN * Caller does not need to free return. The stack is Free'd when WOLFSSL* ssl is. */ WOLF_STACK_OF(WOLFSSL_X509)* wolfSSL_get_peer_cert_chain(const WOLFSSL* ssl) { WOLFSSL_STACK* sk; WOLFSSL_ENTER("wolfSSL_get_peer_cert_chain"); if (ssl == NULL) return NULL; #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) if (ssl->peerCertChain == NULL) wolfSSL_set_peer_cert_chain((WOLFSSL*) ssl); sk = ssl->peerCertChain; #else sk = (WOLF_STACK_OF(WOLFSSL_X509)* )&ssl->session.chain; #endif if (sk == NULL) { WOLFSSL_MSG("Error: Null Peer Cert Chain"); } return sk; } #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) /* Builds up and creates a stack of peer certificates for ssl->peerCertChain based off of the ssl session chain. Returns stack of WOLFSSL_X509 certs or NULL on failure */ WOLF_STACK_OF(WOLFSSL_X509)* wolfSSL_set_peer_cert_chain(WOLFSSL* ssl) { WOLFSSL_STACK* sk; WOLFSSL_X509* x509; int i = 0; int ret; WOLFSSL_ENTER("wolfSSL_set_peer_cert_chain"); if ((ssl == NULL) || (ssl->session.chain.count == 0)) return NULL; sk = wolfSSL_sk_X509_new(); i = ssl->session.chain.count-1; for (; i >= 0; i--) { /* For servers, the peer certificate chain does not include the peer certificate, so do not add it to the stack */ if (ssl->options.side == WOLFSSL_SERVER_END && i == 0) continue; x509 = wolfSSL_X509_new(); if (x509 == NULL) { WOLFSSL_MSG("Error Creating X509"); return NULL; } ret = DecodeToX509(x509, ssl->session.chain.certs[i].buffer, ssl->session.chain.certs[i].length); if (ret != 0 || wolfSSL_sk_X509_push(sk, x509) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error decoding cert"); wolfSSL_X509_free(x509); wolfSSL_sk_X509_free(sk); return NULL; } } if (sk == NULL) { WOLFSSL_MSG("Null session chain"); } /* This is Free'd when ssl is Free'd */ ssl->peerCertChain = sk; return sk; } #endif /* OPENSSL_ALL || WOLFSSL_QT */ #endif /* SESSION_CERTS */ #ifndef NO_CERTS #if defined(KEEP_PEER_CERT) || defined(SESSION_CERTS) || \ defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) /* user externally called free X509, if dynamic go ahead with free, otherwise * don't */ static void ExternalFreeX509(WOLFSSL_X509* x509) { int doFree = 0; WOLFSSL_ENTER("ExternalFreeX509"); if (x509) { if (x509->dynamicMemory) { #if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL) if (wc_LockMutex(&x509->refMutex) != 0) { WOLFSSL_MSG("Couldn't lock x509 mutex"); } /* only free if all references to it are done */ x509->refCount--; if (x509->refCount == 0) doFree = 1; wc_UnLockMutex(&x509->refMutex); #else doFree = 1; #endif /* OPENSSL_EXTRA */ if (doFree) { FreeX509(x509); XFREE(x509, x509->heap, DYNAMIC_TYPE_X509); } } else { WOLFSSL_MSG("free called on non dynamic object, not freeing"); } } } /* Frees an external WOLFSSL_X509 structure */ WOLFSSL_ABI void wolfSSL_X509_free(WOLFSSL_X509* x509) { WOLFSSL_ENTER("wolfSSL_FreeX509"); ExternalFreeX509(x509); } /* copy name into in buffer, at most sz bytes, if buffer is null will malloc buffer, call responsible for freeing */ WOLFSSL_ABI char* wolfSSL_X509_NAME_oneline(WOLFSSL_X509_NAME* name, char* in, int sz) { int copySz; if (name == NULL) { WOLFSSL_MSG("WOLFSSL_X509_NAME pointer was NULL"); return NULL; } copySz = min(sz, name->sz); WOLFSSL_ENTER("wolfSSL_X509_NAME_oneline"); if (!name->sz) return in; if (!in) { #ifdef WOLFSSL_STATIC_MEMORY WOLFSSL_MSG("Using static memory -- please pass in a buffer"); return NULL; #else in = (char*)XMALLOC(name->sz, NULL, DYNAMIC_TYPE_OPENSSL); if (!in ) return in; copySz = name->sz; #endif } if (copySz <= 0) return in; XMEMCPY(in, name->name, copySz - 1); in[copySz - 1] = 0; return in; } #if defined(OPENSSL_EXTRA) && defined(XSNPRINTF) /* Copies X509 subject name into a buffer, with comma-separated name entries * (matching OpenSSL v1.0.0 format) * Example Output for Issuer: * * C=US, ST=Montana, L=Bozeman, O=Sawtooth, OU=Consulting, * CN=www.wolfssl.com, emailAddress=info@wolfssl.com */ char* wolfSSL_X509_get_name_oneline(WOLFSSL_X509_NAME* name, char* in, int sz) { WOLFSSL_X509_NAME_ENTRY* entry; int nameSz, strSz, count, i, idx = 0; int totalSz = 0; char *str; char tmpBuf[256]; char buf[80]; const char* sn; WOLFSSL_ENTER("wolfSSL_X509_get_name_oneline"); if (name == NULL) { WOLFSSL_MSG("wolfSSL_X509_get_subject_name failed"); return NULL; } #ifdef WOLFSSL_STATIC_MEMORY if (!in) { WOLFSSL_MSG("Using static memory -- please pass in a buffer"); return NULL; } #endif tmpBuf[0] = '\0'; /* Make sure tmpBuf is NULL terminated */ /* Loop through X509 name entries and copy new format to buffer */ count = wolfSSL_X509_NAME_entry_count(name); for (i = 0; i < count; i++) { /* Get name entry and size */ entry = wolfSSL_X509_NAME_get_entry(name, i); if (entry == NULL) { WOLFSSL_MSG("X509_NAME_get_entry failed"); return NULL; } nameSz = wolfSSL_X509_NAME_get_text_by_NID(name, entry->nid, buf, sizeof(buf)); if (nameSz < 0) { WOLFSSL_MSG("X509_NAME_get_text_by_NID failed"); return NULL; } /* Get short name */ sn = wolfSSL_OBJ_nid2sn(entry->nid); if (sn == NULL) { WOLFSSL_MSG("OBJ_nid2sn failed"); return NULL; } /* Copy sn and name text to buffer * Add extra strSz for '=', ',', ' ' and '\0' characters in XSNPRINTF. */ if (i != count - 1) { strSz = (int)XSTRLEN(sn) + nameSz + 4; totalSz+= strSz; str = (char*)XMALLOC(strSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (str == NULL) { WOLFSSL_MSG("Memory error"); return NULL; } XSNPRINTF(str, strSz, "%s=%s, ", sn, buf); } else { /* Copy last name entry * Add extra strSz for '=' and '\0' characters in XSNPRINTF. */ strSz = (int)XSTRLEN(sn) + nameSz + 2; totalSz+= strSz; str = (char*)XMALLOC(strSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (str == NULL) { WOLFSSL_MSG("Memory error"); return NULL; } XSNPRINTF(str, strSz, "%s=%s", sn, buf); } /* Copy string to tmpBuf */ XSTRNCAT(tmpBuf, str, strSz); idx += strSz; XFREE(str, NULL, DYNAMIC_TYPE_TMP_BUFFER); } /* Allocate space based on total string size if no buffer was provided */ if (!in) { in = (char*)XMALLOC(totalSz+1, NULL, DYNAMIC_TYPE_OPENSSL); if (in == NULL) { WOLFSSL_MSG("Memory error"); return in; } } else { if (totalSz > sz) { WOLFSSL_MSG("Memory error"); return NULL; } } XMEMCPY(in, tmpBuf, totalSz); in[totalSz] = '\0'; return in; } #endif /* Wraps wolfSSL_X509_d2i * * returns a WOLFSSL_X509 structure pointer on success and NULL on fail */ WOLFSSL_X509* wolfSSL_d2i_X509(WOLFSSL_X509** x509, const unsigned char** in, int len) { WOLFSSL_X509* newX509 = NULL; newX509 = wolfSSL_X509_d2i(x509, *in, len); if (newX509 != NULL) { *in += newX509->derCert->length; } return newX509; } WOLFSSL_X509* wolfSSL_X509_d2i(WOLFSSL_X509** x509, const byte* in, int len) { WOLFSSL_X509 *newX509 = NULL; WOLFSSL_ENTER("wolfSSL_X509_d2i"); if (in != NULL && len != 0) { #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert; #else DecodedCert cert[1]; #endif #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (cert == NULL) return NULL; #endif InitDecodedCert(cert, (byte*)in, len, NULL); if (ParseCertRelative(cert, CERT_TYPE, 0, NULL) == 0) { newX509 = wolfSSL_X509_new(); if (newX509 != NULL) { if (CopyDecodedToX509(newX509, cert) != 0) { wolfSSL_X509_free(newX509); newX509 = NULL; } } } FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, NULL, DYNAMIC_TYPE_DCERT); #endif } if (x509 != NULL) *x509 = newX509; return newX509; } #endif /* KEEP_PEER_CERT || SESSION_CERTS || OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */ #if defined(OPENSSL_ALL) || defined(KEEP_OUR_CERT) || defined(KEEP_PEER_CERT) || \ defined(SESSION_CERTS) /* return the next, if any, altname from the peer cert */ WOLFSSL_ABI char* wolfSSL_X509_get_next_altname(WOLFSSL_X509* cert) { char* ret = NULL; WOLFSSL_ENTER("wolfSSL_X509_get_next_altname"); /* don't have any to work with */ if (cert == NULL || cert->altNames == NULL) return NULL; /* already went through them */ if (cert->altNamesNext == NULL) return NULL; ret = cert->altNamesNext->name; cert->altNamesNext = cert->altNamesNext->next; return ret; } int wolfSSL_X509_get_isCA(WOLFSSL_X509* x509) { int isCA = 0; WOLFSSL_ENTER("wolfSSL_X509_get_isCA"); if (x509 != NULL) isCA = x509->isCa; WOLFSSL_LEAVE("wolfSSL_X509_get_isCA", isCA); return isCA; } int wolfSSL_X509_get_signature(WOLFSSL_X509* x509, unsigned char* buf, int* bufSz) { WOLFSSL_ENTER("wolfSSL_X509_get_signature"); if (x509 == NULL || bufSz == NULL || (*bufSz < (int)x509->sig.length && buf != NULL)) return WOLFSSL_FATAL_ERROR; if (buf != NULL) XMEMCPY(buf, x509->sig.buffer, x509->sig.length); *bufSz = x509->sig.length; return WOLFSSL_SUCCESS; } /* Getter function that copies over the DER public key buffer to "buf" and * sets the size in bufSz. If "buf" is NULL then just bufSz is set to needed * buffer size. "bufSz" passed in should initially be set by the user to be * the size of "buf". This gets checked to make sure the buffer is large * enough to hold the public key. * * Note: this is the X.509 form of key with "header" info. * return WOLFSSL_SUCCESS on success */ int wolfSSL_X509_get_pubkey_buffer(WOLFSSL_X509* x509, unsigned char* buf, int* bufSz) { #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert; #else DecodedCert cert[1]; #endif word32 idx; const byte* der; int length = 0; int ret, derSz = 0; int badDate = 0; const byte* pubKeyX509 = NULL; int pubKeyX509Sz = 0; WOLFSSL_ENTER("wolfSSL_X509_get_pubkey_buffer"); if (x509 == NULL || bufSz == NULL) { WOLFSSL_LEAVE("wolfSSL_X509_get_pubkey_buffer", BAD_FUNC_ARG); return WOLFSSL_FATAL_ERROR; } #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), x509->heap, DYNAMIC_TYPE_TMP_BUFFER); if (cert == NULL) { WOLFSSL_LEAVE("wolfSSL_X509_get_pubkey_buffer", MEMORY_E); return WOLFSSL_FATAL_ERROR; } #endif der = wolfSSL_X509_get_der(x509, &derSz); InitDecodedCert(cert, der, derSz, NULL); ret = wc_GetPubX509(cert, 0, &badDate); if (ret >= 0) { idx = cert->srcIdx; pubKeyX509 = cert->source + cert->srcIdx; ret = GetSequence(cert->source, &cert->srcIdx, &length, cert->maxIdx); pubKeyX509Sz = length + (cert->srcIdx - idx); } FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, x509->heap, DYNAMIC_TYPE_TMP_BUFFER); #endif if (ret < 0) { WOLFSSL_LEAVE("wolfSSL_X509_get_pubkey_buffer", ret); return WOLFSSL_FATAL_ERROR; } if (buf != NULL) { if (pubKeyX509Sz > *bufSz) { WOLFSSL_LEAVE("wolfSSL_X509_get_pubkey_buffer", BUFFER_E); return WOLFSSL_FATAL_ERROR; } XMEMCPY(buf, pubKeyX509, pubKeyX509Sz); } *bufSz = pubKeyX509Sz; return WOLFSSL_SUCCESS; } /* Getter function for the public key OID value * return public key OID stored in WOLFSSL_X509 structure */ int wolfSSL_X509_get_pubkey_type(WOLFSSL_X509* x509) { if (x509 == NULL) return WOLFSSL_FAILURE; return x509->pubKeyOID; } /* write X509 serial number in unsigned binary to buffer buffer needs to be at least EXTERNAL_SERIAL_SIZE (32) for all cases return WOLFSSL_SUCCESS on success */ int wolfSSL_X509_get_serial_number(WOLFSSL_X509* x509, byte* in, int* inOutSz) { WOLFSSL_ENTER("wolfSSL_X509_get_serial_number"); if (x509 == NULL || in == NULL || inOutSz == NULL || *inOutSz < x509->serialSz) return BAD_FUNC_ARG; XMEMCPY(in, x509->serial, x509->serialSz); *inOutSz = x509->serialSz; return WOLFSSL_SUCCESS; } /* not an openssl compatibility function - getting for derCert */ const byte* wolfSSL_X509_get_der(WOLFSSL_X509* x509, int* outSz) { WOLFSSL_ENTER("wolfSSL_X509_get_der"); if (x509 == NULL || x509->derCert == NULL || outSz == NULL) return NULL; *outSz = (int)x509->derCert->length; return x509->derCert->buffer; } /* used by JSSE (not a standard compatibility function) */ /* this is not thread safe */ WOLFSSL_ABI const byte* wolfSSL_X509_notBefore(WOLFSSL_X509* x509) { static byte notBeforeData[CTC_DATE_SIZE]; /* temp buffer for date */ WOLFSSL_ENTER("wolfSSL_X509_notBefore"); if (x509 == NULL) return NULL; XMEMSET(notBeforeData, 0, sizeof(notBeforeData)); notBeforeData[0] = (byte)x509->notBefore.type; notBeforeData[1] = (byte)x509->notBefore.length; XMEMCPY(¬BeforeData[2], x509->notBefore.data, x509->notBefore.length); return notBeforeData; } /* used by JSSE (not a standard compatibility function) */ /* this is not thread safe */ WOLFSSL_ABI const byte* wolfSSL_X509_notAfter(WOLFSSL_X509* x509) { static byte notAfterData[CTC_DATE_SIZE]; /* temp buffer for date */ WOLFSSL_ENTER("wolfSSL_X509_notAfter"); if (x509 == NULL) return NULL; XMEMSET(notAfterData, 0, sizeof(notAfterData)); notAfterData[0] = (byte)x509->notAfter.type; notAfterData[1] = (byte)x509->notAfter.length; XMEMCPY(¬AfterData[2], x509->notAfter.data, x509->notAfter.length); return notAfterData; } #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) && !defined(NO_WOLFSSL_STUB) WOLFSSL_ASN1_TIME* wolfSSL_X509_gmtime_adj(WOLFSSL_ASN1_TIME *s, long adj) { (void) s; (void) adj; WOLFSSL_STUB("wolfSSL_X509_gmtime_adj"); return NULL; } #endif /* get the buffer to be signed (tbs) from the WOLFSSL_X509 certificate * * outSz : gets set to the size of the buffer * returns a pointer to the internal buffer at the location of TBS on * on success and NULL on failure. */ const unsigned char* wolfSSL_X509_get_tbs(WOLFSSL_X509* x509, int* outSz) { int sz = 0, len; unsigned int idx = 0, tmpIdx; const unsigned char* der = NULL; const unsigned char* tbs = NULL; if (x509 == NULL || outSz == NULL) { return NULL; } der = wolfSSL_X509_get_der(x509, &sz); if (der == NULL) { return NULL; } if (GetSequence(der, &idx, &len, sz) < 0) { return NULL; } tbs = der + idx; tmpIdx = idx; if (GetSequence(der, &idx, &len, sz) < 0) { return NULL; } *outSz = len + (idx - tmpIdx); return tbs; } int wolfSSL_X509_version(WOLFSSL_X509* x509) { WOLFSSL_ENTER("wolfSSL_X509_version"); if (x509 == NULL) return 0; return x509->version; } #ifdef WOLFSSL_SEP /* copy oid into in buffer, at most *inOutSz bytes, if buffer is null will malloc buffer, call responsible for freeing. Actual size returned in *inOutSz. Requires inOutSz be non-null */ byte* wolfSSL_X509_get_device_type(WOLFSSL_X509* x509, byte* in, int *inOutSz) { int copySz; WOLFSSL_ENTER("wolfSSL_X509_get_dev_type"); if (inOutSz == NULL) return NULL; if (!x509->deviceTypeSz) return in; copySz = min(*inOutSz, x509->deviceTypeSz); if (!in) { #ifdef WOLFSSL_STATIC_MEMORY WOLFSSL_MSG("Using static memory -- please pass in a buffer"); return NULL; #else in = (byte*)XMALLOC(x509->deviceTypeSz, 0, DYNAMIC_TYPE_OPENSSL); if (!in) return in; copySz = x509->deviceTypeSz; #endif } XMEMCPY(in, x509->deviceType, copySz); *inOutSz = copySz; return in; } byte* wolfSSL_X509_get_hw_type(WOLFSSL_X509* x509, byte* in, int* inOutSz) { int copySz; WOLFSSL_ENTER("wolfSSL_X509_get_hw_type"); if (inOutSz == NULL) return NULL; if (!x509->hwTypeSz) return in; copySz = min(*inOutSz, x509->hwTypeSz); if (!in) { #ifdef WOLFSSL_STATIC_MEMORY WOLFSSL_MSG("Using static memory -- please pass in a buffer"); return NULL; #else in = (byte*)XMALLOC(x509->hwTypeSz, 0, DYNAMIC_TYPE_OPENSSL); if (!in) return in; copySz = x509->hwTypeSz; #endif } XMEMCPY(in, x509->hwType, copySz); *inOutSz = copySz; return in; } byte* wolfSSL_X509_get_hw_serial_number(WOLFSSL_X509* x509,byte* in, int* inOutSz) { int copySz; WOLFSSL_ENTER("wolfSSL_X509_get_hw_serial_number"); if (inOutSz == NULL) return NULL; if (!x509->hwTypeSz) return in; copySz = min(*inOutSz, x509->hwSerialNumSz); if (!in) { #ifdef WOLFSSL_STATIC_MEMORY WOLFSSL_MSG("Using static memory -- please pass in a buffer"); return NULL; #else in = (byte*)XMALLOC(x509->hwSerialNumSz, 0, DYNAMIC_TYPE_OPENSSL); if (!in) return in; copySz = x509->hwSerialNumSz; #endif } XMEMCPY(in, x509->hwSerialNum, copySz); *inOutSz = copySz; return in; } #endif /* WOLFSSL_SEP */ /* require OPENSSL_EXTRA since wolfSSL_X509_free is wrapped by OPENSSL_EXTRA */ #if !defined(NO_CERTS) && defined(OPENSSL_EXTRA) WOLFSSL_ASN1_TIME* wolfSSL_X509_get_notBefore(const WOLFSSL_X509* x509) { WOLFSSL_ENTER("wolfSSL_X509_get_notBefore"); if (x509 == NULL) return NULL; return (WOLFSSL_ASN1_TIME*)&x509->notBefore; } WOLFSSL_ASN1_TIME* wolfSSL_X509_get_notAfter(const WOLFSSL_X509* x509) { WOLFSSL_ENTER("wolfSSL_X509_get_notAfter"); if (x509 == NULL) return NULL; return (WOLFSSL_ASN1_TIME*)&x509->notAfter; } /* return 1 on success 0 on fail */ int wolfSSL_sk_X509_push(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk, WOLFSSL_X509* x509) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_X509_push"); if (sk == NULL || x509 == NULL) { return WOLFSSL_FAILURE; } /* no previous values in stack */ if (sk->data.x509 == NULL) { sk->data.x509 = x509; sk->num += 1; return WOLFSSL_SUCCESS; } /* stack already has value(s) create a new node and add more */ node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_X509); if (node == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } XMEMSET(node, 0, sizeof(WOLFSSL_STACK)); /* push new x509 onto head of stack */ node->data.x509 = sk->data.x509; node->next = sk->next; node->type = sk->type; sk->next = node; sk->data.x509 = x509; sk->num += 1; return WOLFSSL_SUCCESS; } WOLFSSL_X509* wolfSSL_sk_X509_pop(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk) { WOLFSSL_STACK* node; WOLFSSL_X509* x509; if (sk == NULL) { return NULL; } node = sk->next; x509 = sk->data.x509; if (node != NULL) { /* update sk and remove node from stack */ sk->data.x509 = node->data.x509; sk->next = node->next; XFREE(node, NULL, DYNAMIC_TYPE_X509); } else { /* last x509 in stack */ sk->data.x509 = NULL; } if (sk->num > 0) { sk->num -= 1; } return x509; } /* Getter function for WOLFSSL_X509 pointer * * sk is the stack to retrieve pointer from * i is the index value in stack * * returns a pointer to a WOLFSSL_X509 structure on success and NULL on * fail */ WOLFSSL_X509* wolfSSL_sk_X509_value(STACK_OF(WOLFSSL_X509)* sk, int i) { WOLFSSL_ENTER("wolfSSL_sk_X509_value"); for (; sk != NULL && i > 0; i--) sk = sk->next; if (i != 0 || sk == NULL) return NULL; return sk->data.x509; } WOLFSSL_X509* wolfSSL_sk_X509_shift(WOLF_STACK_OF(WOLFSSL_X509)* sk) { return wolfSSL_sk_X509_pop(sk); } #ifndef NO_WOLFSSL_STUB void* wolfSSL_sk_X509_OBJECT_value(WOLF_STACK_OF(WOLFSSL_X509_OBJECT)* sk, int x) { (void) sk; (void) x; return NULL; } #endif /* Free's all nodes in X509 stack. This is different then wolfSSL_sk_X509_free * in that it allows for choosing the function to use when freeing an X509s. * * sk stack to free nodes in * f X509 free function */ void wolfSSL_sk_X509_pop_free(STACK_OF(WOLFSSL_X509)* sk, void (*f) (WOLFSSL_X509*)) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_X509_pop_free"); if (sk == NULL) { return; } /* parse through stack freeing each node */ node = sk->next; while (node && sk->num > 1) { WOLFSSL_STACK* tmp = node; node = node->next; if (f) f(tmp->data.x509); else wolfSSL_X509_free(tmp->data.x509); tmp->data.x509 = NULL; XFREE(tmp, NULL, DYNAMIC_TYPE_X509); sk->num -= 1; } /* free head of stack */ if (sk->num == 1) { if (f) f(sk->data.x509); else wolfSSL_X509_free(sk->data.x509); sk->data.x509 = NULL; } XFREE(sk, NULL, DYNAMIC_TYPE_X509); } /* free structure for x509 stack */ void wolfSSL_sk_X509_free(WOLF_STACK_OF(WOLFSSL_X509)* sk) { wolfSSL_sk_X509_pop_free(sk, NULL); } #endif /* NO_CERTS && OPENSSL_EXTRA */ #if defined(OPENSSL_ALL) || defined (WOLFSSL_QT) /* return 1 on success 0 on fail */ int wolfSSL_sk_ACCESS_DESCRIPTION_push(WOLF_STACK_OF(ACCESS_DESCRIPTION)* sk, WOLFSSL_ACCESS_DESCRIPTION* access) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_ACCESS_DESCRIPTION_push"); if (sk == NULL || access == NULL) { return WOLFSSL_FAILURE; } /* no previous values in stack */ if (sk->data.access == NULL) { sk->data.access = access; sk->num += 1; return WOLFSSL_SUCCESS; } /* stack already has value(s) create a new node and add more */ node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_ASN1); if (node == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } XMEMSET(node, 0, sizeof(WOLFSSL_STACK)); /* push new obj onto head of stack */ node->data.access = sk->data.access; node->next = sk->next; node->type = sk->type; sk->next = node; sk->data.access = access; sk->num += 1; return WOLFSSL_SUCCESS; } /* Frees all nodes in ACCESS_DESCRIPTION stack * * sk stack of nodes to free * f free function to use, not called with wolfSSL */ void wolfSSL_sk_ACCESS_DESCRIPTION_pop_free(WOLFSSL_STACK* sk, void (*f) (WOLFSSL_ACCESS_DESCRIPTION*)) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_ACCESS_DESCRIPTION_pop_free"); if (sk == NULL) { return; } /* parse through stack freeing each node */ node = sk->next; while (node && sk->num > 1) { WOLFSSL_STACK* tmp = node; node = node->next; if (f) f(tmp->data.access); else wolfSSL_ACCESS_DESCRIPTION_free(tmp->data.access); tmp->data.access = NULL; XFREE(tmp, NULL, DYNAMIC_TYPE_ASN1); sk->num -= 1; } /* free head of stack */ if (sk->num == 1) { if (f) f(sk->data.access); else { if(sk->data.access->method) { wolfSSL_ASN1_OBJECT_free(sk->data.access->method); } if(sk->data.access->location) { wolfSSL_GENERAL_NAME_free(sk->data.access->location); } } sk->data.access = NULL; } XFREE(sk, NULL, DYNAMIC_TYPE_ASN1); } void wolfSSL_sk_ACCESS_DESCRIPTION_free(WOLFSSL_STACK* sk) { wolfSSL_sk_ACCESS_DESCRIPTION_pop_free(sk, NULL); } void wolfSSL_ACCESS_DESCRIPTION_free(WOLFSSL_ACCESS_DESCRIPTION* access) { WOLFSSL_ENTER("wolfSSL_ACCESS_DESCRIPTION_free"); if (access == NULL) return; if (access->method) wolfSSL_ASN1_OBJECT_free(access->method); if (access->location) wolfSSL_GENERAL_NAME_free(access->location); /* access = NULL, don't try to access or double free it */ } #endif #ifdef OPENSSL_EXTRA /* create a generic wolfSSL stack node * returns a new WOLFSSL_STACK structure on success */ WOLFSSL_STACK* wolfSSL_sk_new_node(void* heap) { WOLFSSL_STACK* sk; WOLFSSL_ENTER("wolfSSL_sk_new_node"); sk = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), heap, DYNAMIC_TYPE_OPENSSL); if (sk != NULL) { XMEMSET(sk, 0, sizeof(*sk)); sk->heap = heap; } return sk; } /* free's node but does not free internal data such as in->data.x509 */ void wolfSSL_sk_free_node(WOLFSSL_STACK* in) { if (in != NULL) { XFREE(in, in->heap, DYNAMIC_TYPE_OPENSSL); } } /* pushes node "in" onto "stack" and returns pointer to the new stack on success * also handles internal "num" for number of nodes on stack * return WOLFSSL_SUCCESS on success */ int wolfSSL_sk_push_node(WOLFSSL_STACK** stack, WOLFSSL_STACK* in) { if (stack == NULL || in == NULL) { return WOLFSSL_FAILURE; } if (*stack == NULL) { in->num = 1; *stack = in; return WOLFSSL_SUCCESS; } in->num = (*stack)->num + 1; in->next = *stack; *stack = in; return WOLFSSL_SUCCESS; } /* return 1 on success 0 on fail */ int wolfSSL_sk_push(WOLFSSL_STACK* sk, const void *data) { int ret = WOLFSSL_FAILURE; WOLFSSL_ENTER("wolfSSL_sk_push"); switch (sk->type) { #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) case STACK_TYPE_X509: ret = wolfSSL_sk_X509_push(sk, (WOLFSSL_X509*) data); break; #ifndef NO_WOLFSSL_STUB case STACK_TYPE_CIPHER: ret = wolfSSL_sk_CIPHER_push(sk, (WOLFSSL_CIPHER*) data); break; #endif case STACK_TYPE_GEN_NAME: ret = wolfSSL_sk_ASN1_OBJECT_push(sk, (WOLFSSL_ASN1_OBJECT*) data); break; case STACK_TYPE_ACCESS_DESCRIPTION: ret = wolfSSL_sk_ACCESS_DESCRIPTION_push(sk, (WOLFSSL_ACCESS_DESCRIPTION*) data); break; case STACK_TYPE_NULL: ret = wolfSSL_sk_GENERIC_push(sk, (void*) data); break; case STACK_TYPE_OBJ: ret = wolfSSL_sk_ASN1_OBJECT_push(sk, (WOLFSSL_ASN1_OBJECT*) data); break; #endif default: ret = wolfSSL_sk_ASN1_OBJECT_push(sk, (WOLFSSL_ASN1_OBJECT*) data); break; } return ret; } /* Creates and returns new GENERAL_NAME structure */ WOLFSSL_GENERAL_NAME* wolfSSL_GENERAL_NAME_new(void) { WOLFSSL_GENERAL_NAME* gn; WOLFSSL_ENTER("GENERAL_NAME_new"); gn = (WOLFSSL_GENERAL_NAME*)XMALLOC(sizeof(WOLFSSL_GENERAL_NAME), NULL, DYNAMIC_TYPE_ASN1); if (gn == NULL) { return NULL; } XMEMSET(gn, 0, sizeof(WOLFSSL_GENERAL_NAME)); gn->d.ia5 = wolfSSL_ASN1_STRING_new(); if (gn->d.ia5 == NULL) { WOLFSSL_MSG("Issue creating ASN1_STRING struct"); wolfSSL_GENERAL_NAME_free(gn); return NULL; } return gn; } /* return 1 on success 0 on fail */ int wolfSSL_sk_GENERAL_NAME_push(WOLF_STACK_OF(WOLFSSL_GENERAL_NAME)* sk, WOLFSSL_GENERAL_NAME* gn) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_GENERAL_NAME_push"); if (sk == NULL || gn == NULL) { return WOLFSSL_FAILURE; } /* no previous values in stack */ if (sk->data.gn == NULL) { sk->data.gn = gn; sk->num += 1; return WOLFSSL_SUCCESS; } /* stack already has value(s) create a new node and add more */ node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_ASN1); if (node == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } XMEMSET(node, 0, sizeof(WOLFSSL_STACK)); /* push new obj onto head of stack */ node->data.gn = sk->data.gn; node->next = sk->next; sk->next = node; sk->data.gn = gn; sk->num += 1; return WOLFSSL_SUCCESS; } /* Returns the general name at index i from the stack * * sk stack to get general name from * idx index to get * * return a pointer to the internal node of the stack */ WOLFSSL_GENERAL_NAME* wolfSSL_sk_GENERAL_NAME_value(WOLFSSL_STACK* sk, int idx) { WOLFSSL_STACK* ret; if (sk == NULL) { return NULL; } ret = wolfSSL_sk_get_node(sk, idx); if (ret != NULL) { return ret->data.gn; } return NULL; } /* Gets the number of nodes in the stack * * sk stack to get the number of nodes from * * returns the number of nodes, -1 if no nodes */ int wolfSSL_sk_GENERAL_NAME_num(WOLFSSL_STACK* sk) { WOLFSSL_ENTER("wolfSSL_sk_GENERAL_NAME_num"); if (sk == NULL) { return -1; } return (int)sk->num; } /* Frees all nodes in a GENERAL NAME stack * * sk stack of nodes to free * f free function to use, not called with wolfSSL */ void wolfSSL_sk_GENERAL_NAME_pop_free(WOLFSSL_STACK* sk, void (*f) (WOLFSSL_GENERAL_NAME*)) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_GENERAL_NAME_pop_free"); if (sk == NULL) { return; } /* parse through stack freeing each node */ node = sk->next; while (node && sk->num > 1) { WOLFSSL_STACK* tmp = node; node = node->next; if (f) f(tmp->data.gn); else wolfSSL_GENERAL_NAME_free(tmp->data.gn); XFREE(tmp, NULL, DYNAMIC_TYPE_ASN1); sk->num -= 1; } /* free head of stack */ if (sk->num == 1) { if (f) f(sk->data.gn); else wolfSSL_GENERAL_NAME_free(sk->data.gn); } XFREE(sk, NULL, DYNAMIC_TYPE_ASN1); } void wolfSSL_sk_GENERAL_NAME_free(WOLFSSL_STACK* sk) { WOLFSSL_ENTER("sk_GENERAL_NAME_free"); wolfSSL_sk_GENERAL_NAME_pop_free(sk, NULL); } /* returns the number of nodes in stack on success and WOLFSSL_FATAL_ERROR * on fail */ int wolfSSL_sk_ACCESS_DESCRIPTION_num(WOLFSSL_STACK* sk) { if (sk == NULL) { return WOLFSSL_FATAL_ERROR; } return (int)sk->num; } #ifndef NO_WOLFSSL_STUB /* similar to call to sk_ACCESS_DESCRIPTION_pop_free */ void wolfSSL_AUTHORITY_INFO_ACCESS_free( WOLF_STACK_OF(WOLFSSL_ACCESS_DESCRIPTION)* sk) { WOLFSSL_STUB("wolfSSL_AUTHORITY_INFO_ACCESS_free"); (void)sk; } #endif /* returns the node at index "idx", NULL if not found */ WOLFSSL_STACK* wolfSSL_sk_get_node(WOLFSSL_STACK* sk, int idx) { int i; WOLFSSL_STACK* ret = NULL; WOLFSSL_STACK* current; current = sk; for (i = 0; i <= idx && current != NULL; i++) { if (i == idx) { ret = current; break; } current = current->next; } return ret; } /* returns NULL on fail and pointer to internal data on success */ WOLFSSL_ACCESS_DESCRIPTION* wolfSSL_sk_ACCESS_DESCRIPTION_value( WOLFSSL_STACK* sk, int idx) { WOLFSSL_STACK* ret; if (sk == NULL) { return NULL; } ret = wolfSSL_sk_get_node(sk, idx); if (ret != NULL) { return ret->data.access; } return NULL; } /* Frees GENERAL_NAME objects. */ void wolfSSL_GENERAL_NAME_free(WOLFSSL_GENERAL_NAME* name) { WOLFSSL_ENTER("wolfSSL_GENERAL_NAME_Free"); if(name != NULL) { if (name->d.dNSName != NULL) { wolfSSL_ASN1_STRING_free(name->d.dNSName); name->d.dNSName = NULL; } if (name->d.uniformResourceIdentifier != NULL) { wolfSSL_ASN1_STRING_free(name->d.uniformResourceIdentifier); name->d.uniformResourceIdentifier = NULL; } if (name->d.iPAddress != NULL) { wolfSSL_ASN1_STRING_free(name->d.iPAddress); name->d.iPAddress = NULL; } if (name->d.registeredID != NULL) { wolfSSL_ASN1_OBJECT_free(name->d.registeredID); name->d.registeredID = NULL; } if (name->d.ia5 != NULL) { wolfSSL_ASN1_STRING_free(name->d.ia5); name->d.ia5 = NULL; } XFREE(name, NULL, DYNAMIC_TYPE_OPENSSL); } } void wolfSSL_GENERAL_NAMES_free(WOLFSSL_GENERAL_NAMES *gens) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_GENERAL_NAMES_free"); if (gens == NULL) { return; } /* parse through stack freeing each node */ node = gens->next; while (gens->num > 1) { WOLFSSL_STACK* tmp = node; node = node->next; wolfSSL_ASN1_OBJECT_free(tmp->data.obj); XFREE(tmp, NULL, DYNAMIC_TYPE_ASN1); gens->num -= 1; } /* free head of stack */ if (gens->num == 1) { wolfSSL_ASN1_OBJECT_free(gens->data.obj); } XFREE(gens, NULL, DYNAMIC_TYPE_ASN1); } #if defined(OPENSSL_ALL) WOLF_STACK_OF(WOLFSSL_X509_EXTENSION)* wolfSSL_sk_X509_EXTENSION_new_null(void) { WOLFSSL_STACK* sk = wolfSSL_sk_new_node(NULL); if (sk) { sk->type = STACK_TYPE_X509_EXT; } return (WOLF_STACK_OF(WOLFSSL_X509_EXTENSION)*)sk;; } /* returns the number of nodes on the stack */ int wolfSSL_sk_X509_EXTENSION_num(WOLF_STACK_OF(WOLFSSL_X509_EXTENSION)* sk) { if (sk != NULL) { return (int)sk->num; } return WOLFSSL_FATAL_ERROR; } /* returns null on failure and pointer to internal value on success */ WOLFSSL_X509_EXTENSION* wolfSSL_sk_X509_EXTENSION_value( WOLF_STACK_OF(WOLFSSL_X509_EXTENSION)* sk, int idx) { WOLFSSL_STACK* ret; if (sk == NULL) { return NULL; } ret = wolfSSL_sk_get_node(sk, idx); if (ret != NULL) { return ret->data.ext; } return NULL; } /* frees all of the nodes and the values in stack */ void wolfSSL_sk_X509_EXTENSION_pop_free( WOLF_STACK_OF(WOLFSSL_X509_EXTENSION)* sk, void (*f) (WOLFSSL_X509_EXTENSION*)) { WOLFSSL_STACK* current; if (sk == NULL) { return; } current = sk; while (current != NULL) { WOLFSSL_STACK* toFree = current; current = current->next; if (f) f(toFree->data.ext); wolfSSL_sk_free_node(toFree); } } #if defined(HAVE_ECC) /* Copies ecc_key into new WOLFSSL_EC_KEY object * * src : EC_KEY to duplicate. If EC_KEY is not null, create new EC_KEY and copy * internal ecc_key from src to dup. * * Returns pointer to duplicate EC_KEY. */ WOLFSSL_EC_KEY *wolfSSL_EC_KEY_dup(const WOLFSSL_EC_KEY *src) { WOLFSSL_EC_KEY *dup; ecc_key *key, *srcKey; int ret; WOLFSSL_ENTER("wolfSSL_EC_KEY_dup"); if (src == NULL || src->internal == NULL || src->group == NULL || \ src->pub_key == NULL || src->priv_key == NULL) { WOLFSSL_MSG("src NULL error"); return NULL; } dup = wolfSSL_EC_KEY_new(); if (dup == NULL) { WOLFSSL_MSG("wolfSSL_EC_KEY_new error"); return NULL; } key = (ecc_key*)dup->internal; if (key == NULL) { WOLFSSL_MSG("ecc_key NULL error"); wolfSSL_EC_KEY_free(dup); return NULL; } srcKey = (ecc_key*)src->internal; /* ecc_key */ /* copy pubkey */ ret = wc_ecc_copy_point(&srcKey->pubkey, &key->pubkey); if (ret != MP_OKAY) { WOLFSSL_MSG("wc_ecc_copy_point error"); wolfSSL_EC_KEY_free(dup); return NULL; } /* copy private key k */ ret = mp_copy(&srcKey->k, &key->k); if (ret != MP_OKAY) { WOLFSSL_MSG("mp_copy error"); wolfSSL_EC_KEY_free(dup); return NULL; } /* copy domain parameters */ if (srcKey->dp) { ret = wc_ecc_set_curve(key, 0, srcKey->dp->id); if (ret != 0) { WOLFSSL_MSG("wc_ecc_set_curve error"); return NULL; } } key->type = srcKey->type; key->idx = srcKey->idx; key->state = srcKey->state; key->flags = srcKey->flags; /* Copy group */ if (dup->group == NULL) { WOLFSSL_MSG("EC_GROUP_new_by_curve_name error"); wolfSSL_EC_KEY_free(dup); return NULL; } dup->group->curve_idx = src->group->curve_idx; dup->group->curve_nid = src->group->curve_nid; dup->group->curve_oid = src->group->curve_oid; /* Copy public key */ if (src->pub_key->internal == NULL || dup->pub_key->internal == NULL) { WOLFSSL_MSG("NULL pub_key error"); wolfSSL_EC_KEY_free(dup); return NULL; } /* Copy public key internal */ ret = wc_ecc_copy_point((ecc_point*)src->pub_key->internal, \ (ecc_point*)dup->pub_key->internal); if (ret != MP_OKAY) { WOLFSSL_MSG("ecc_copy_point error"); wolfSSL_EC_KEY_free(dup); return NULL; } /* Copy X, Y, Z */ dup->pub_key->X = wolfSSL_BN_dup(src->pub_key->X); if (!dup->pub_key->X && src->pub_key->X) { WOLFSSL_MSG("Error copying EC_POINT"); wolfSSL_EC_KEY_free(dup); return NULL; } dup->pub_key->Y = wolfSSL_BN_dup(src->pub_key->Y); if (!dup->pub_key->Y && src->pub_key->Y) { WOLFSSL_MSG("Error copying EC_POINT"); wolfSSL_EC_KEY_free(dup); return NULL; } dup->pub_key->Z = wolfSSL_BN_dup(src->pub_key->Z); if (!dup->pub_key->Z && src->pub_key->Z) { WOLFSSL_MSG("Error copying EC_POINT"); wolfSSL_EC_KEY_free(dup); return NULL; } dup->pub_key->inSet = src->pub_key->inSet; dup->pub_key->exSet = src->pub_key->exSet; /* Copy private key */ if (src->priv_key->internal == NULL || dup->priv_key->internal == NULL) { WOLFSSL_MSG("NULL priv_key error"); wolfSSL_EC_KEY_free(dup); return NULL; } /* Free priv_key before call to dup function */ wolfSSL_BN_free(dup->priv_key); dup->priv_key = wolfSSL_BN_dup(src->priv_key); if (dup->priv_key == NULL) { WOLFSSL_MSG("BN_dup error"); wolfSSL_EC_KEY_free(dup); return NULL; } return dup; } #endif /* HAVE_ECC */ #if !defined(NO_DH) int wolfSSL_DH_check(const WOLFSSL_DH *dh, int *codes) { int isPrime = MP_NO, codeTmp = 0; WC_RNG rng; WOLFSSL_ENTER("wolfSSL_DH_check"); if (dh == NULL){ return WOLFSSL_FAILURE; } if (dh->g == NULL || dh->g->internal == NULL){ codeTmp = DH_NOT_SUITABLE_GENERATOR; } if (dh->p == NULL || dh->p->internal == NULL){ codeTmp = DH_CHECK_P_NOT_PRIME; } else { /* test if dh->p has prime */ if (wc_InitRng(&rng) == 0){ mp_prime_is_prime_ex((mp_int*)dh->p->internal,8,&isPrime,&rng); } else { WOLFSSL_MSG("Error initializing rng\n"); return WOLFSSL_FAILURE; } wc_FreeRng(&rng); if (isPrime != MP_YES){ codeTmp = DH_CHECK_P_NOT_PRIME; } } /* User may choose to enter NULL for codes if they don't want to check it*/ if (codes != NULL){ *codes = codeTmp; } /* if codeTmp was set,some check was flagged invalid */ if (codeTmp){ return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* Converts DER encoded DH parameters to a WOLFSSL_DH structure. * * dh : structure to copy DH parameters into. * pp : DER encoded DH parameters * length : length to copy * * Returns pointer to WOLFSSL_DH structure on success, or NULL on failure */ WOLFSSL_DH *wolfSSL_d2i_DHparams(WOLFSSL_DH **dh, const unsigned char **pp, long length) { WOLFSSL_DH *newDH = NULL; int ret; word32 idx = 0; WOLFSSL_ENTER("wolfSSL_d2i_DHparams"); if (pp == NULL || length <= 0) { WOLFSSL_MSG("bad argument"); return NULL; } if ((newDH = wolfSSL_DH_new()) == NULL) { WOLFSSL_MSG("wolfSSL_DH_new() failed"); return NULL; } ret = wc_DhKeyDecode(*pp, &idx, (DhKey*)newDH->internal, (word32)length); if (ret != 0) { WOLFSSL_MSG("DhKeyDecode() failed"); wolfSSL_DH_free(newDH); return NULL; } newDH->inSet = 1; if (SetDhExternal(newDH) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetDhExternal failed"); wolfSSL_DH_free(newDH); return NULL; } *pp += length; if (dh != NULL){ *dh = newDH; } return newDH; } /* Converts internal WOLFSSL_DH structure to DER encoded DH. * * dh : structure to copy DH parameters from. * out : DER buffer for DH parameters * * Returns size of DER on success and WOLFSSL_FAILURE if error */ int wolfSSL_i2d_DHparams(const WOLFSSL_DH *dh, unsigned char **out) { word32 len; int ret = 0; WOLFSSL_ENTER("wolfSSL_i2d_DHparams"); if (dh == NULL) { WOLFSSL_MSG("Bad parameters"); return WOLFSSL_FAILURE; } /* Get total length */ len = 2 + mp_leading_bit((mp_int*)dh->p->internal) + mp_unsigned_bin_size((mp_int*)dh->p->internal) + 2 + mp_leading_bit((mp_int*)dh->g->internal) + mp_unsigned_bin_size((mp_int*)dh->g->internal); /* Two bytes required for length if ASN.1 SEQ data greater than 127 bytes * and less than 256 bytes. */ len = ((len > 127) ? 2 : 1) + len; if (out != NULL && *out != NULL) { ret = StoreDHparams(*out, &len, (mp_int*)dh->p->internal, (mp_int*)dh->g->internal); if (ret != MP_OKAY) { WOLFSSL_MSG("StoreDHparams error"); len = 0; } else{ *out += len; } } return (int)len; } #endif /* !NO_DH */ #endif /* OPENSSL_ALL */ #endif /* OPENSSL_EXTRA */ #ifndef NO_FILESYSTEM #ifndef NO_STDIO_FILESYSTEM WOLFSSL_X509* wolfSSL_X509_d2i_fp(WOLFSSL_X509** x509, XFILE file) { WOLFSSL_X509* newX509 = NULL; WOLFSSL_ENTER("wolfSSL_X509_d2i_fp"); if (file != XBADFILE) { byte* fileBuffer = NULL; long sz = 0; if (XFSEEK(file, 0, XSEEK_END) != 0) return NULL; sz = XFTELL(file); XREWIND(file); if (sz > MAX_WOLFSSL_FILE_SIZE || sz < 0) { WOLFSSL_MSG("X509_d2i file size error"); return NULL; } fileBuffer = (byte*)XMALLOC(sz, NULL, DYNAMIC_TYPE_FILE); if (fileBuffer != NULL) { int ret = (int)XFREAD(fileBuffer, 1, sz, file); if (ret == sz) { newX509 = wolfSSL_X509_d2i(NULL, fileBuffer, (int)sz); } XFREE(fileBuffer, NULL, DYNAMIC_TYPE_FILE); } } if (x509 != NULL) *x509 = newX509; return newX509; } #endif /* NO_STDIO_FILESYSTEM */ WOLFSSL_ABI WOLFSSL_X509* wolfSSL_X509_load_certificate_file(const char* fname, int format) { #ifdef WOLFSSL_SMALL_STACK byte staticBuffer[1]; /* force heap usage */ #else byte staticBuffer[FILE_BUFFER_SIZE]; #endif byte* fileBuffer = staticBuffer; int dynamic = 0; int ret; long sz = 0; XFILE file; WOLFSSL_X509* x509 = NULL; /* Check the inputs */ if ((fname == NULL) || (format != WOLFSSL_FILETYPE_ASN1 && format != WOLFSSL_FILETYPE_PEM)) return NULL; file = XFOPEN(fname, "rb"); if (file == XBADFILE) return NULL; if (XFSEEK(file, 0, XSEEK_END) != 0){ XFCLOSE(file); return NULL; } sz = XFTELL(file); XREWIND(file); if (sz > MAX_WOLFSSL_FILE_SIZE || sz < 0) { WOLFSSL_MSG("X509_load_certificate_file size error"); XFCLOSE(file); return NULL; } if (sz > (long)sizeof(staticBuffer)) { fileBuffer = (byte*)XMALLOC(sz, NULL, DYNAMIC_TYPE_FILE); if (fileBuffer == NULL) { XFCLOSE(file); return NULL; } dynamic = 1; } ret = (int)XFREAD(fileBuffer, 1, sz, file); if (ret != sz) { XFCLOSE(file); if (dynamic) XFREE(fileBuffer, NULL, DYNAMIC_TYPE_FILE); return NULL; } XFCLOSE(file); x509 = wolfSSL_X509_load_certificate_buffer(fileBuffer, (int)sz, format); if (dynamic) XFREE(fileBuffer, NULL, DYNAMIC_TYPE_FILE); return x509; } #endif /* NO_FILESYSTEM */ WOLFSSL_X509* wolfSSL_X509_load_certificate_buffer( const unsigned char* buf, int sz, int format) { int ret; WOLFSSL_X509* x509 = NULL; DerBuffer* der = NULL; WOLFSSL_ENTER("wolfSSL_X509_load_certificate_ex"); if (format == WOLFSSL_FILETYPE_PEM) { #ifdef WOLFSSL_PEM_TO_DER if (PemToDer(buf, sz, CERT_TYPE, &der, NULL, NULL, NULL) != 0) { FreeDer(&der); } #else ret = NOT_COMPILED_IN; #endif } else { ret = AllocDer(&der, (word32)sz, CERT_TYPE, NULL); if (ret == 0) { XMEMCPY(der->buffer, buf, sz); } } /* At this point we want `der` to have the certificate in DER format */ /* ready to be decoded. */ if (der != NULL && der->buffer != NULL) { #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert; #else DecodedCert cert[1]; #endif #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (cert != NULL) #endif { InitDecodedCert(cert, der->buffer, der->length, NULL); if (ParseCertRelative(cert, CERT_TYPE, 0, NULL) == 0) { x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL, DYNAMIC_TYPE_X509); if (x509 != NULL) { InitX509(x509, 1, NULL); if (CopyDecodedToX509(x509, cert) != 0) { wolfSSL_X509_free(x509); x509 = NULL; } } } FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, NULL, DYNAMIC_TYPE_DCERT); #endif } FreeDer(&der); } return x509; } #endif /* KEEP_PEER_CERT || SESSION_CERTS */ /* OPENSSL_EXTRA is needed for wolfSSL_X509_d21 function KEEP_OUR_CERT is to insure ability for returning ssl certificate */ #if (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) && \ defined(KEEP_OUR_CERT) WOLFSSL_X509* wolfSSL_get_certificate(WOLFSSL* ssl) { if (ssl == NULL) { return NULL; } if (ssl->buffers.weOwnCert) { if (ssl->ourCert == NULL) { if (ssl->buffers.certificate == NULL) { WOLFSSL_MSG("Certificate buffer not set!"); return NULL; } #ifndef WOLFSSL_X509_STORE_CERTS ssl->ourCert = wolfSSL_X509_d2i(NULL, ssl->buffers.certificate->buffer, ssl->buffers.certificate->length); #endif } return ssl->ourCert; } else { /* if cert not owned get parent ctx cert or return null */ if (ssl->ctx) { if (ssl->ctx->ourCert == NULL) { if (ssl->ctx->certificate == NULL) { WOLFSSL_MSG("Ctx Certificate buffer not set!"); return NULL; } #ifndef WOLFSSL_X509_STORE_CERTS ssl->ctx->ourCert = wolfSSL_X509_d2i(NULL, ssl->ctx->certificate->buffer, ssl->ctx->certificate->length); #endif ssl->ctx->ownOurCert = 1; } return ssl->ctx->ourCert; } } return NULL; } #endif /* OPENSSL_EXTRA && KEEP_OUR_CERT */ #endif /* NO_CERTS */ #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) #ifndef NO_ASN void wolfSSL_ASN1_OBJECT_free(WOLFSSL_ASN1_OBJECT* obj) { if (obj == NULL) { return; } if ((obj->obj != NULL) && ((obj->dynamic & WOLFSSL_ASN1_DYNAMIC_DATA) != 0)) { WOLFSSL_MSG("Freeing ASN1 data"); XFREE((void*)obj->obj, obj->heap, DYNAMIC_TYPE_ASN1); obj->obj = NULL; } #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) if (obj->pathlen != NULL) { wolfSSL_ASN1_INTEGER_free(obj->pathlen); obj->pathlen = NULL; } #endif if ((obj->dynamic & WOLFSSL_ASN1_DYNAMIC) != 0) { WOLFSSL_MSG("Freeing ASN1 OBJECT"); XFREE(obj, NULL, DYNAMIC_TYPE_ASN1); } } #endif /* NO_ASN */ #endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */ #ifdef OPENSSL_EXTRA #ifndef NO_ASN WOLFSSL_ASN1_OBJECT* wolfSSL_ASN1_OBJECT_new(void) { WOLFSSL_ASN1_OBJECT* obj; obj = (WOLFSSL_ASN1_OBJECT*)XMALLOC(sizeof(WOLFSSL_ASN1_OBJECT), NULL, DYNAMIC_TYPE_ASN1); if (obj == NULL) { return NULL; } XMEMSET(obj, 0, sizeof(WOLFSSL_ASN1_OBJECT)); obj->d.ia5 = &(obj->d.ia5_internal); #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) obj->d.iPAddress = &(obj->d.iPAddress_internal); #endif obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; return obj; } /* Creates and returns a new WOLFSSL_CIPHER stack. */ WOLFSSL_STACK* wolfSSL_sk_new_asn1_obj(void) { WOLFSSL_STACK* sk; WOLFSSL_ENTER("wolfSSL_sk_new_asn1_obj"); sk = wolfSSL_sk_new_null(); if (sk == NULL) return NULL; sk->type = STACK_TYPE_OBJ; return sk; } /* return 1 on success 0 on fail */ int wolfSSL_sk_ASN1_OBJECT_push(WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)* sk, WOLFSSL_ASN1_OBJECT* obj) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_ASN1_OBJECT_push"); if (sk == NULL || obj == NULL) { return WOLFSSL_FAILURE; } /* no previous values in stack */ if (sk->data.obj == NULL) { sk->data.obj = obj; sk->num += 1; return WOLFSSL_SUCCESS; } /* stack already has value(s) create a new node and add more */ node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_ASN1); if (node == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } XMEMSET(node, 0, sizeof(WOLFSSL_STACK)); /* push new obj onto head of stack */ node->data.obj = sk->data.obj; node->next = sk->next; node->type = sk->type; sk->next = node; sk->data.obj = obj; sk->num += 1; return WOLFSSL_SUCCESS; } WOLFSSL_ASN1_OBJECT* wolfSSL_sk_ASN1_OBJECT_pop( WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)* sk) { WOLFSSL_STACK* node; WOLFSSL_ASN1_OBJECT* obj; if (sk == NULL) { return NULL; } node = sk->next; obj = sk->data.obj; if (node != NULL) { /* update sk and remove node from stack */ sk->data.obj = node->data.obj; sk->next = node->next; XFREE(node, NULL, DYNAMIC_TYPE_ASN1); } else { /* last obj in stack */ sk->data.obj = NULL; } if (sk->num > 0) { sk->num -= 1; } return obj; } /* Free the structure for ASN1_OBJECT stack * * sk stack to free nodes in */ void wolfSSL_sk_ASN1_OBJECT_free(WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)* sk) { wolfSSL_sk_ASN1_OBJECT_pop_free(sk, NULL); } /* Free's all nodes in ASN1_OBJECT stack. * This is different then wolfSSL_ASN1_OBJECT_free in that it allows for * choosing the function to use when freeing an ASN1_OBJECT stack. * * sk stack to free nodes in * f X509 free function */ void wolfSSL_sk_ASN1_OBJECT_pop_free(WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)* sk, void (*f) (WOLFSSL_ASN1_OBJECT*)) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_ASN1_OBJECT_pop_free"); if (sk == NULL) { WOLFSSL_MSG("Parameter error"); return; } /* parse through stack freeing each node */ node = sk->next; while (node && sk->num > 1) { WOLFSSL_STACK* tmp = node; node = node->next; if (f) f(tmp->data.obj); else wolfSSL_ASN1_OBJECT_free(tmp->data.obj); tmp->data.obj = NULL; XFREE(tmp, NULL, DYNAMIC_TYPE_ASN1); sk->num -= 1; } /* free head of stack */ if (sk->num == 1) { if (f) f(sk->data.obj); else wolfSSL_ASN1_OBJECT_free(sk->data.obj); sk->data.obj = NULL; } XFREE(sk, NULL, DYNAMIC_TYPE_ASN1); } int wolfSSL_ASN1_STRING_to_UTF8(unsigned char **out, WOLFSSL_ASN1_STRING *in) { /* ASN1_STRING_to_UTF8() converts the string in to UTF8 format, the converted data is allocated in a buffer in *out. The length of out is returned or a negative error code. The buffer *out should be free using OPENSSL_free(). */ unsigned char* buf; unsigned char* inPtr; int inLen; if (!out || !in) { return -1; } inPtr = wolfSSL_ASN1_STRING_data(in); inLen = wolfSSL_ASN1_STRING_length(in); if (!inPtr || inLen < 0) { return -1; } buf = (unsigned char*)XMALLOC(inLen + 1, NULL, DYNAMIC_TYPE_OPENSSL); if (!buf) { return -1; } XMEMCPY(buf, inPtr, inLen + 1); *out = buf; return inLen; } /* Returns string representation of ASN1_STRING */ char* wolfSSL_i2s_ASN1_STRING(WOLFSSL_v3_ext_method *method, const WOLFSSL_ASN1_STRING *s) { int i; int tmpSz = 100; int valSz = 5; char* tmp; char val[5]; unsigned char* str; WOLFSSL_ENTER("wolfSSL_i2s_ASN1_STRING"); (void)method; if(s == NULL || s->data == NULL) { WOLFSSL_MSG("Bad Function Argument"); return NULL; } str = (unsigned char*)XMALLOC(s->length, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (str == NULL) { WOLFSSL_MSG("Memory Error"); return NULL; } XMEMCPY(str, (unsigned char*)s->data, s->length); tmp = (char*)XMALLOC(tmpSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (tmp == NULL) { WOLFSSL_MSG("Memory Error"); XFREE(str, NULL, DYNAMIC_TYPE_TMP_BUFFER); return NULL; } XMEMSET(tmp, 0, tmpSz); for (i = 0; i < tmpSz && i < (s->length - 1); i++) { XSNPRINTF(val, valSz - 1, "%02X:", str[i]); XSTRNCAT(tmp, val, valSz); } XSNPRINTF(val, valSz - 1, "%02X", str[i]); XSTRNCAT(tmp, val, valSz); XFREE(str, NULL, DYNAMIC_TYPE_TMP_BUFFER); return tmp; } #endif /* NO_ASN */ void wolfSSL_set_connect_state(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_set_connect_state"); if (ssl == NULL) { WOLFSSL_MSG("WOLFSSL struct pointer passed in was null"); return; } #ifndef NO_DH /* client creates its own DH parameters on handshake */ if (ssl->buffers.serverDH_P.buffer && ssl->buffers.weOwnDH) { XFREE(ssl->buffers.serverDH_P.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); } ssl->buffers.serverDH_P.buffer = NULL; if (ssl->buffers.serverDH_G.buffer && ssl->buffers.weOwnDH) { XFREE(ssl->buffers.serverDH_G.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); } ssl->buffers.serverDH_G.buffer = NULL; #endif if (InitSSL_Side(ssl, WOLFSSL_CLIENT_END) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error initializing client side"); } } #endif /* OPENSSL_EXTRA */ int wolfSSL_get_shutdown(const WOLFSSL* ssl) { int isShutdown = 0; WOLFSSL_ENTER("wolfSSL_get_shutdown"); if (ssl) { /* in OpenSSL, WOLFSSL_SENT_SHUTDOWN = 1, when closeNotifySent * * WOLFSSL_RECEIVED_SHUTDOWN = 2, from close notify or fatal err */ isShutdown = ((ssl->options.closeNotify||ssl->options.connReset) << 1) | (ssl->options.sentNotify); } return isShutdown; } int wolfSSL_session_reused(WOLFSSL* ssl) { int resuming = 0; if (ssl) resuming = ssl->options.resuming; return resuming; } #if defined(OPENSSL_EXTRA) || defined(HAVE_EXT_CACHE) WOLFSSL_SESSION* wolfSSL_SESSION_dup(WOLFSSL_SESSION* session) { #ifdef HAVE_EXT_CACHE WOLFSSL_SESSION* copy; WOLFSSL_ENTER("wolfSSL_SESSION_dup"); if (session == NULL) return NULL; #ifdef HAVE_SESSION_TICKET if (session->isDynamic && !session->ticket) { WOLFSSL_MSG("Session dynamic flag is set but ticket pointer is null"); return NULL; } #endif copy = (WOLFSSL_SESSION*)XMALLOC(sizeof(WOLFSSL_SESSION), NULL, DYNAMIC_TYPE_OPENSSL); if (copy != NULL) { XMEMCPY(copy, session, sizeof(WOLFSSL_SESSION)); copy->isAlloced = 1; #ifdef HAVE_SESSION_TICKET if (session->isDynamic) { copy->ticket = (byte*)XMALLOC(session->ticketLen, NULL, DYNAMIC_TYPE_SESSION_TICK); XMEMCPY(copy->ticket, session->ticket, session->ticketLen); } else { copy->ticket = copy->staticTicket; } #endif #if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA) copy->peer = wolfSSL_X509_dup(session->peer); #endif } return copy; #else WOLFSSL_MSG("wolfSSL_SESSION_dup was called " "but HAVE_EXT_CACHE is not defined"); (void)session; return NULL; #endif /* HAVE_EXT_CACHE */ } void wolfSSL_SESSION_free(WOLFSSL_SESSION* session) { if (session == NULL) return; #if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA) if (session->peer) { wolfSSL_X509_free(session->peer); } #endif #ifdef HAVE_EXT_CACHE if (session->isAlloced) { #ifdef HAVE_SESSION_TICKET if (session->isDynamic) XFREE(session->ticket, NULL, DYNAMIC_TYPE_SESSION_TICK); #endif XFREE(session, NULL, DYNAMIC_TYPE_OPENSSL); } #else /* No need to free since cache is static */ (void)session; #endif } #endif /* helper function that takes in a protocol version struct and returns string */ static const char* wolfSSL_internal_get_version(ProtocolVersion* version) { WOLFSSL_ENTER("wolfSSL_get_version"); if (version == NULL) { return "Bad arg"; } if (version->major == SSLv3_MAJOR) { switch (version->minor) { #ifndef NO_OLD_TLS #ifdef WOLFSSL_ALLOW_SSLV3 case SSLv3_MINOR : return "SSLv3"; #endif #ifdef WOLFSSL_ALLOW_TLSV10 case TLSv1_MINOR : return "TLSv1"; #endif case TLSv1_1_MINOR : return "TLSv1.1"; #endif case TLSv1_2_MINOR : return "TLSv1.2"; #ifdef WOLFSSL_TLS13 case TLSv1_3_MINOR : #ifdef WOLFSSL_TLS13_DRAFT #ifdef WOLFSSL_TLS13_DRAFT_18 return "TLSv1.3 (Draft 18)"; #elif defined(WOLFSSL_TLS13_DRAFT_22) return "TLSv1.3 (Draft 22)"; #elif defined(WOLFSSL_TLS13_DRAFT_23) return "TLSv1.3 (Draft 23)"; #elif defined(WOLFSSL_TLS13_DRAFT_26) return "TLSv1.3 (Draft 26)"; #else return "TLSv1.3 (Draft 28)"; #endif #else return "TLSv1.3"; #endif #endif default: return "unknown"; } } #ifdef WOLFSSL_DTLS else if (version->major == DTLS_MAJOR) { switch (version->minor) { case DTLS_MINOR : return "DTLS"; case DTLSv1_2_MINOR : return "DTLSv1.2"; default: return "unknown"; } } #endif /* WOLFSSL_DTLS */ return "unknown"; } const char* wolfSSL_get_version(WOLFSSL* ssl) { if (ssl == NULL) { WOLFSSL_MSG("Bad argument"); return "unknown"; } return wolfSSL_internal_get_version(&ssl->version); } /* current library version */ const char* wolfSSL_lib_version(void) { return LIBWOLFSSL_VERSION_STRING; } /* current library version in hex */ word32 wolfSSL_lib_version_hex(void) { return LIBWOLFSSL_VERSION_HEX; } int wolfSSL_get_current_cipher_suite(WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_get_current_cipher_suite"); if (ssl) return (ssl->options.cipherSuite0 << 8) | ssl->options.cipherSuite; return 0; } WOLFSSL_CIPHER* wolfSSL_get_current_cipher(WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_get_current_cipher"); if (ssl) { ssl->cipher.cipherSuite0 = ssl->options.cipherSuite0; ssl->cipher.cipherSuite = ssl->options.cipherSuite; return &ssl->cipher; } else return NULL; } const char* wolfSSL_CIPHER_get_name(const WOLFSSL_CIPHER* cipher) { WOLFSSL_ENTER("wolfSSL_CIPHER_get_name"); if (cipher == NULL) { return NULL; } #if !defined(WOLFSSL_CIPHER_INTERNALNAME) && !defined(NO_ERROR_STRINGS) && \ !defined(WOLFSSL_QT) return GetCipherNameIana(cipher->cipherSuite0, cipher->cipherSuite); #else return wolfSSL_get_cipher_name_from_suite(cipher->cipherSuite0, cipher->cipherSuite); #endif } const char* wolfSSL_CIPHER_get_version(const WOLFSSL_CIPHER* cipher) { WOLFSSL_ENTER("SSL_CIPHER_get_version"); if (cipher == NULL || cipher->ssl == NULL) { return NULL; } return wolfSSL_get_version(cipher->ssl); } const char* wolfSSL_SESSION_CIPHER_get_name(WOLFSSL_SESSION* session) { if (session == NULL) { return NULL; } #if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \ (defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)) #if !defined(WOLFSSL_CIPHER_INTERNALNAME) && !defined(NO_ERROR_STRINGS) return GetCipherNameIana(session->cipherSuite0, session->cipherSuite); #else return GetCipherNameInternal(session->cipherSuite0, session->cipherSuite); #endif #else return NULL; #endif } const char* wolfSSL_get_cipher(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_cipher"); return wolfSSL_CIPHER_get_name(wolfSSL_get_current_cipher(ssl)); } /* gets cipher name in the format DHE-RSA-... rather then TLS_DHE... */ const char* wolfSSL_get_cipher_name(WOLFSSL* ssl) { /* get access to cipher_name_idx in internal.c */ return wolfSSL_get_cipher_name_internal(ssl); } const char* wolfSSL_get_cipher_name_from_suite(const byte cipherSuite0, const byte cipherSuite) { return GetCipherNameInternal(cipherSuite0, cipherSuite); } const char* wolfSSL_get_cipher_name_iana_from_suite(const byte cipherSuite0, const byte cipherSuite) { return GetCipherNameIana(cipherSuite0, cipherSuite); } #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) /* Creates and returns a new WOLFSSL_CIPHER stack. */ WOLFSSL_STACK* wolfSSL_sk_new_cipher(void) { WOLFSSL_STACK* sk; WOLFSSL_ENTER("wolfSSL_sk_new_cipher"); sk = wolfSSL_sk_new_null(); if (sk == NULL) return NULL; sk->type = STACK_TYPE_CIPHER; return sk; } #ifndef NO_WOLFSSL_STUB /* Keep as stubs for now */ /* return 1 on success 0 on fail */ int wolfSSL_sk_CIPHER_push(WOLF_STACK_OF(WOLFSSL_CIPHER)* sk, WOLFSSL_CIPHER* cipher) { WOLFSSL_STUB("wolfSSL_sk_CIPHER_push"); (void)sk; (void)cipher; return 0; } WOLFSSL_CIPHER* wolfSSL_sk_CIPHER_pop(WOLF_STACK_OF(WOLFSSL_CIPHER)* sk) { WOLFSSL_STUB("wolfSSL_sk_CIPHER_pop"); (void)sk; return NULL; } #endif /* NO_WOLFSSL_STUB */ #endif /* WOLFSSL_QT || OPENSSL_ALL */ word32 wolfSSL_CIPHER_get_id(const WOLFSSL_CIPHER* cipher) { word16 cipher_id = 0; WOLFSSL_ENTER("SSL_CIPHER_get_id"); if (cipher && cipher->ssl) { cipher_id = (cipher->ssl->options.cipherSuite0 << 8) | cipher->ssl->options.cipherSuite; } return cipher_id; } const WOLFSSL_CIPHER* wolfSSL_get_cipher_by_value(word16 value) { const WOLFSSL_CIPHER* cipher = NULL; byte cipherSuite0, cipherSuite; WOLFSSL_ENTER("SSL_get_cipher_by_value"); /* extract cipher id information */ cipherSuite = (value & 0xFF); cipherSuite0 = ((value >> 8) & 0xFF); /* TODO: lookup by cipherSuite0 / cipherSuite */ (void)cipherSuite0; (void)cipherSuite; return cipher; } #if defined(OPENSSL_ALL) /* Free the structure for WOLFSSL_CIPHER stack * * sk stack to free nodes in */ void wolfSSL_sk_CIPHER_free(WOLF_STACK_OF(WOLFSSL_CIPHER)* sk) { WOLFSSL_STACK* node; WOLFSSL_STACK* tmp; WOLFSSL_ENTER("wolfSSL_sk_CIPHER_free"); if (sk == NULL) return; /* parse through stack freeing each node */ node = sk->next; while (node) { tmp = node; node = node->next; XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL); } /* free head of stack */ XFREE(sk, NULL, DYNAMIC_TYPE_ASN1); } #endif #if defined(HAVE_ECC) || defined(HAVE_CURVE25519) || defined(HAVE_CURVE448) || \ !defined(NO_DH) #ifdef HAVE_FFDHE static const char* wolfssl_ffdhe_name(word16 group) { const char* str = NULL; switch (group) { case WOLFSSL_FFDHE_2048: str = "FFDHE_2048"; break; case WOLFSSL_FFDHE_3072: str = "FFDHE_3072"; break; case WOLFSSL_FFDHE_4096: str = "FFDHE_4096"; break; case WOLFSSL_FFDHE_6144: str = "FFDHE_6144"; break; case WOLFSSL_FFDHE_8192: str = "FFDHE_8192"; break; } return str; } #endif /* Return the name of the curve used for key exchange as a printable string. * * ssl The SSL/TLS object. * returns NULL if ECDH was not used, otherwise the name as a string. */ const char* wolfSSL_get_curve_name(WOLFSSL* ssl) { const char* cName = NULL; if (ssl == NULL) return NULL; #ifdef HAVE_FFDHE if (ssl->namedGroup != 0) { cName = wolfssl_ffdhe_name(ssl->namedGroup); } #endif #ifdef HAVE_CURVE25519 if (ssl->ecdhCurveOID == ECC_X25519_OID && cName == NULL) { cName = "X25519"; } #endif #ifdef HAVE_CURVE448 if (ssl->ecdhCurveOID == ECC_X448_OID && cName == NULL) { cName = "X448"; } #endif #ifdef HAVE_ECC if (ssl->ecdhCurveOID != 0 && cName == NULL) { cName = wc_ecc_get_name(wc_ecc_get_oid(ssl->ecdhCurveOID, NULL, NULL)); } #endif return cName; } #endif #if defined(OPENSSL_EXTRA_X509_SMALL) || defined(KEEP_PEER_CERT) || \ defined(SESSION_CERTS) /* Smaller subset of X509 compatibility functions. Avoid increasing the size of * this subset and its memory usage */ #if !defined(NO_CERTS) /* returns a pointer to a new WOLFSSL_X509 structure on success and NULL on * fail */ WOLFSSL_X509* wolfSSL_X509_new(void) { WOLFSSL_X509* x509; x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL, DYNAMIC_TYPE_X509); if (x509 != NULL) { InitX509(x509, 1, NULL); } return x509; } WOLFSSL_ABI WOLFSSL_X509_NAME* wolfSSL_X509_get_subject_name(WOLFSSL_X509* cert) { WOLFSSL_ENTER("wolfSSL_X509_get_subject_name"); if (cert && cert->subject.sz != 0) return &cert->subject; return NULL; } #if defined(OPENSSL_EXTRA) && !defined(NO_SHA) /****************************************************************************** * wolfSSL_X509_subject_name_hash - compute the hash digest of the raw subject name * * RETURNS: * The beginning of the hash digest. Otherwise, returns zero. * Note: * Returns a different hash value from OpenSSL's X509_subject_name_hash() API * depending on the subject name. */ unsigned long wolfSSL_X509_subject_name_hash(const WOLFSSL_X509* x509) { word32 ret = 0; int retHash; WOLFSSL_X509_NAME *subjectName = NULL; #ifdef WOLFSSL_PIC32MZ_HASH byte digest[PIC32_DIGEST_SIZE]; #else byte digest[WC_SHA_DIGEST_SIZE]; #endif if (x509 == NULL){ return WOLFSSL_FAILURE; } subjectName = wolfSSL_X509_get_subject_name((WOLFSSL_X509*)x509); if (subjectName != NULL){ retHash = wc_ShaHash((const byte*)subjectName->name, (word32)subjectName->sz, digest); if(retHash != 0){ WOLFSSL_MSG("Hash of X509 subjectName has failed"); return WOLFSSL_FAILURE; } ret = MakeWordFromHash(digest); } return (unsigned long)ret; } #endif WOLFSSL_ABI WOLFSSL_X509_NAME* wolfSSL_X509_get_issuer_name(WOLFSSL_X509* cert) { WOLFSSL_ENTER("X509_get_issuer_name"); if (cert && cert->issuer.sz != 0) return &cert->issuer; return NULL; } int wolfSSL_X509_get_signature_type(WOLFSSL_X509* x509) { int type = 0; WOLFSSL_ENTER("wolfSSL_X509_get_signature_type"); if (x509 != NULL) type = x509->sigOID; return type; } #if defined(OPENSSL_EXTRA_X509_SMALL) /* Used to get a string from the WOLFSSL_X509_NAME structure that * corresponds with the NID value passed in. * * name structure to get string from * nid NID value to search for * buf [out] buffer to hold results. If NULL then the buffer size minus the * null char is returned. * len size of "buf" passed in * * returns the length of string found, not including the NULL terminator. * It's possible the function could return a negative value in the * case that len is less than or equal to 0. A negative value is * considered an error case. */ int wolfSSL_X509_NAME_get_text_by_NID(WOLFSSL_X509_NAME* name, int nid, char* buf, int len) { char *text = NULL; int textSz = 0; WOLFSSL_ENTER("wolfSSL_X509_NAME_get_text_by_NID"); switch (nid) { case ASN_COMMON_NAME: text = name->fullName.fullName + name->fullName.cnIdx; textSz = name->fullName.cnLen; break; case ASN_SUR_NAME: text = name->fullName.fullName + name->fullName.snIdx; textSz = name->fullName.snLen; break; case ASN_SERIAL_NUMBER: text = name->fullName.fullName + name->fullName.serialIdx; textSz = name->fullName.serialLen; break; case ASN_COUNTRY_NAME: text = name->fullName.fullName + name->fullName.cIdx; textSz = name->fullName.cLen; break; case ASN_LOCALITY_NAME: text = name->fullName.fullName + name->fullName.lIdx; textSz = name->fullName.lLen; break; case ASN_STATE_NAME: text = name->fullName.fullName + name->fullName.stIdx; textSz = name->fullName.stLen; break; case ASN_ORG_NAME: text = name->fullName.fullName + name->fullName.oIdx; textSz = name->fullName.oLen; break; case ASN_ORGUNIT_NAME: text = name->fullName.fullName + name->fullName.ouIdx; textSz = name->fullName.ouLen; break; case ASN_DOMAIN_COMPONENT: text = name->fullName.fullName + name->fullName.dcIdx[0]; textSz = name->fullName.dcLen[0]; break; case NID_emailAddress: text = name->fullName.fullName + name->fullName.emailIdx; textSz = name->fullName.emailLen; break; #ifdef WOLFSSL_CERT_EXT case ASN_BUS_CAT: text = name->fullName.fullName + name->fullName.bcIdx; textSz = name->fullName.bcLen; break; #endif default: WOLFSSL_MSG("Entry type not found"); return WOLFSSL_FATAL_ERROR; } /* if buf is NULL return size of buffer needed (minus null char) */ if (buf == NULL) { return textSz; } if (buf != NULL && text != NULL) { textSz = min(textSz + 1, len); /* + 1 to account for null char */ if (textSz > 0) { XMEMCPY(buf, text, textSz - 1); buf[textSz - 1] = '\0'; } } WOLFSSL_LEAVE("wolfSSL_X509_NAME_get_text_by_NID", textSz); return (textSz - 1); /* do not include null character in size */ } /* Creates a new WOLFSSL_EVP_PKEY structure that has the public key from x509 * * returns a pointer to the created WOLFSSL_EVP_PKEY on success and NULL on fail */ WOLFSSL_EVP_PKEY* wolfSSL_X509_get_pubkey(WOLFSSL_X509* x509) { WOLFSSL_EVP_PKEY* key = NULL; WOLFSSL_ENTER("X509_get_pubkey"); if (x509 != NULL) { key = wolfSSL_EVP_PKEY_new_ex(x509->heap); if (key != NULL) { if (x509->pubKeyOID == RSAk) { key->type = EVP_PKEY_RSA; } else if (x509->pubKeyOID == DSAk) { key->type = EVP_PKEY_DSA; } else { key->type = EVP_PKEY_EC; } key->save_type = 0; key->pkey.ptr = (char*)XMALLOC( x509->pubKey.length, x509->heap, DYNAMIC_TYPE_PUBLIC_KEY); if (key->pkey.ptr == NULL) { wolfSSL_EVP_PKEY_free(key); return NULL; } XMEMCPY(key->pkey.ptr, x509->pubKey.buffer, x509->pubKey.length); key->pkey_sz = x509->pubKey.length; #ifdef HAVE_ECC key->pkey_curve = (int)x509->pkCurveOID; #endif /* HAVE_ECC */ /* decode RSA key */ #ifndef NO_RSA if (key->type == EVP_PKEY_RSA) { key->ownRsa = 1; key->rsa = wolfSSL_RSA_new(); if (key->rsa == NULL) { wolfSSL_EVP_PKEY_free(key); return NULL; } if (wolfSSL_RSA_LoadDer_ex(key->rsa, (const unsigned char*)key->pkey.ptr, key->pkey_sz, WOLFSSL_RSA_LOAD_PUBLIC) != SSL_SUCCESS) { wolfSSL_EVP_PKEY_free(key); return NULL; } } #endif /* NO_RSA */ /* decode ECC key */ #if defined(HAVE_ECC) && defined(OPENSSL_EXTRA) if (key->type == EVP_PKEY_EC) { word32 idx = 0; key->ownEcc = 1; key->ecc = wolfSSL_EC_KEY_new(); if (key->ecc == NULL || key->ecc->internal == NULL) { wolfSSL_EVP_PKEY_free(key); return NULL; } /* not using wolfSSL_EC_KEY_LoadDer because public key in x509 * is in the format of x963 (no sequence at start of buffer) */ if (wc_EccPublicKeyDecode((const unsigned char*)key->pkey.ptr, &idx, (ecc_key*)key->ecc->internal, key->pkey_sz) < 0) { WOLFSSL_MSG("wc_EccPublicKeyDecode failed"); wolfSSL_EVP_PKEY_free(key); return NULL; } if (SetECKeyExternal(key->ecc) != SSL_SUCCESS) { WOLFSSL_MSG("SetECKeyExternal failed"); wolfSSL_EVP_PKEY_free(key); return NULL; } key->ecc->inSet = 1; } #endif /* HAVE_ECC */ #ifndef NO_DSA if (key->type == EVP_PKEY_DSA) { key->ownDsa = 1; key->dsa = wolfSSL_DSA_new(); if (key->dsa == NULL) { wolfSSL_EVP_PKEY_free(key); return NULL; } if (wolfSSL_DSA_LoadDer_ex(key->dsa, (const unsigned char*)key->pkey.ptr, key->pkey_sz, \ WOLFSSL_DSA_LOAD_PUBLIC) != SSL_SUCCESS) { wolfSSL_DSA_free(key->dsa); key->dsa = NULL; wolfSSL_EVP_PKEY_free(key); return NULL; } } #endif /* NO_DSA */ } } return key; } #endif /* OPENSSL_EXTRA_X509_SMALL */ #endif /* !NO_CERTS */ /* End of smaller subset of X509 compatibility functions. Avoid increasing the * size of this subset and its memory usage */ #endif /* OPENSSL_EXTRA_X509_SMALL */ #if defined(OPENSSL_ALL) /* Takes two WOLFSSL_X509* certificates and performs a Sha hash of each, if the * has values are the same, then it will do an XMEMCMP to confirm they are * identical. Returns a 0 when certificates match, returns a negative number * when certificates are not a match. */ int wolfSSL_X509_cmp(const WOLFSSL_X509 *a, const WOLFSSL_X509 *b) { const byte* derA; const byte* derB; int retHashA; int retHashB; int outSzA = 0; int outSzB = 0; #ifdef WOLFSSL_PIC32MZ_HASH byte digestA[PIC32_DIGEST_SIZE]; byte digestB[PIC32_DIGEST_SIZE]; #else byte digestA[WC_SHA_DIGEST_SIZE]; byte digestB[WC_SHA_DIGEST_SIZE]; #endif if (a == NULL || b == NULL){ return BAD_FUNC_ARG; } derA = wolfSSL_X509_get_der((WOLFSSL_X509*)a, &outSzA); if(derA == NULL){ WOLFSSL_MSG("wolfSSL_X509_get_der - certificate A has failed"); return WOLFSSL_FATAL_ERROR; } derB = wolfSSL_X509_get_der((WOLFSSL_X509*)b, &outSzB); if(derB == NULL){ WOLFSSL_MSG("wolfSSL_X509_get_der - certificate B has failed"); return WOLFSSL_FATAL_ERROR; } retHashA = wc_ShaHash(derA, (word32)outSzA, digestA); if(retHashA != 0){ WOLFSSL_MSG("Hash of certificate A has failed"); return WOLFSSL_FATAL_ERROR; } retHashB = wc_ShaHash(derB, (word32)outSzB, digestB); if(retHashB != 0){ WOLFSSL_MSG("Hash of certificate B has failed"); return WOLFSSL_FATAL_ERROR; } if (outSzA == outSzB){ #ifdef WOLFSSL_PIC32MZ_HASH if(XMEMCMP(digestA, digestB, PIC32_DIGEST_SIZE) != 0){ return WOLFSSL_FATAL_ERROR; } #else if(XMEMCMP(digestA, digestB, WC_SHA_DIGEST_SIZE) != 0){ return WOLFSSL_FATAL_ERROR; } #endif else{ WOLFSSL_LEAVE("wolfSSL_X509_cmp", 0); return 0; } } else{ WOLFSSL_LEAVE("wolfSSL_X509_cmp", WOLFSSL_FATAL_ERROR); return WOLFSSL_FATAL_ERROR; } } #endif #if defined(OPENSSL_EXTRA) #if !defined(NO_CERTS) int wolfSSL_X509_ext_isSet_by_NID(WOLFSSL_X509* x509, int nid) { int isSet = 0; WOLFSSL_ENTER("wolfSSL_X509_ext_isSet_by_NID"); if (x509 != NULL) { switch (nid) { case BASIC_CA_OID: isSet = x509->basicConstSet; break; case ALT_NAMES_OID: isSet = x509->subjAltNameSet; break; case AUTH_KEY_OID: isSet = x509->authKeyIdSet; break; case SUBJ_KEY_OID: isSet = x509->subjKeyIdSet; break; case KEY_USAGE_OID: isSet = x509->keyUsageSet; break; case CRL_DIST_OID: isSet = x509->CRLdistSet; break; case EXT_KEY_USAGE_OID: isSet = ((x509->extKeyUsageSrc) ? 1 : 0); break; case AUTH_INFO_OID: isSet = x509->authInfoSet; break; #if defined(WOLFSSL_SEP) || defined(WOLFSSL_QT) case CERT_POLICY_OID: isSet = x509->certPolicySet; break; #endif /* WOLFSSL_SEP || WOLFSSL_QT */ default: WOLFSSL_MSG("NID not in table"); } } WOLFSSL_LEAVE("wolfSSL_X509_ext_isSet_by_NID", isSet); return isSet; } int wolfSSL_X509_ext_get_critical_by_NID(WOLFSSL_X509* x509, int nid) { int crit = 0; WOLFSSL_ENTER("wolfSSL_X509_ext_get_critical_by_NID"); if (x509 != NULL) { switch (nid) { case BASIC_CA_OID: crit = x509->basicConstCrit; break; case ALT_NAMES_OID: crit = x509->subjAltNameCrit; break; case AUTH_KEY_OID: crit = x509->authKeyIdCrit; break; case SUBJ_KEY_OID: crit = x509->subjKeyIdCrit; break; case KEY_USAGE_OID: crit = x509->keyUsageCrit; break; case CRL_DIST_OID: crit= x509->CRLdistCrit; break; #if defined(WOLFSSL_SEP) || defined(WOLFSSL_QT) case CERT_POLICY_OID: crit = x509->certPolicyCrit; break; #endif /* WOLFSSL_SEP || WOLFSSL_QT */ } } WOLFSSL_LEAVE("wolfSSL_X509_ext_get_critical_by_NID", crit); return crit; } int wolfSSL_X509_get_isSet_pathLength(WOLFSSL_X509* x509) { int isSet = 0; WOLFSSL_ENTER("wolfSSL_X509_get_isSet_pathLength"); if (x509 != NULL) isSet = x509->basicConstPlSet; WOLFSSL_LEAVE("wolfSSL_X509_get_isSet_pathLength", isSet); return isSet; } word32 wolfSSL_X509_get_pathLength(WOLFSSL_X509* x509) { word32 pathLength = 0; WOLFSSL_ENTER("wolfSSL_X509_get_pathLength"); if (x509 != NULL) pathLength = x509->pathLength; WOLFSSL_LEAVE("wolfSSL_X509_get_pathLength", pathLength); return pathLength; } unsigned int wolfSSL_X509_get_keyUsage(WOLFSSL_X509* x509) { word16 usage = 0; WOLFSSL_ENTER("wolfSSL_X509_get_keyUsage"); if (x509 != NULL) usage = x509->keyUsage; WOLFSSL_LEAVE("wolfSSL_X509_get_keyUsage", usage); return usage; } byte* wolfSSL_X509_get_authorityKeyID(WOLFSSL_X509* x509, byte* dst, int* dstLen) { byte *id = NULL; int copySz = 0; WOLFSSL_ENTER("wolfSSL_X509_get_authorityKeyID"); if (x509 != NULL) { if (x509->authKeyIdSet) { copySz = min(dstLen != NULL ? *dstLen : 0, (int)x509->authKeyIdSz); id = x509->authKeyId; } if (dst != NULL && dstLen != NULL && id != NULL && copySz > 0) { XMEMCPY(dst, id, copySz); id = dst; *dstLen = copySz; } } WOLFSSL_LEAVE("wolfSSL_X509_get_authorityKeyID", copySz); return id; } byte* wolfSSL_X509_get_subjectKeyID(WOLFSSL_X509* x509, byte* dst, int* dstLen) { byte *id = NULL; int copySz = 0; WOLFSSL_ENTER("wolfSSL_X509_get_subjectKeyID"); if (x509 != NULL) { if (x509->subjKeyIdSet) { copySz = min(dstLen != NULL ? *dstLen : 0, (int)x509->subjKeyIdSz); id = x509->subjKeyId; } if (dst != NULL && dstLen != NULL && id != NULL && copySz > 0) { XMEMCPY(dst, id, copySz); id = dst; *dstLen = copySz; } } WOLFSSL_LEAVE("wolfSSL_X509_get_subjectKeyID", copySz); return id; } int wolfSSL_X509_NAME_entry_count(WOLFSSL_X509_NAME* name) { int count = 0; WOLFSSL_ENTER("wolfSSL_X509_NAME_entry_count"); if (name != NULL) count = name->fullName.locSz; WOLFSSL_LEAVE("wolfSSL_X509_NAME_entry_count", count); return count; } int wolfSSL_X509_NAME_get_index_by_NID(WOLFSSL_X509_NAME* name, int nid, int pos) { int value = nid, i; WOLFSSL_ENTER("wolfSSL_X509_NAME_get_index_by_NID"); if (name == NULL || pos >= DN_NAMES_MAX + DOMAIN_COMPONENT_MAX) { return BAD_FUNC_ARG; } if (value == NID_emailAddress) { value = ASN_EMAIL_NAME; } i = pos + 1; /* start search after index passed in */ if (i < 0) { i = 0; } for (;i < name->fullName.locSz && i < DN_NAMES_MAX + DOMAIN_COMPONENT_MAX; i++) { if (name->fullName.loc[i] == value) { return i; } } return WOLFSSL_FATAL_ERROR; } WOLFSSL_ASN1_STRING* wolfSSL_X509_NAME_ENTRY_get_data( WOLFSSL_X509_NAME_ENTRY* in) { WOLFSSL_ENTER("wolfSSL_X509_NAME_ENTRY_get_data"); if (in == NULL) return NULL; return in->value; } /* Creates a new WOLFSSL_ASN1_STRING structure. * * returns a pointer to the new structure created on success or NULL if fail */ WOLFSSL_ASN1_STRING* wolfSSL_ASN1_STRING_new(void) { WOLFSSL_ASN1_STRING* asn1; WOLFSSL_ENTER("wolfSSL_ASN1_STRING_new"); asn1 = (WOLFSSL_ASN1_STRING*)XMALLOC(sizeof(WOLFSSL_ASN1_STRING), NULL, DYNAMIC_TYPE_OPENSSL); if (asn1 != NULL) { XMEMSET(asn1, 0, sizeof(WOLFSSL_ASN1_STRING)); } return asn1; /* no check for null because error case is returning null*/ } /* used to free a WOLFSSL_ASN1_STRING structure */ void wolfSSL_ASN1_STRING_free(WOLFSSL_ASN1_STRING* asn1) { WOLFSSL_ENTER("wolfSSL_ASN1_STRING_free"); if (asn1 != NULL) { if (asn1->length > 0 && asn1->data != NULL && asn1->isDynamic) { XFREE(asn1->data, NULL, DYNAMIC_TYPE_OPENSSL); } XFREE(asn1, NULL, DYNAMIC_TYPE_OPENSSL); } } /* Creates a new WOLFSSL_ASN1_STRING structure given the input type. * * type is the type of set when WOLFSSL_ASN1_STRING is created * * returns a pointer to the new structure created on success or NULL if fail */ WOLFSSL_ASN1_STRING* wolfSSL_ASN1_STRING_type_new(int type) { WOLFSSL_ASN1_STRING* asn1; WOLFSSL_ENTER("wolfSSL_ASN1_STRING_type_new"); asn1 = wolfSSL_ASN1_STRING_new(); if (asn1 == NULL) { return NULL; } asn1->type = type; return asn1; } /****************************************************************************** * wolfSSL_ASN1_STRING_type - returns the type of * * RETURNS: * returns the type set for . Otherwise, returns WOLFSSL_FAILURE. */ int wolfSSL_ASN1_STRING_type(const WOLFSSL_ASN1_STRING* asn1) { WOLFSSL_ENTER("wolfSSL_ASN1_STRING_type"); if (asn1 == NULL) { return WOLFSSL_FAILURE; } return asn1->type; } /* if dataSz is negative then use XSTRLEN to find length of data * return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on failure */ /* `data` can be NULL and only buffer will be allocated */ int wolfSSL_ASN1_STRING_set(WOLFSSL_ASN1_STRING* asn1, const void* data, int dataSz) { int sz; WOLFSSL_ENTER("wolfSSL_ASN1_STRING_set"); if (asn1 == NULL || (data == NULL && dataSz < 0)) { return WOLFSSL_FAILURE; } if (dataSz < 0) { sz = (int)XSTRLEN((const char*)data) + 1; /* +1 for null */ } else { sz = dataSz; } if (sz < 0) { return WOLFSSL_FAILURE; } /* free any existing data before copying */ if (asn1->data != NULL && asn1->isDynamic) { XFREE(asn1->data, NULL, DYNAMIC_TYPE_OPENSSL); asn1->data = NULL; } if (sz > CTC_NAME_SIZE) { /* create new data buffer and copy over */ asn1->data = (char*)XMALLOC(sz, NULL, DYNAMIC_TYPE_OPENSSL); if (asn1->data == NULL) { return WOLFSSL_FAILURE; } asn1->isDynamic = 1; } else { XMEMSET(asn1->strData, 0, CTC_NAME_SIZE); asn1->data = asn1->strData; asn1->isDynamic = 0; } if (data != NULL) { XMEMCPY(asn1->data, data, sz); asn1->data[sz] = '\0'; } asn1->length = sz; return WOLFSSL_SUCCESS; } unsigned char* wolfSSL_ASN1_STRING_data(WOLFSSL_ASN1_STRING* asn) { WOLFSSL_ENTER("wolfSSL_ASN1_STRING_data"); if (asn) { return (unsigned char*)asn->data; } else { return NULL; } } int wolfSSL_ASN1_STRING_length(WOLFSSL_ASN1_STRING* asn) { WOLFSSL_ENTER("wolfSSL_ASN1_STRING_length"); if (asn) { return asn->length; } else { return 0; } } #ifndef NO_WOLFSSL_STUB WOLFSSL_ASN1_STRING* wolfSSL_d2i_DISPLAYTEXT(WOLFSSL_ASN1_STRING **asn, const unsigned char **in, long len) { WOLFSSL_STUB("d2i_DISPLAYTEXT"); (void)asn; (void)in; (void)len; return NULL; } #endif #ifdef XSNPRINTF /* a snprintf function needs to be available */ /* Writes the human readable form of x509 to bio. * * bio WOLFSSL_BIO to write to. * x509 Certificate to write. * * returns WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on failure */ int wolfSSL_X509_print_ex(WOLFSSL_BIO* bio, WOLFSSL_X509* x509, unsigned long nmflags, unsigned long cflag) { WOLFSSL_ENTER("wolfSSL_X509_print_ex"); #ifndef NO_WOLFSSL_STUB /* flags currently not supported */ (void)nmflags; (void)cflag; #endif if (bio == NULL || x509 == NULL) { return WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bio, "Certificate:\n", (int)XSTRLEN("Certificate:\n")) <= 0) { return WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bio, " Data:\n", (int)XSTRLEN(" Data:\n")) <= 0) { return WOLFSSL_FAILURE; } /* print version of cert */ { int version; char tmp[20]; if ((version = wolfSSL_X509_version(x509)) < 0) { WOLFSSL_MSG("Error getting X509 version"); return WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bio, " Version:", (int)XSTRLEN(" Version:")) <= 0) { return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp), " %d (0x%x)\n", version, (byte)version-1); if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } /* print serial number out */ { unsigned char serial[32]; int sz = sizeof(serial); XMEMSET(serial, 0, sz); if (wolfSSL_X509_get_serial_number(x509, serial, &sz) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error getting x509 serial number"); return WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bio, " Serial Number:", (int)XSTRLEN(" Serial Number:")) <= 0) { return WOLFSSL_FAILURE; } /* if serial can fit into byte than print on the same line */ if (sz <= (int)sizeof(byte)) { char tmp[17]; XSNPRINTF(tmp, sizeof(tmp), " %d (0x%x)\n", serial[0],serial[0]); if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } else { int i; char tmp[100]; int tmpSz = 100; char val[5]; int valSz = 5; /* serial is larger than int size so print off hex values */ if (wolfSSL_BIO_write(bio, "\n ", (int)XSTRLEN("\n ")) <= 0) { return WOLFSSL_FAILURE; } tmp[0] = '\0'; for (i = 0; i < sz - 1 && (3 * i) < tmpSz - valSz; i++) { XSNPRINTF(val, sizeof(val) - 1, "%02x:", serial[i]); val[3] = '\0'; /* make sure is null terminated */ XSTRNCAT(tmp, val, valSz); } XSNPRINTF(val, sizeof(val) - 1, "%02x\n", serial[i]); val[3] = '\0'; /* make sure is null terminated */ XSTRNCAT(tmp, val, valSz); if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } } /* print signature algo */ { int oid; const char* sig; if ((oid = wolfSSL_X509_get_signature_type(x509)) <= 0) { WOLFSSL_MSG("Error getting x509 signature type"); return WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bio, " Signature Algorithm: ", (int)XSTRLEN(" Signature Algorithm: ")) <= 0) { return WOLFSSL_FAILURE; } sig = GetSigName(oid); if (wolfSSL_BIO_write(bio, sig, (int)XSTRLEN(sig)) <= 0) { return WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bio, "\n", (int)XSTRLEN("\n")) <= 0) { return WOLFSSL_FAILURE; } } /* print issuer */ { char* issuer; #ifdef WOLFSSL_SMALL_STACK char* buff = NULL; int issSz = 0; #else char buff[256]; int issSz = 256; #endif #if defined(WOLFSSL_QT) issuer = wolfSSL_X509_get_name_oneline( wolfSSL_X509_get_issuer_name(x509), buff, issSz); #else issuer = wolfSSL_X509_NAME_oneline( wolfSSL_X509_get_issuer_name(x509), buff, issSz); #endif if (wolfSSL_BIO_write(bio, " Issuer: ", (int)XSTRLEN(" Issuer: ")) <= 0) { #ifdef WOLFSSL_SMALL_STACK XFREE(issuer, NULL, DYNAMIC_TYPE_OPENSSL); #endif return WOLFSSL_FAILURE; } if (issuer != NULL) { if (wolfSSL_BIO_write(bio, issuer, (int)XSTRLEN(issuer)) <= 0) { #ifdef WOLFSSL_SMALL_STACK XFREE(issuer, NULL, DYNAMIC_TYPE_OPENSSL); #endif return WOLFSSL_FAILURE; } } #ifdef WOLFSSL_SMALL_STACK XFREE(issuer, NULL, DYNAMIC_TYPE_OPENSSL); #endif if (wolfSSL_BIO_write(bio, "\n", (int)XSTRLEN("\n")) <= 0) { return WOLFSSL_FAILURE; } } #ifndef NO_ASN_TIME /* print validity */ { char tmp[80]; if (wolfSSL_BIO_write(bio, " Validity\n", (int)XSTRLEN(" Validity\n")) <= 0) { return WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bio, " Not Before: ", (int)XSTRLEN(" Not Before: ")) <= 0) { return WOLFSSL_FAILURE; } if (x509->notBefore.length > 0) { if (GetTimeString(x509->notBefore.data, ASN_UTC_TIME, tmp, sizeof(tmp)) != WOLFSSL_SUCCESS) { if (GetTimeString(x509->notBefore.data, ASN_GENERALIZED_TIME, tmp, sizeof(tmp)) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error getting not before date"); return WOLFSSL_FAILURE; } } } else { XSTRNCPY(tmp, "Not Set", sizeof(tmp)-1); } tmp[sizeof(tmp) - 1] = '\0'; /* make sure null terminated */ if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bio, "\n Not After : ", (int)XSTRLEN("\n Not After : ")) <= 0) { return WOLFSSL_FAILURE; } if (x509->notAfter.length > 0) { if (GetTimeString(x509->notAfter.data, ASN_UTC_TIME, tmp, sizeof(tmp)) != WOLFSSL_SUCCESS) { if (GetTimeString(x509->notAfter.data, ASN_GENERALIZED_TIME, tmp, sizeof(tmp)) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error getting not after date"); return WOLFSSL_FAILURE; } } } else { XSTRNCPY(tmp, "Not Set", sizeof(tmp)-1); } tmp[sizeof(tmp) - 1] = '\0'; /* make sure null terminated */ if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } #endif /* print subject */ { char* subject; #ifdef WOLFSSL_SMALL_STACK char* buff = NULL; int subSz = 0; #else char buff[256]; int subSz = 256; #endif #if defined(WOLFSSL_QT) subject = wolfSSL_X509_get_name_oneline( wolfSSL_X509_get_subject_name(x509), buff, subSz); #else subject = wolfSSL_X509_NAME_oneline( wolfSSL_X509_get_subject_name(x509), buff, subSz); #endif if (wolfSSL_BIO_write(bio, "\n Subject: ", (int)XSTRLEN("\n Subject: ")) <= 0) { #ifdef WOLFSSL_SMALL_STACK XFREE(subject, NULL, DYNAMIC_TYPE_OPENSSL); #endif return WOLFSSL_FAILURE; } if (subject != NULL) { if (wolfSSL_BIO_write(bio, subject, (int)XSTRLEN(subject)) <= 0) { #ifdef WOLFSSL_SMALL_STACK XFREE(subject, NULL, DYNAMIC_TYPE_OPENSSL); #endif return WOLFSSL_FAILURE; } } #ifdef WOLFSSL_SMALL_STACK XFREE(subject, NULL, DYNAMIC_TYPE_OPENSSL); #endif } /* get and print public key */ if (wolfSSL_BIO_write(bio, "\n Subject Public Key Info:\n", (int)XSTRLEN("\n Subject Public Key Info:\n")) <= 0) { return WOLFSSL_FAILURE; } { #if (!defined(NO_RSA) && !defined(HAVE_USER_RSA)) || defined(HAVE_ECC) char tmp[100]; #endif switch (x509->pubKeyOID) { #ifndef NO_RSA case RSAk: if (wolfSSL_BIO_write(bio, " Public Key Algorithm: rsaEncryption\n", (int)XSTRLEN(" Public Key Algorithm: rsaEncryption\n")) <= 0) { return WOLFSSL_FAILURE; } #ifdef HAVE_USER_RSA if (wolfSSL_BIO_write(bio, " Build without user RSA to print key\n", (int)XSTRLEN(" Build without user RSA to print key\n")) <= 0) { return WOLFSSL_FAILURE; } #else { RsaKey rsa; word32 idx = 0; int sz; byte lbit = 0; int rawLen; unsigned char* rawKey; if (wc_InitRsaKey(&rsa, NULL) != 0) { WOLFSSL_MSG("wc_InitRsaKey failure"); return WOLFSSL_FAILURE; } if (wc_RsaPublicKeyDecode(x509->pubKey.buffer, &idx, &rsa, x509->pubKey.length) != 0) { WOLFSSL_MSG("Error decoding RSA key"); wc_FreeRsaKey(&rsa); return WOLFSSL_FAILURE; } if ((sz = wc_RsaEncryptSize(&rsa)) < 0) { WOLFSSL_MSG("Error getting RSA key size"); wc_FreeRsaKey(&rsa); return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1, "%s%s: (%d bit)\n%s\n", " ", "Public-Key", 8 * sz, " Modulus:"); tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { wc_FreeRsaKey(&rsa); return WOLFSSL_FAILURE; } /* print out modulus */ XSNPRINTF(tmp, sizeof(tmp) - 1," "); tmp[sizeof(tmp) - 1] = '\0'; if (mp_leading_bit(&rsa.n)) { lbit = 1; XSTRNCAT(tmp, "00", 3); } rawLen = mp_unsigned_bin_size(&rsa.n); rawKey = (unsigned char*)XMALLOC(rawLen, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (rawKey == NULL) { WOLFSSL_MSG("Memory error"); wc_FreeRsaKey(&rsa); return WOLFSSL_FAILURE; } mp_to_unsigned_bin(&rsa.n, rawKey); for (idx = 0; idx < (word32)rawLen; idx++) { char val[5]; int valSz = 5; if ((idx == 0) && !lbit) { XSNPRINTF(val, valSz - 1, "%02x", rawKey[idx]); } else if ((idx != 0) && (((idx + lbit) % 15) == 0)) { tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { XFREE(rawKey, NULL, DYNAMIC_TYPE_TMP_BUFFER); wc_FreeRsaKey(&rsa); return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1, ":\n "); XSNPRINTF(val, valSz - 1, "%02x", rawKey[idx]); } else { XSNPRINTF(val, valSz - 1, ":%02x", rawKey[idx]); } XSTRNCAT(tmp, val, valSz); } XFREE(rawKey, NULL, DYNAMIC_TYPE_TMP_BUFFER); /* print out remaining modulus values */ if ((idx > 0) && (((idx - 1 + lbit) % 15) != 0)) { tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } /* print out exponent values */ rawLen = mp_unsigned_bin_size(&rsa.e); if (rawLen < 0) { WOLFSSL_MSG("Error getting exponent size"); wc_FreeRsaKey(&rsa); return WOLFSSL_FAILURE; } if ((word32)rawLen < sizeof(word32)) { rawLen = sizeof(word32); } rawKey = (unsigned char*)XMALLOC(rawLen, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (rawKey == NULL) { WOLFSSL_MSG("Memory error"); wc_FreeRsaKey(&rsa); return WOLFSSL_FAILURE; } XMEMSET(rawKey, 0, rawLen); mp_to_unsigned_bin(&rsa.e, rawKey); if ((word32)rawLen <= sizeof(word32)) { idx = *(word32*)rawKey; #ifdef BIG_ENDIAN_ORDER idx = ByteReverseWord32(idx); #endif } XSNPRINTF(tmp, sizeof(tmp) - 1, "\n Exponent: %d (0x%x)\n",idx, idx); if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { XFREE(rawKey, NULL, DYNAMIC_TYPE_TMP_BUFFER); wc_FreeRsaKey(&rsa); return WOLFSSL_FAILURE; } XFREE(rawKey, NULL, DYNAMIC_TYPE_TMP_BUFFER); wc_FreeRsaKey(&rsa); } #endif /* HAVE_USER_RSA */ break; #endif /* NO_RSA */ #ifdef HAVE_ECC case ECDSAk: { word32 i; ecc_key ecc; if (wolfSSL_BIO_write(bio, " Public Key Algorithm: EC\n", (int)XSTRLEN(" Public Key Algorithm: EC\n")) <= 0) { return WOLFSSL_FAILURE; } if (wc_ecc_init_ex(&ecc, x509->heap, INVALID_DEVID) != 0) { return WOLFSSL_FAILURE; } i = 0; if (wc_EccPublicKeyDecode(x509->pubKey.buffer, &i, &ecc, x509->pubKey.length) != 0) { wc_ecc_free(&ecc); return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1, "%s%s: (%d bit)\n%s\n", " ", "Public-Key", 8 * wc_ecc_size(&ecc), " pub:"); tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { wc_ecc_free(&ecc); return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1," "); { word32 derSz; byte* der; derSz = wc_ecc_size(&ecc) * WOLFSSL_BIT_SIZE; der = (byte*)XMALLOC(derSz, x509->heap, DYNAMIC_TYPE_TMP_BUFFER); if (der == NULL) { wc_ecc_free(&ecc); return WOLFSSL_FAILURE; } if (wc_ecc_export_x963(&ecc, der, &derSz) != 0) { wc_ecc_free(&ecc); XFREE(der, x509->heap, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } for (i = 0; i < derSz; i++) { char val[5]; int valSz = 5; if (i == 0) { XSNPRINTF(val, valSz - 1, "%02x", der[i]); } else if ((i % 15) == 0) { tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { wc_ecc_free(&ecc); XFREE(der, x509->heap, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1, ":\n "); XSNPRINTF(val, valSz - 1, "%02x", der[i]); } else { XSNPRINTF(val, valSz - 1, ":%02x", der[i]); } XSTRNCAT(tmp, val, valSz); } /* print out remaining modulus values */ if ((i > 0) && (((i - 1) % 15) != 0)) { tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { wc_ecc_free(&ecc); XFREE(der, x509->heap, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } } XFREE(der, x509->heap, DYNAMIC_TYPE_TMP_BUFFER); } XSNPRINTF(tmp, sizeof(tmp) - 1, "\n%s%s: %s\n", " ", "ASN1 OID", ecc.dp->name); if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { wc_ecc_free(&ecc); return WOLFSSL_FAILURE; } wc_ecc_free(&ecc); } break; #endif /* HAVE_ECC */ default: WOLFSSL_MSG("Unknown key type"); return WOLFSSL_FAILURE; } } /* print out extensions */ if (wolfSSL_BIO_write(bio, " X509v3 extensions:\n", (int)XSTRLEN(" X509v3 extensions:\n")) <= 0) { return WOLFSSL_FAILURE; } /* print subject key id */ if (x509->subjKeyIdSet && x509->subjKeyId != NULL && x509->subjKeyIdSz > 0) { char tmp[100]; word32 i; char val[5]; int valSz = 5; if (wolfSSL_BIO_write(bio, " X509v3 Subject Key Identifier: \n", (int)XSTRLEN(" X509v3 Subject Key Identifier: \n")) <= 0) { return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1, " "); for (i = 0; i < sizeof(tmp) && i < (x509->subjKeyIdSz - 1); i++) { XSNPRINTF(val, valSz - 1, "%02X:", x509->subjKeyId[i]); XSTRNCAT(tmp, val, valSz); } XSNPRINTF(val, valSz - 1, "%02X\n", x509->subjKeyId[i]); XSTRNCAT(tmp, val, valSz); if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } /* printf out authority key id */ if (x509->authKeyIdSet && x509->authKeyId != NULL && x509->authKeyIdSz > 0) { char tmp[100]; word32 i; char val[5]; int valSz = 5; int len = 0; if (wolfSSL_BIO_write(bio, " X509v3 Authority Key Identifier: \n", (int)XSTRLEN(" X509v3 Authority Key Identifier: \n")) <= 0) { return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1, " keyid"); for (i = 0; i < x509->authKeyIdSz; i++) { /* check if buffer is almost full */ if (XSTRLEN(tmp) >= sizeof(tmp) - valSz) { if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } tmp[0] = '\0'; } XSNPRINTF(val, valSz - 1, ":%02X", x509->authKeyId[i]); XSTRNCAT(tmp, val, valSz); } len = (int)XSTRLEN("\n"); XSTRNCAT(tmp, "\n", len + 1); if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } /* print basic constraint */ if (x509->basicConstSet) { char tmp[100]; if (wolfSSL_BIO_write(bio, "\n X509v3 Basic Constraints: \n", (int)XSTRLEN("\n X509v3 Basic Constraints: \n")) <= 0) { return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp), " CA:%s\n", (x509->isCa)? "TRUE": "FALSE"); if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } /* print out signature */ if (x509->sig.length > 0) { unsigned char* sig; int sigSz; int i; char tmp[100]; int sigOid = wolfSSL_X509_get_signature_type(x509); if (wolfSSL_BIO_write(bio, " Signature Algorithm: ", (int)XSTRLEN(" Signature Algorithm: ")) <= 0) { return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1,"%s\n", GetSigName(sigOid)); tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } sigSz = (int)x509->sig.length; sig = (unsigned char*)XMALLOC(sigSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (sig == NULL) { return WOLFSSL_FAILURE; } if (wolfSSL_X509_get_signature(x509, sig, &sigSz) <= 0) { XFREE(sig, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1," "); tmp[sizeof(tmp) - 1] = '\0'; for (i = 0; i < sigSz; i++) { char val[5]; int valSz = 5; if (i == 0) { XSNPRINTF(val, valSz - 1, "%02x", sig[i]); } else if (((i % 18) == 0)) { tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { XFREE(sig, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1, ":\n "); XSNPRINTF(val, valSz - 1, "%02x", sig[i]); } else { XSNPRINTF(val, valSz - 1, ":%02x", sig[i]); } XSTRNCAT(tmp, val, valSz); } XFREE(sig, NULL, DYNAMIC_TYPE_TMP_BUFFER); /* print out remaining sig values */ if ((i > 0) && (((i - 1) % 18) != 0)) { tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } } /* done with print out */ if (wolfSSL_BIO_write(bio, "\n\0", (int)XSTRLEN("\n\0")) <= 0) { return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } int wolfSSL_X509_print(WOLFSSL_BIO* bio, WOLFSSL_X509* x509) { return wolfSSL_X509_print_ex(bio, x509, 0, 0); } #endif /* XSNPRINTF */ #endif /* NO_CERTS */ #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) /* Creates cipher->description based on cipher->offset * cipher->offset is set in wolfSSL_get_ciphers_compat when it is added * to a stack of ciphers. * @param [in] cipher: A cipher from a stack of ciphers. * return WOLFSSL_SUCCESS if cipher->description is set, else WOLFSSL_FAILURE */ int wolfSSL_sk_CIPHER_description(WOLFSSL_CIPHER* cipher) { int ret = WOLFSSL_FAILURE; int i,j,k; int strLen; unsigned long offset; char* dp; const char* name; const char *keaStr, *authStr, *encStr, *macStr, *protocol; char n[MAX_SEGMENTS][MAX_SEGMENT_SZ] = {{0}}; unsigned char len = MAX_DESCRIPTION_SZ-1; const CipherSuiteInfo* cipher_names; ProtocolVersion pv; WOLFSSL_ENTER("wolfSSL_sk_CIPHER_description"); if (cipher == NULL) return WOLFSSL_FAILURE; dp = cipher->description; if (dp == NULL) return WOLFSSL_FAILURE; cipher_names = GetCipherNames(); offset = cipher->offset; pv.major = cipher_names[offset].major; pv.minor = cipher_names[offset].minor; protocol = wolfSSL_internal_get_version(&pv); name = cipher_names[offset].name; if (name == NULL) return ret; /* Segment cipher name into n[n0,n1,n2,n4] * These are used later for comparisons to create: * keaStr, authStr, encStr, macStr * * If cipher_name = ECDHE-ECDSA-AES256-SHA * then n0 = "ECDHE", n1 = "ECDSA", n2 = "AES256", n3 = "SHA" * and n = [n0,n1,n2,n3,0] */ strLen = (int)XSTRLEN(name); for (i = 0, j = 0, k = 0; i <= strLen; i++) { if (k > MAX_SEGMENTS || j > MAX_SEGMENT_SZ) break; if (name[i] != '-' && name[i] != '\0') { n[k][j] = name[i]; /* Fill kth segment string until '-' */ j++; } else { n[k][j] = '\0'; j = 0; k++; } } /* keaStr */ keaStr = GetCipherKeaStr(n); /* authStr */ authStr = GetCipherAuthStr(n); /* encStr */ encStr = GetCipherEncStr(n); if ((cipher->bits = SetCipherBits(encStr)) == WOLFSSL_FAILURE) { WOLFSSL_MSG("Cipher Bits Not Set."); } /* macStr */ macStr = GetCipherMacStr(n); /* Build up the string by copying onto the end. */ XSTRNCPY(dp, name, len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, " ", len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, protocol, len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, " Kx=", len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, keaStr, len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, " Au=", len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, authStr, len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, " Enc=", len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, encStr, len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, " Mac=", len); dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp); len -= (int)strLen; dp += strLen; XSTRNCPY(dp, macStr, len); dp[len-1] = '\0'; return WOLFSSL_SUCCESS; } #endif char* wolfSSL_CIPHER_description(const WOLFSSL_CIPHER* cipher, char* in, int len) { char *ret = in; const char *keaStr, *authStr, *encStr, *macStr; size_t strLen; WOLFSSL_ENTER("wolfSSL_CIPHER_description"); if (cipher == NULL || in == NULL) return NULL; #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) /* if cipher is in the stack from wolfSSL_get_ciphers_compat then * Return the description based on cipher_names[cipher->offset] */ if (cipher->in_stack == TRUE) { wolfSSL_sk_CIPHER_description((WOLFSSL_CIPHER*)cipher); XSTRNCPY(in,cipher->description,len); return ret; } #endif /* Get the cipher description based on the SSL session cipher */ switch (cipher->ssl->specs.kea) { case no_kea: keaStr = "None"; break; #ifndef NO_RSA case rsa_kea: keaStr = "RSA"; break; #endif #ifndef NO_DH case diffie_hellman_kea: keaStr = "DHE"; break; #endif case fortezza_kea: keaStr = "FZ"; break; #ifndef NO_PSK case psk_kea: keaStr = "PSK"; break; #ifndef NO_DH case dhe_psk_kea: keaStr = "DHEPSK"; break; #endif #ifdef HAVE_ECC case ecdhe_psk_kea: keaStr = "ECDHEPSK"; break; #endif #endif #ifdef HAVE_NTRU case ntru_kea: keaStr = "NTRU"; break; #endif #ifdef HAVE_ECC case ecc_diffie_hellman_kea: keaStr = "ECDHE"; break; case ecc_static_diffie_hellman_kea: keaStr = "ECDH"; break; #endif default: keaStr = "unknown"; break; } switch (cipher->ssl->specs.sig_algo) { case anonymous_sa_algo: authStr = "None"; break; #ifndef NO_RSA case rsa_sa_algo: authStr = "RSA"; break; #endif #ifndef NO_DSA case dsa_sa_algo: authStr = "DSA"; break; #endif #ifdef HAVE_ECC case ecc_dsa_sa_algo: authStr = "ECDSA"; break; #endif default: authStr = "unknown"; break; } switch (cipher->ssl->specs.bulk_cipher_algorithm) { case wolfssl_cipher_null: encStr = "None"; break; #ifndef NO_RC4 case wolfssl_rc4: encStr = "RC4(128)"; break; #endif #ifndef NO_DES3 case wolfssl_triple_des: encStr = "3DES(168)"; break; #endif #ifdef HAVE_IDEA case wolfssl_idea: encStr = "IDEA(128)"; break; #endif #ifndef NO_AES case wolfssl_aes: if (cipher->ssl->specs.key_size == 128) encStr = "AES(128)"; else if (cipher->ssl->specs.key_size == 256) encStr = "AES(256)"; else encStr = "AES(?)"; break; #ifdef HAVE_AESGCM case wolfssl_aes_gcm: if (cipher->ssl->specs.key_size == 128) encStr = "AESGCM(128)"; else if (cipher->ssl->specs.key_size == 256) encStr = "AESGCM(256)"; else encStr = "AESGCM(?)"; break; #endif #ifdef HAVE_AESCCM case wolfssl_aes_ccm: if (cipher->ssl->specs.key_size == 128) encStr = "AESCCM(128)"; else if (cipher->ssl->specs.key_size == 256) encStr = "AESCCM(256)"; else encStr = "AESCCM(?)"; break; #endif #endif #ifdef HAVE_CHACHA case wolfssl_chacha: encStr = "CHACHA20/POLY1305(256)"; break; #endif #ifdef HAVE_CAMELLIA case wolfssl_camellia: if (cipher->ssl->specs.key_size == 128) encStr = "Camellia(128)"; else if (cipher->ssl->specs.key_size == 256) encStr = "Camellia(256)"; else encStr = "Camellia(?)"; break; #endif #if defined(HAVE_HC128) && !defined(NO_HC128) case wolfssl_hc128: encStr = "HC128(128)"; break; #endif #if defined(HAVE_RABBIT) && !defined(NO_RABBIT) case wolfssl_rabbit: encStr = "RABBIT(128)"; break; #endif default: encStr = "unknown"; break; } switch (cipher->ssl->specs.mac_algorithm) { case no_mac: macStr = "None"; break; #ifndef NO_MD5 case md5_mac: macStr = "MD5"; break; #endif #ifndef NO_SHA case sha_mac: macStr = "SHA1"; break; #endif #ifdef HAVE_SHA224 case sha224_mac: macStr = "SHA224"; break; #endif #ifndef NO_SHA256 case sha256_mac: macStr = "SHA256"; break; #endif #ifdef HAVE_SHA384 case sha384_mac: macStr = "SHA384"; break; #endif #ifdef HAVE_SHA512 case sha512_mac: macStr = "SHA512"; break; #endif default: macStr = "unknown"; break; } /* Build up the string by copying onto the end. */ XSTRNCPY(in, wolfSSL_CIPHER_get_name(cipher), len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, " ", len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, wolfSSL_get_version(cipher->ssl), len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, " Kx=", len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, keaStr, len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, " Au=", len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, authStr, len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, " Enc=", len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, encStr, len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, " Mac=", len); in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen; XSTRNCPY(in, macStr, len); in[len-1] = '\0'; return ret; } #ifndef NO_SESSION_CACHE WOLFSSL_SESSION* wolfSSL_get1_session(WOLFSSL* ssl) { if (ssl == NULL) { return NULL; } /* sessions are stored statically, no need for reference count */ return wolfSSL_get_session(ssl); } #endif /* NO_SESSION_CACHE */ /* was do nothing */ /* void OPENSSL_free(void* buf) { (void)buf; } */ #ifndef NO_WOLFSSL_STUB int wolfSSL_OCSP_parse_url(char* url, char** host, char** port, char** path, int* ssl) { (void)url; (void)host; (void)port; (void)path; (void)ssl; WOLFSSL_STUB("OCSP_parse_url"); return 0; } #endif #ifndef NO_MD4 void wolfSSL_MD4_Init(WOLFSSL_MD4_CTX* md4) { /* make sure we have a big enough buffer */ typedef char ok[sizeof(md4->buffer) >= sizeof(Md4) ? 1 : -1]; (void) sizeof(ok); WOLFSSL_ENTER("MD4_Init"); wc_InitMd4((Md4*)md4); } void wolfSSL_MD4_Update(WOLFSSL_MD4_CTX* md4, const void* data, unsigned long len) { WOLFSSL_ENTER("MD4_Update"); wc_Md4Update((Md4*)md4, (const byte*)data, (word32)len); } void wolfSSL_MD4_Final(unsigned char* digest, WOLFSSL_MD4_CTX* md4) { WOLFSSL_ENTER("MD4_Final"); wc_Md4Final((Md4*)md4, digest); } #endif /* NO_MD4 */ /* Removes a WOLFSSL_BIO struct from the WOLFSSL_BIO linked list. * * bio is the WOLFSSL_BIO struct in the list and removed. * * The return WOLFSSL_BIO struct is the next WOLFSSL_BIO in the list or NULL if * there is none. */ WOLFSSL_BIO* wolfSSL_BIO_pop(WOLFSSL_BIO* bio) { if (bio == NULL) { WOLFSSL_MSG("Bad argument passed in"); return NULL; } if (bio->prev != NULL) { bio->prev->next = bio->next; } if (bio->next != NULL) { bio->next->prev = bio->prev; } return bio->next; } WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_mem(void) { static WOLFSSL_BIO_METHOD meth; WOLFSSL_ENTER("wolfSSL_BIO_s_mem"); meth.type = WOLFSSL_BIO_MEMORY; return &meth; } WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_base64(void) { static WOLFSSL_BIO_METHOD meth; WOLFSSL_ENTER("wolfSSL_BIO_f_base64"); meth.type = WOLFSSL_BIO_BASE64; return &meth; } /* Set the flag for the bio. * * bio the structure to set the flag in * flags the flag to use */ void wolfSSL_BIO_set_flags(WOLFSSL_BIO* bio, int flags) { WOLFSSL_ENTER("wolfSSL_BIO_set_flags"); if (bio != NULL) { bio->flags |= flags; } } void wolfSSL_BIO_clear_flags(WOLFSSL_BIO *bio, int flags) { WOLFSSL_ENTER("wolfSSL_BIO_clear_flags"); if (bio != NULL) { bio->flags &= ~flags; } } /* Set ex_data for WOLFSSL_BIO * * bio : BIO structure to set ex_data in * idx : Index of ex_data to set * data : Data to set in ex_data * * Returns WOLFSSL_SUCCESS on success or WOLFSSL_FAILURE on failure */ int wolfSSL_BIO_set_ex_data(WOLFSSL_BIO *bio, int idx, void *data) { WOLFSSL_ENTER("wolfSSL_BIO_set_ex_data"); #ifdef HAVE_EX_DATA if (bio != NULL && idx < MAX_EX_DATA) { return wolfSSL_CRYPTO_set_ex_data(&bio->ex_data, idx, data); } #else (void)bio; (void)idx; (void)data; #endif return WOLFSSL_FAILURE; } /* Get ex_data in WOLFSSL_BIO at given index * * bio : BIO structure to get ex_data from * idx : Index of ex_data to get data from * * Returns void pointer to ex_data on success or NULL on failure */ void *wolfSSL_BIO_get_ex_data(WOLFSSL_BIO *bio, int idx) { WOLFSSL_ENTER("wolfSSL_BIO_get_ex_data"); #ifdef HAVE_EX_DATA if (bio != NULL && idx < MAX_EX_DATA && idx >= 0) { return wolfSSL_CRYPTO_get_ex_data(&bio->ex_data, idx); } #else (void)bio; (void)idx; #endif return NULL; } #ifndef NO_WOLFSSL_STUB void wolfSSL_RAND_screen(void) { WOLFSSL_STUB("RAND_screen"); } #endif int wolfSSL_RAND_load_file(const char* fname, long len) { (void)fname; /* wolfCrypt provides enough entropy internally or will report error */ if (len == -1) return 1024; else return (int)len; } #ifndef NO_WOLFSSL_STUB WOLFSSL_COMP_METHOD* wolfSSL_COMP_zlib(void) { WOLFSSL_STUB("COMP_zlib"); return 0; } #endif #ifndef NO_WOLFSSL_STUB WOLFSSL_COMP_METHOD* wolfSSL_COMP_rle(void) { WOLFSSL_STUB("COMP_rle"); return 0; } #endif #ifndef NO_WOLFSSL_STUB int wolfSSL_COMP_add_compression_method(int method, void* data) { (void)method; (void)data; WOLFSSL_STUB("COMP_add_compression_method"); return 0; } #endif #ifndef NO_WOLFSSL_STUB void wolfSSL_set_dynlock_create_callback(WOLFSSL_dynlock_value* (*f)( const char*, int)) { WOLFSSL_STUB("CRYPTO_set_dynlock_create_callback"); (void)f; } #endif #ifndef NO_WOLFSSL_STUB void wolfSSL_set_dynlock_lock_callback( void (*f)(int, WOLFSSL_dynlock_value*, const char*, int)) { WOLFSSL_STUB("CRYPTO_set_set_dynlock_lock_callback"); (void)f; } #endif #ifndef NO_WOLFSSL_STUB void wolfSSL_set_dynlock_destroy_callback( void (*f)(WOLFSSL_dynlock_value*, const char*, int)) { WOLFSSL_STUB("CRYPTO_set_set_dynlock_destroy_callback"); (void)f; } #endif const char* wolfSSL_X509_verify_cert_error_string(long err) { return wolfSSL_ERR_reason_error_string(err); } #ifndef NO_WOLFSSL_STUB int wolfSSL_X509_LOOKUP_add_dir(WOLFSSL_X509_LOOKUP* lookup, const char* dir, long len) { (void)lookup; (void)dir; (void)len; WOLFSSL_STUB("X509_LOOKUP_add_dir"); return 0; } #endif int wolfSSL_X509_LOOKUP_load_file(WOLFSSL_X509_LOOKUP* lookup, const char* file, long type) { #if !defined(NO_FILESYSTEM) && \ (defined(WOLFSSL_PEM_TO_DER) || defined(WOLFSSL_DER_TO_PEM)) int ret = WOLFSSL_FAILURE; XFILE fp; long sz; byte* pem = NULL; byte* curr = NULL; byte* prev = NULL; WOLFSSL_X509* x509; const char* header = NULL; const char* footer = NULL; if (type != X509_FILETYPE_PEM) return BAD_FUNC_ARG; fp = XFOPEN(file, "r"); if (fp == XBADFILE) return BAD_FUNC_ARG; if(XFSEEK(fp, 0, XSEEK_END) != 0) { XFCLOSE(fp); return WOLFSSL_BAD_FILE; } sz = XFTELL(fp); XREWIND(fp); if (sz > MAX_WOLFSSL_FILE_SIZE || sz <= 0) { WOLFSSL_MSG("X509_LOOKUP_load_file size error"); goto end; } pem = (byte*)XMALLOC(sz, 0, DYNAMIC_TYPE_PEM); if (pem == NULL) { ret = MEMORY_ERROR; goto end; } /* Read in file which may be CRLs or certificates. */ if (XFREAD(pem, (size_t)sz, 1, fp) != 1) goto end; prev = curr = pem; do { /* get PEM header and footer based on type */ if (wc_PemGetHeaderFooter(CRL_TYPE, &header, &footer) == 0 && XSTRNSTR((char*)curr, header, (unsigned int)sz) != NULL) { #ifdef HAVE_CRL WOLFSSL_CERT_MANAGER* cm = lookup->store->cm; if (cm->crl == NULL) { if (wolfSSL_CertManagerEnableCRL(cm, 0) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Enable CRL failed"); goto end; } } ret = BufferLoadCRL(cm->crl, curr, sz, WOLFSSL_FILETYPE_PEM, NO_VERIFY); if (ret != WOLFSSL_SUCCESS) goto end; #endif curr = (byte*)XSTRNSTR((char*)curr, footer, (unsigned int)sz); } else if (wc_PemGetHeaderFooter(CERT_TYPE, &header, &footer) == 0 && XSTRNSTR((char*)curr, header, (unsigned int)sz) != NULL) { x509 = wolfSSL_X509_load_certificate_buffer(curr, (int)sz, WOLFSSL_FILETYPE_PEM); if (x509 == NULL) goto end; ret = wolfSSL_X509_STORE_add_cert(lookup->store, x509); wolfSSL_X509_free(x509); if (ret != WOLFSSL_SUCCESS) goto end; curr = (byte*)XSTRNSTR((char*)curr, footer, (unsigned int)sz); } else goto end; if (curr == NULL) goto end; curr++; sz -= (long)(curr - prev); prev = curr; } while (ret == WOLFSSL_SUCCESS); end: if (pem != NULL) XFREE(pem, 0, DYNAMIC_TYPE_PEM); XFCLOSE(fp); return ret; #else (void)lookup; (void)file; (void)type; return WOLFSSL_FAILURE; #endif } WOLFSSL_X509_LOOKUP_METHOD* wolfSSL_X509_LOOKUP_hash_dir(void) { /* Method implementation in functions. */ static WOLFSSL_X509_LOOKUP_METHOD meth = { 1 }; return &meth; } WOLFSSL_X509_LOOKUP_METHOD* wolfSSL_X509_LOOKUP_file(void) { /* Method implementation in functions. */ static WOLFSSL_X509_LOOKUP_METHOD meth = { 0 }; return &meth; } WOLFSSL_X509_LOOKUP* wolfSSL_X509_STORE_add_lookup(WOLFSSL_X509_STORE* store, WOLFSSL_X509_LOOKUP_METHOD* m) { WOLFSSL_ENTER("SSL_X509_STORE_add_lookup"); if (store == NULL) return NULL; /* Method is a dummy value and is not needed. */ (void)m; /* Make sure the lookup has a back reference to the store. */ store->lookup.store = store; return &store->lookup; } #ifndef NO_CERTS /* Converts the X509 to DER format and outputs it into bio. * * bio is the structure to hold output DER * x509 certificate to create DER from * * returns WOLFSSL_SUCCESS on success */ int wolfSSL_i2d_X509_bio(WOLFSSL_BIO* bio, WOLFSSL_X509* x509) { WOLFSSL_ENTER("wolfSSL_i2d_X509_bio"); if (bio == NULL || x509 == NULL) { return WOLFSSL_FAILURE; } if (x509->derCert != NULL) { word32 len = x509->derCert->length; byte* der = x509->derCert->buffer; if (wolfSSL_BIO_write(bio, der, len) == (int)len) { return SSL_SUCCESS; } } return WOLFSSL_FAILURE; } /* Converts an internal structure to a DER buffer * * x509 structure to get DER buffer from * out buffer to hold result. If NULL then *out is NULL then a new buffer is * created. * * returns the size of the DER result on success */ int wolfSSL_i2d_X509(WOLFSSL_X509* x509, unsigned char** out) { const unsigned char* der; int derSz = 0; WOLFSSL_ENTER("wolfSSL_i2d_X509"); if (x509 == NULL) { WOLFSSL_LEAVE("wolfSSL_i2d_X509", BAD_FUNC_ARG); return BAD_FUNC_ARG; } der = wolfSSL_X509_get_der(x509, &derSz); if (der == NULL) { WOLFSSL_LEAVE("wolfSSL_i2d_X509", MEMORY_E); return MEMORY_E; } if (out != NULL && *out == NULL) { *out = (unsigned char*)XMALLOC(derSz, NULL, DYNAMIC_TYPE_OPENSSL); if (*out == NULL) { WOLFSSL_LEAVE("wolfSSL_i2d_X509", MEMORY_E); return MEMORY_E; } } if (out != NULL) XMEMCPY(*out, der, derSz); WOLFSSL_LEAVE("wolfSSL_i2d_X509", derSz); return derSz; } /* Converts the DER from bio and creates a WOLFSSL_X509 structure from it. * * bio is the structure holding DER * x509 certificate to create from DER. Can be NULL * * returns pointer to WOLFSSL_X509 structure on success and NULL on fail */ WOLFSSL_X509* wolfSSL_d2i_X509_bio(WOLFSSL_BIO* bio, WOLFSSL_X509** x509) { WOLFSSL_X509* localX509 = NULL; unsigned char* mem = NULL; int ret; word32 size; WOLFSSL_ENTER("wolfSSL_d2i_X509_bio"); if (bio == NULL) { WOLFSSL_MSG("Bad Function Argument bio is NULL"); return NULL; } ret = wolfSSL_BIO_get_mem_data(bio, &mem); if (mem == NULL || ret <= 0) { WOLFSSL_MSG("Failed to get data from bio struct"); return NULL; } size = ret; localX509 = wolfSSL_X509_d2i(NULL, mem, size); if (localX509 == NULL) { return NULL; } if (x509 != NULL) { *x509 = localX509; } return localX509; } #if !defined(NO_ASN) && !defined(NO_PWDBASED) WC_PKCS12* wolfSSL_d2i_PKCS12_bio(WOLFSSL_BIO* bio, WC_PKCS12** pkcs12) { WC_PKCS12* localPkcs12 = NULL; unsigned char* mem = NULL; int ret; word32 size; WOLFSSL_ENTER("wolfSSL_d2i_PKCS12_bio"); if (bio == NULL) { WOLFSSL_MSG("Bad Function Argument bio is NULL"); return NULL; } localPkcs12 = wc_PKCS12_new(); if (localPkcs12 == NULL) { WOLFSSL_MSG("Memory error"); return NULL; } if (pkcs12 != NULL) { *pkcs12 = localPkcs12; } ret = wolfSSL_BIO_get_mem_data(bio, &mem); if (mem == NULL || ret <= 0) { WOLFSSL_MSG("Failed to get data from bio struct"); wc_PKCS12_free(localPkcs12); if (pkcs12 != NULL) { *pkcs12 = NULL; } return NULL; } size = ret; ret = wc_d2i_PKCS12(mem, size, localPkcs12); if (ret < 0) { WOLFSSL_MSG("Failed to get PKCS12 sequence"); wc_PKCS12_free(localPkcs12); if (pkcs12 != NULL) { *pkcs12 = NULL; } return NULL; } return localPkcs12; } /* Converts the PKCS12 to DER format and outputs it into bio. * * bio is the structure to hold output DER * pkcs12 structure to create DER from * * return 1 for success or 0 if an error occurs */ int wolfSSL_i2d_PKCS12_bio(WOLFSSL_BIO *bio, WC_PKCS12 *pkcs12) { int ret = WOLFSSL_FAILURE; WOLFSSL_ENTER("wolfSSL_i2d_PKCS12_bio"); if ((bio != NULL) && (pkcs12 != NULL)) { word32 certSz = 0; byte *certDer = NULL; certSz = wc_i2d_PKCS12(pkcs12, &certDer, NULL); if ((certSz > 0) && (certDer != NULL)) { if (wolfSSL_BIO_write(bio, certDer, certSz) == (int)certSz) { ret = SSL_SUCCESS; } } if (certDer != NULL) { XFREE(certDer, NULL, DYNAMIC_TYPE_PKCS); } } return ret; } /* helper function to get raw pointer to DER buffer from WOLFSSL_EVP_PKEY */ static int wolfSSL_EVP_PKEY_get_der(WOLFSSL_EVP_PKEY* key, unsigned char** der) { if (!key) return WOLFSSL_FAILURE; if (der) *der = (unsigned char*)key->pkey.ptr; return key->pkey_sz; } /* Copies unencrypted DER key buffer into "der". If "der" is null then the size * of buffer needed is returned * NOTE: This also advances the "der" pointer to be at the end of buffer. * * Returns size of key buffer on success */ int wolfSSL_i2d_PrivateKey(WOLFSSL_EVP_PKEY* key, unsigned char** der) { if (key == NULL) { return WOLFSSL_FATAL_ERROR; } if (key->pkey_sz <= 0 || !key->pkey.ptr) { return WOLFSSL_FATAL_ERROR; } if (der != NULL) { /* since this function signature has no size value passed in it is * assumed that the user has allocated a large enough buffer */ XMEMCPY(*der, key->pkey.ptr, key->pkey_sz); *der += key->pkey_sz; } return key->pkey_sz; } /* Creates a new WC_PKCS12 structure * * pass password to use * name friendlyName to use * pkey private key to go into PKCS12 bundle * cert certificate to go into PKCS12 bundle * ca extra certificates that can be added to bundle. Can be NULL * keyNID type of encryption to use on the key (-1 means no encryption) * certNID type of encryption to use on the certificate * itt number of iterations with encryption * macItt number of iterations with mac creation * keyType flag for signature and/or encryption key * * returns a pointer to a new WC_PKCS12 structure on success and NULL on fail */ WC_PKCS12* wolfSSL_PKCS12_create(char* pass, char* name, WOLFSSL_EVP_PKEY* pkey, WOLFSSL_X509* cert, WOLF_STACK_OF(WOLFSSL_X509)* ca, int keyNID, int certNID, int itt, int macItt, int keyType) { WC_PKCS12* pkcs12; WC_DerCertList* list = NULL; word32 passSz; byte* keyDer; word32 keyDerSz; byte* certDer; int certDerSz; int ret; WOLFSSL_ENTER("wolfSSL_PKCS12_create()"); if (pass == NULL || pkey == NULL || cert == NULL) { WOLFSSL_LEAVE("wolfSSL_PKCS12_create()", BAD_FUNC_ARG); return NULL; } passSz = (word32)XSTRLEN(pass); if ((ret = wolfSSL_EVP_PKEY_get_der(pkey, &keyDer)) < 0) { WOLFSSL_LEAVE("wolfSSL_PKCS12_create", ret); return NULL; } keyDerSz = ret; certDer = (byte*)wolfSSL_X509_get_der(cert, &certDerSz); if (certDer == NULL) { return NULL; } if (ca != NULL) { WC_DerCertList* cur; unsigned long numCerts = ca->num; byte* curDer; int curDerSz = 0; WOLFSSL_STACK* sk = ca; while (numCerts > 0 && sk != NULL) { cur = (WC_DerCertList*)XMALLOC(sizeof(WC_DerCertList), NULL, DYNAMIC_TYPE_PKCS); if (cur == NULL) { wc_FreeCertList(list, NULL); return NULL; } curDer = (byte*)wolfSSL_X509_get_der(sk->data.x509, &curDerSz); if (curDer == NULL || curDerSz < 0) { XFREE(cur, NULL, DYNAMIC_TYPE_PKCS); wc_FreeCertList(list, NULL); return NULL; } cur->buffer = (byte*)XMALLOC(curDerSz, NULL, DYNAMIC_TYPE_PKCS); if (cur->buffer == NULL) { XFREE(cur, NULL, DYNAMIC_TYPE_PKCS); wc_FreeCertList(list, NULL); return NULL; } XMEMCPY(cur->buffer, curDer, curDerSz); cur->bufferSz = curDerSz; cur->next = list; list = cur; sk = sk->next; numCerts--; } } pkcs12 = wc_PKCS12_create(pass, passSz, name, keyDer, keyDerSz, certDer, certDerSz, list, keyNID, certNID, itt, macItt, keyType, NULL); if (ca != NULL) { wc_FreeCertList(list, NULL); } return pkcs12; } /* return WOLFSSL_SUCCESS on success, WOLFSSL_FAILURE on failure */ int wolfSSL_PKCS12_parse(WC_PKCS12* pkcs12, const char* psw, WOLFSSL_EVP_PKEY** pkey, WOLFSSL_X509** cert, WOLF_STACK_OF(WOLFSSL_X509)** ca) { DecodedCert DeCert; void* heap = NULL; int ret; byte* certData = NULL; word32 certDataSz; byte* pk = NULL; word32 pkSz; WC_DerCertList* certList = NULL; WOLFSSL_ENTER("wolfSSL_PKCS12_parse"); /* make sure we init return args */ if (pkey) *pkey = NULL; if (cert) *cert = NULL; if (ca) *ca = NULL; if (pkcs12 == NULL || psw == NULL || pkey == NULL || cert == NULL) { WOLFSSL_MSG("Bad argument value"); return WOLFSSL_FAILURE; } heap = wc_PKCS12_GetHeap(pkcs12); if (ca == NULL) { ret = wc_PKCS12_parse(pkcs12, psw, &pk, &pkSz, &certData, &certDataSz, NULL); } else { ret = wc_PKCS12_parse(pkcs12, psw, &pk, &pkSz, &certData, &certDataSz, &certList); } if (ret < 0) { WOLFSSL_LEAVE("wolfSSL_PKCS12_parse", ret); return WOLFSSL_FAILURE; } /* Decode cert and place in X509 stack struct */ if (certList != NULL) { WC_DerCertList* current = certList; *ca = (WOLF_STACK_OF(WOLFSSL_X509)*)XMALLOC(sizeof(WOLF_STACK_OF(WOLFSSL_X509)), heap, DYNAMIC_TYPE_X509); if (*ca == NULL) { if (pk != NULL) { XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY); } if (certData != NULL) { XFREE(*cert, heap, DYNAMIC_TYPE_PKCS); *cert = NULL; } /* Free up WC_DerCertList and move on */ while (current != NULL) { WC_DerCertList* next = current->next; XFREE(current->buffer, heap, DYNAMIC_TYPE_PKCS); XFREE(current, heap, DYNAMIC_TYPE_PKCS); current = next; } return WOLFSSL_FAILURE; } XMEMSET(*ca, 0, sizeof(WOLF_STACK_OF(WOLFSSL_X509))); /* add list of DER certs as X509's to stack */ while (current != NULL) { WC_DerCertList* toFree = current; WOLFSSL_X509* x509; x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), heap, DYNAMIC_TYPE_X509); InitX509(x509, 1, heap); InitDecodedCert(&DeCert, current->buffer, current->bufferSz, heap); if (ParseCertRelative(&DeCert, CERT_TYPE, NO_VERIFY, NULL) != 0) { WOLFSSL_MSG("Issue with parsing certificate"); FreeDecodedCert(&DeCert); wolfSSL_X509_free(x509); } else { if ((ret = CopyDecodedToX509(x509, &DeCert)) != 0) { WOLFSSL_MSG("Failed to copy decoded cert"); FreeDecodedCert(&DeCert); wolfSSL_X509_free(x509); wolfSSL_sk_X509_free(*ca); *ca = NULL; if (pk != NULL) { XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY); } if (certData != NULL) { XFREE(certData, heap, DYNAMIC_TYPE_PKCS); } /* Free up WC_DerCertList */ while (current != NULL) { WC_DerCertList* next = current->next; XFREE(current->buffer, heap, DYNAMIC_TYPE_PKCS); XFREE(current, heap, DYNAMIC_TYPE_PKCS); current = next; } return WOLFSSL_FAILURE; } FreeDecodedCert(&DeCert); if (wolfSSL_sk_X509_push(*ca, x509) != 1) { WOLFSSL_MSG("Failed to push x509 onto stack"); wolfSSL_X509_free(x509); wolfSSL_sk_X509_free(*ca); *ca = NULL; if (pk != NULL) { XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY); } if (certData != NULL) { XFREE(certData, heap, DYNAMIC_TYPE_PKCS); } /* Free up WC_DerCertList */ while (current != NULL) { WC_DerCertList* next = current->next; XFREE(current->buffer, heap, DYNAMIC_TYPE_PKCS); XFREE(current, heap, DYNAMIC_TYPE_PKCS); current = next; } return WOLFSSL_FAILURE; } } current = current->next; XFREE(toFree->buffer, heap, DYNAMIC_TYPE_PKCS); XFREE(toFree, heap, DYNAMIC_TYPE_PKCS); } } /* Decode cert and place in X509 struct */ if (certData != NULL) { *cert = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), heap, DYNAMIC_TYPE_X509); if (*cert == NULL) { if (pk != NULL) { XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY); } if (ca != NULL) { wolfSSL_sk_X509_free(*ca); *ca = NULL; } XFREE(certData, heap, DYNAMIC_TYPE_PKCS); return WOLFSSL_FAILURE; } InitX509(*cert, 1, heap); InitDecodedCert(&DeCert, certData, certDataSz, heap); if (ParseCertRelative(&DeCert, CERT_TYPE, NO_VERIFY, NULL) != 0) { WOLFSSL_MSG("Issue with parsing certificate"); } if ((ret = CopyDecodedToX509(*cert, &DeCert)) != 0) { WOLFSSL_MSG("Failed to copy decoded cert"); FreeDecodedCert(&DeCert); if (pk != NULL) { XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY); } if (ca != NULL) { wolfSSL_sk_X509_free(*ca); *ca = NULL; } wolfSSL_X509_free(*cert); *cert = NULL; return WOLFSSL_FAILURE; } FreeDecodedCert(&DeCert); XFREE(certData, heap, DYNAMIC_TYPE_PKCS); } /* get key type */ ret = BAD_STATE_E; if (pk != NULL) { /* decode key if present */ *pkey = wolfSSL_EVP_PKEY_new_ex(heap); if (*pkey == NULL) { wolfSSL_X509_free(*cert); *cert = NULL; if (ca != NULL) { wolfSSL_sk_X509_free(*ca); *ca = NULL; } XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY); return WOLFSSL_FAILURE; } #ifndef NO_RSA { word32 keyIdx = 0; RsaKey key; if (wc_InitRsaKey(&key, heap) != 0) { ret = BAD_STATE_E; } else { if ((ret = wc_RsaPrivateKeyDecode(pk, &keyIdx, &key, pkSz)) == 0) { (*pkey)->type = EVP_PKEY_RSA; (*pkey)->rsa = wolfSSL_RSA_new(); (*pkey)->ownRsa = 1; /* we own RSA */ if ((*pkey)->rsa == NULL) { WOLFSSL_MSG("issue creating EVP RSA key"); wolfSSL_X509_free(*cert); *cert = NULL; if (ca != NULL) { wolfSSL_sk_X509_free(*ca); *ca = NULL; } wolfSSL_EVP_PKEY_free(*pkey); *pkey = NULL; XFREE(pk, heap, DYNAMIC_TYPE_PKCS); return WOLFSSL_FAILURE; } if ((ret = wolfSSL_RSA_LoadDer_ex((*pkey)->rsa, pk, pkSz, WOLFSSL_RSA_LOAD_PRIVATE)) != SSL_SUCCESS) { WOLFSSL_MSG("issue loading RSA key"); wolfSSL_X509_free(*cert); *cert = NULL; if (ca != NULL) { wolfSSL_sk_X509_free(*ca); *ca = NULL; } wolfSSL_EVP_PKEY_free(*pkey); *pkey = NULL; XFREE(pk, heap, DYNAMIC_TYPE_PKCS); return WOLFSSL_FAILURE; } WOLFSSL_MSG("Found PKCS12 RSA key"); ret = 0; /* set in success state for upcoming ECC check */ } wc_FreeRsaKey(&key); } } #endif /* NO_RSA */ #ifdef HAVE_ECC { word32 keyIdx = 0; ecc_key key; if (ret != 0) { /* if is in fail state check if ECC key */ if (wc_ecc_init(&key) != 0) { wolfSSL_X509_free(*cert); *cert = NULL; if (ca != NULL) { wolfSSL_sk_X509_free(*ca); *ca = NULL; } wolfSSL_EVP_PKEY_free(*pkey); *pkey = NULL; XFREE(pk, heap, DYNAMIC_TYPE_PKCS); return WOLFSSL_FAILURE; } if ((ret = wc_EccPrivateKeyDecode(pk, &keyIdx, &key, pkSz)) != 0) { wolfSSL_X509_free(*cert); *cert = NULL; if (ca != NULL) { wolfSSL_sk_X509_free(*ca); *ca = NULL; } wolfSSL_EVP_PKEY_free(*pkey); *pkey = NULL; XFREE(pk, heap, DYNAMIC_TYPE_PKCS); WOLFSSL_MSG("Bad PKCS12 key format"); return WOLFSSL_FAILURE; } (*pkey)->type = EVP_PKEY_EC; (*pkey)->pkey_curve = key.dp->oidSum; wc_ecc_free(&key); WOLFSSL_MSG("Found PKCS12 ECC key"); } } #else if (ret != 0) { /* if is in fail state and no ECC then fail */ wolfSSL_X509_free(*cert); *cert = NULL; if (ca != NULL) { wolfSSL_sk_X509_free(*ca); *ca = NULL; } wolfSSL_EVP_PKEY_free(*pkey); *pkey = NULL; XFREE(pk, heap, DYNAMIC_TYPE_PKCS); WOLFSSL_MSG("Bad PKCS12 key format"); return WOLFSSL_FAILURE; } #endif /* HAVE_ECC */ (*pkey)->save_type = 0; (*pkey)->pkey_sz = pkSz; (*pkey)->pkey.ptr = (char*)pk; } (void)ret; (void)ca; return WOLFSSL_SUCCESS; } #endif /* !defined(NO_ASN) && !defined(NO_PWDBASED) */ /* no-op function. Was initially used for adding encryption algorithms available * for PKCS12 */ void wolfSSL_PKCS12_PBE_add(void) { WOLFSSL_ENTER("wolfSSL_PKCS12_PBE_add"); } WOLFSSL_STACK* wolfSSL_X509_STORE_CTX_get_chain(WOLFSSL_X509_STORE_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_get_chain"); if (ctx == NULL) { return NULL; } #ifdef SESSION_CERTS /* if chain is null but sesChain is available then populate stack */ if (ctx->chain == NULL && ctx->sesChain != NULL) { int i; WOLFSSL_X509_CHAIN* c = ctx->sesChain; WOLFSSL_STACK* sk = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_X509); if (sk == NULL) { return NULL; } XMEMSET(sk, 0, sizeof(WOLFSSL_STACK)); ctx->chain = sk; for (i = 0; i < c->count && i < MAX_CHAIN_DEPTH; i++) { WOLFSSL_X509* x509 = wolfSSL_get_chain_X509(c, i); if (x509 == NULL) { WOLFSSL_MSG("Unable to get x509 from chain"); wolfSSL_sk_X509_free(sk); return NULL; } if (wolfSSL_sk_X509_push(sk, x509) != SSL_SUCCESS) { WOLFSSL_MSG("Unable to load x509 into stack"); wolfSSL_sk_X509_free(sk); wolfSSL_X509_free(x509); return NULL; } } #if defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) || defined(OPENSSL_EXTRA) /* add CA used to verify top of chain to the list */ if (c->count > 0) { WOLFSSL_X509* x509 = wolfSSL_get_chain_X509(c, c->count - 1); if (x509 != NULL) { WOLFSSL_X509* issuer = NULL; if (wolfSSL_X509_STORE_CTX_get1_issuer(&issuer, ctx, x509) == WOLFSSL_SUCCESS) { /* check that the certificate being looked up is not self * signed and that a issuer was found */ if (issuer != NULL && wolfSSL_X509_NAME_cmp(&x509->issuer, &x509->subject) != 0) { if (wolfSSL_sk_X509_push(sk, issuer) != SSL_SUCCESS) { WOLFSSL_MSG("Unable to load CA x509 into stack"); wolfSSL_sk_X509_free(sk); wolfSSL_X509_free(issuer); return NULL; } } else { WOLFSSL_MSG("Certificate is self signed"); if (issuer != NULL) wolfSSL_X509_free(issuer); } } else { WOLFSSL_MSG("Could not find CA for certificate"); } } } #endif } #endif /* SESSION_CERTS */ return ctx->chain; } /* make shallow copy of the stack, data pointers are copied by reference */ WOLFSSL_STACK* wolfSSL_sk_X509_dup(WOLFSSL_STACK* sk) { unsigned long i; WOLFSSL_STACK* dup = NULL; WOLFSSL_STACK* node = NULL; WOLFSSL_STACK *dIdx = NULL, *sIdx = sk; if (sk == NULL) { return NULL; } for (i = 0; i < sk->num; i++) { node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_X509); if (node == NULL) { if (i != 0) { wolfSSL_sk_free(dup); } WOLFSSL_MSG("Memory error"); return NULL; } XMEMSET(node, 0, sizeof(WOLFSSL_STACK)); /* copy sk node to new node, data by reference */ node->data.x509 = sIdx->data.x509; node->num = sIdx->num; /* insert node into list, progress idx */ if (i == 0) { dup = node; } else { dIdx->next = node; } dIdx = node; sIdx = sIdx->next; } return dup; } /* like X509_STORE_CTX_get_chain(), but return a copy with data reference counts increased */ WOLFSSL_STACK* wolfSSL_X509_STORE_CTX_get1_chain(WOLFSSL_X509_STORE_CTX* ctx) { unsigned long i; WOLFSSL_STACK* ref; WOLFSSL_STACK* dup; if (ctx == NULL) { return NULL; } /* get chain in ctx */ ref = wolfSSL_X509_STORE_CTX_get_chain(ctx); if (ref == NULL) { return ref; } /* create duplicate of ctx chain */ dup = wolfSSL_sk_X509_dup(ref); if (dup == NULL) { return NULL; } /* increase ref counts of inner data X509 */ ref = dup; for (i = 0; i < dup->num && ref != NULL; i++) { if (wc_LockMutex(&ref->data.x509->refMutex) != 0) { WOLFSSL_MSG("Failed to lock x509 mutex"); } ref->data.x509->refCount++; wc_UnLockMutex(&ref->data.x509->refMutex); ref = ref->next; } return dup; } int wolfSSL_X509_STORE_add_cert(WOLFSSL_X509_STORE* store, WOLFSSL_X509* x509) { int result = WOLFSSL_FATAL_ERROR; WOLFSSL_ENTER("wolfSSL_X509_STORE_add_cert"); if (store != NULL && store->cm != NULL && x509 != NULL && x509->derCert != NULL) { DerBuffer* derCert = NULL; result = AllocDer(&derCert, x509->derCert->length, x509->derCert->type, NULL); if (result == 0) { /* AddCA() frees the buffer. */ XMEMCPY(derCert->buffer, x509->derCert->buffer, x509->derCert->length); result = AddCA(store->cm, &derCert, WOLFSSL_USER_CA, VERIFY); } } WOLFSSL_LEAVE("wolfSSL_X509_STORE_add_cert", result); if (result != WOLFSSL_SUCCESS) { result = WOLFSSL_FATAL_ERROR; } return result; } WOLFSSL_X509_STORE* wolfSSL_X509_STORE_new(void) { WOLFSSL_X509_STORE* store = NULL; WOLFSSL_ENTER("SSL_X509_STORE_new"); if ((store = (WOLFSSL_X509_STORE*)XMALLOC(sizeof(WOLFSSL_X509_STORE), NULL, DYNAMIC_TYPE_X509_STORE)) == NULL) goto err_exit; XMEMSET(store, 0, sizeof(WOLFSSL_X509_STORE)); store->isDynamic = 1; if ((store->cm = wolfSSL_CertManagerNew()) == NULL) goto err_exit; #ifdef HAVE_CRL store->crl = NULL; if ((store->crl = (WOLFSSL_X509_CRL *)XMALLOC(sizeof(WOLFSSL_X509_CRL), NULL, DYNAMIC_TYPE_TMP_BUFFER)) == NULL) goto err_exit; if (InitCRL(store->crl, NULL) < 0) goto err_exit; #endif #ifdef OPENSSL_EXTRA if ((store->param = (WOLFSSL_X509_VERIFY_PARAM*)XMALLOC( sizeof(WOLFSSL_X509_VERIFY_PARAM), NULL,DYNAMIC_TYPE_OPENSSL)) == NULL) goto err_exit; #endif return store; err_exit: if (store == NULL) return NULL; wolfSSL_X509_STORE_free(store); return NULL; } void wolfSSL_X509_STORE_free(WOLFSSL_X509_STORE* store) { if (store != NULL && store->isDynamic) { if (store->cm != NULL) wolfSSL_CertManagerFree(store->cm); #ifdef HAVE_CRL if (store->crl != NULL) wolfSSL_X509_CRL_free(store->crl); #endif #ifdef OPENSSL_EXTRA if (store->param != NULL) XFREE(store->param, NULL, DYNAMIC_TYPE_OPENSSL); #endif XFREE(store, NULL, DYNAMIC_TYPE_X509_STORE); } } int wolfSSL_X509_STORE_set_flags(WOLFSSL_X509_STORE* store, unsigned long flag) { int ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_X509_STORE_set_flags"); if (store == NULL) return WOLFSSL_FAILURE; if ((flag & WOLFSSL_CRL_CHECKALL) || (flag & WOLFSSL_CRL_CHECK)) { ret = wolfSSL_CertManagerEnableCRL(store->cm, (int)flag); } (void)store; (void)flag; return ret; } int wolfSSL_X509_STORE_set_default_paths(WOLFSSL_X509_STORE* store) { (void)store; return WOLFSSL_SUCCESS; } #ifndef NO_WOLFSSL_STUB int wolfSSL_X509_STORE_get_by_subject(WOLFSSL_X509_STORE_CTX* ctx, int idx, WOLFSSL_X509_NAME* name, WOLFSSL_X509_OBJECT* obj) { (void)ctx; (void)idx; (void)name; (void)obj; WOLFSSL_STUB("X509_STORE_get_by_subject"); return 0; } #endif WOLFSSL_X509_STORE_CTX* wolfSSL_X509_STORE_CTX_new(void) { WOLFSSL_X509_STORE_CTX* ctx; WOLFSSL_ENTER("X509_STORE_CTX_new"); ctx = (WOLFSSL_X509_STORE_CTX*)XMALLOC(sizeof(WOLFSSL_X509_STORE_CTX), NULL, DYNAMIC_TYPE_X509_CTX); if (ctx != NULL) { ctx->param = NULL; wolfSSL_X509_STORE_CTX_init(ctx, NULL, NULL, NULL); } return ctx; } int wolfSSL_X509_STORE_CTX_init(WOLFSSL_X509_STORE_CTX* ctx, WOLFSSL_X509_STORE* store, WOLFSSL_X509* x509, WOLF_STACK_OF(WOLFSSL_X509)* sk) { WOLFSSL_X509* x509_cert; int ret = 0; (void)sk; WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_init"); if (ctx != NULL) { ctx->store = store; #ifndef WOLFSSL_X509_STORE_CERTS ctx->current_cert = x509; #else if(x509 != NULL){ ctx->current_cert = wolfSSL_X509_d2i(NULL, x509->derCert->buffer,x509->derCert->length); if(ctx->current_cert == NULL) return WOLFSSL_FATAL_ERROR; } else ctx->current_cert = NULL; #endif ctx->chain = sk; /* Add intermediate certificates from stack to store */ while (sk != NULL) { x509_cert = sk->data.x509; if (x509_cert != NULL && x509_cert->isCa) { ret = wolfSSL_X509_STORE_add_cert(store, x509_cert); if (ret < 0) { return WOLFSSL_FATAL_ERROR; } } sk = sk->next; } ctx->sesChain = NULL; ctx->domain = NULL; #if defined(HAVE_EX_DATA) || defined(FORTRESS) XMEMSET(&ctx->ex_data, 0, sizeof(ctx->ex_data)); #endif ctx->userCtx = NULL; ctx->error = 0; ctx->error_depth = 0; ctx->discardSessionCerts = 0; #ifdef OPENSSL_EXTRA if (ctx->param == NULL) { ctx->param = (WOLFSSL_X509_VERIFY_PARAM*)XMALLOC( sizeof(WOLFSSL_X509_VERIFY_PARAM), NULL,DYNAMIC_TYPE_OPENSSL); if (ctx->param == NULL){ WOLFSSL_MSG("wolfSSL_X509_STORE_CTX_init failed"); return SSL_FATAL_ERROR; } } #endif return SSL_SUCCESS; } return WOLFSSL_FATAL_ERROR; } void wolfSSL_X509_STORE_CTX_free(WOLFSSL_X509_STORE_CTX* ctx) { WOLFSSL_ENTER("X509_STORE_CTX_free"); if (ctx != NULL) { #if !defined(OPENSSL_ALL) && !defined(WOLFSSL_QT) if (ctx->store != NULL) wolfSSL_X509_STORE_free(ctx->store); #ifndef WOLFSSL_KEEP_STORE_CERTS if (ctx->current_cert != NULL) wolfSSL_FreeX509(ctx->current_cert); #endif #endif /* !OPENSSL_ALL && !WOLFSSL_QT */ #ifdef OPENSSL_EXTRA if (ctx->param != NULL){ XFREE(ctx->param,NULL,DYNAMIC_TYPE_OPENSSL); } #endif XFREE(ctx, NULL, DYNAMIC_TYPE_X509_CTX); } } void wolfSSL_X509_STORE_CTX_cleanup(WOLFSSL_X509_STORE_CTX* ctx) { (void)ctx; /* Do nothing */ } #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) /* Returns corresponding X509 error from internal ASN error */ static int GetX509Error(int e) { switch (e) { case ASN_BEFORE_DATE_E: return X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD; case ASN_AFTER_DATE_E: return X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD; case ASN_NO_SIGNER_E: return X509_V_ERR_INVALID_CA; case ASN_SELF_SIGNED_E: return X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT; case ASN_PATHLEN_INV_E: case ASN_PATHLEN_SIZE_E: return X509_V_ERR_PATH_LENGTH_EXCEEDED; case ASN_SIG_OID_E: case ASN_SIG_CONFIRM_E: case ASN_SIG_HASH_E: case ASN_SIG_KEY_E: return X509_V_ERR_CERT_SIGNATURE_FAILURE; default: WOLFSSL_MSG("Error not configured or implemented yet"); return e; } } #endif /* Verifies certificate chain using WOLFSSL_X509_STORE_CTX * returns 0 on success or < 0 on failure. */ int wolfSSL_X509_verify_cert(WOLFSSL_X509_STORE_CTX* ctx) { int ret = 0; #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) int depth = 0; int error; byte *afterDate, *beforeDate; #endif WOLFSSL_ENTER("wolfSSL_X509_verify_cert"); if (ctx != NULL && ctx->store != NULL && ctx->store->cm != NULL && ctx->current_cert != NULL && ctx->current_cert->derCert != NULL) { ret = wolfSSL_CertManagerVerifyBuffer(ctx->store->cm, ctx->current_cert->derCert->buffer, ctx->current_cert->derCert->length, WOLFSSL_FILETYPE_ASN1); #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) /* If there was an error, process it and add it to CTX */ if (ret < 0) { /* Get corresponding X509 error */ error = GetX509Error(ret); /* Set error depth */ if (ctx->chain) depth = (int)ctx->chain->num; wolfSSL_X509_STORE_CTX_set_error(ctx, error); wolfSSL_X509_STORE_CTX_set_error_depth(ctx, depth); ctx->store->verify_cb(0, ctx); } error = 0; /* wolfSSL_CertManagerVerifyBuffer only returns ASN_AFTER_DATE_E or ASN_BEFORE_DATE_E if there are no additional errors found in the cert. Therefore, check if the cert is expired or not yet valid in order to return the correct expected error. */ afterDate = ctx->current_cert->notAfter.data; beforeDate = ctx->current_cert->notBefore.data; if (ValidateDate(afterDate, ctx->current_cert->notAfter.type, AFTER) < 1) { error = X509_V_ERR_CERT_HAS_EXPIRED; } else if (ValidateDate(beforeDate, ctx->current_cert->notBefore.type, BEFORE) < 1) { error = X509_V_ERR_CERT_NOT_YET_VALID; } if (error != 0 ) { wolfSSL_X509_STORE_CTX_set_error(ctx, error); wolfSSL_X509_STORE_CTX_set_error_depth(ctx, depth); if (ctx->store && ctx->store->verify_cb) ctx->store->verify_cb(0, ctx); } #endif /* OPENSSL_ALL || WOLFSSL_QT */ return ret; } return WOLFSSL_FATAL_ERROR; } /* Use the public key to verify the signature. Note: this only verifies * the certificate signature. * returns WOLFSSL_SUCCESS on successful signature verification */ int wolfSSL_X509_verify(WOLFSSL_X509* x509, WOLFSSL_EVP_PKEY* pkey) { int ret; const byte* der; int derSz = 0; int type; if (x509 == NULL || pkey == NULL) { return WOLFSSL_FATAL_ERROR; } der = wolfSSL_X509_get_der(x509, &derSz); if (der == NULL) { WOLFSSL_MSG("Error getting WOLFSSL_X509 DER"); return WOLFSSL_FATAL_ERROR; } switch (pkey->type) { case EVP_PKEY_RSA: type = RSAk; break; case EVP_PKEY_EC: type = ECDSAk; break; case EVP_PKEY_DSA: type = DSAk; break; default: WOLFSSL_MSG("Unknown pkey key type"); return WOLFSSL_FATAL_ERROR; } ret = CheckCertSignaturePubKey(der, derSz, x509->heap, (unsigned char*)pkey->pkey.ptr, pkey->pkey_sz, type); if (ret == 0) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } #endif /* NO_CERTS */ #if !defined(NO_FILESYSTEM) static void *wolfSSL_d2i_X509_fp_ex(XFILE file, void **x509, int type) { void *newx509 = NULL; byte *fileBuffer = NULL; long sz = 0; /* init variable */ if (x509) *x509 = NULL; /* argument check */ if (file == XBADFILE) { return NULL; } /* determine file size */ if (XFSEEK(file, 0, XSEEK_END) != 0) { return NULL; } sz = XFTELL(file); XREWIND(file); if (sz > MAX_WOLFSSL_FILE_SIZE || sz <= 0) { WOLFSSL_MSG("d2i_X509_fp_ex file size error"); return NULL; } fileBuffer = (byte *)XMALLOC(sz, NULL, DYNAMIC_TYPE_FILE); if (fileBuffer != NULL) { if ((long)XFREAD(fileBuffer, 1, sz, file) != sz) { WOLFSSL_MSG("File read failed"); goto err_exit; } if (type == CERT_TYPE) { newx509 = (void *)wolfSSL_X509_d2i(NULL, fileBuffer, (int)sz); } #ifdef HAVE_CRL else if (type == CRL_TYPE) { newx509 = (void *)wolfSSL_d2i_X509_CRL(NULL, fileBuffer, (int)sz); } #endif #if !defined(NO_ASN) && !defined(NO_PWDBASED) else if (type == PKCS12_TYPE) { if ((newx509 = wc_PKCS12_new()) == NULL) { goto err_exit; } if (wc_d2i_PKCS12(fileBuffer, (int)sz, (WC_PKCS12*)newx509) < 0) { goto err_exit; } } #endif else { goto err_exit; } if (newx509 == NULL) { WOLFSSL_MSG("X509 failed"); goto err_exit; } } if (x509) *x509 = newx509; goto _exit; err_exit: #if !defined(NO_ASN) && !defined(NO_PWDBASED) if ((newx509 != NULL) && (type == PKCS12_TYPE)) { wc_PKCS12_free((WC_PKCS12*)newx509); newx509 = NULL; } #endif _exit: if (fileBuffer != NULL) XFREE(fileBuffer, NULL, DYNAMIC_TYPE_FILE); return newx509; } WOLFSSL_X509_PKCS12 *wolfSSL_d2i_PKCS12_fp(XFILE fp, WOLFSSL_X509_PKCS12 **pkcs12) { WOLFSSL_ENTER("wolfSSL_d2i_PKCS12_fp"); return (WOLFSSL_X509_PKCS12 *)wolfSSL_d2i_X509_fp_ex(fp, (void **)pkcs12, PKCS12_TYPE); } WOLFSSL_X509 *wolfSSL_d2i_X509_fp(XFILE fp, WOLFSSL_X509 **x509) { WOLFSSL_ENTER("wolfSSL_d2i_X509_fp"); return (WOLFSSL_X509 *)wolfSSL_d2i_X509_fp_ex(fp, (void **)x509, CERT_TYPE); } #endif /* !NO_FILESYSTEM */ #ifdef HAVE_CRL #ifndef NO_FILESYSTEM WOLFSSL_X509_CRL *wolfSSL_d2i_X509_CRL_fp(XFILE fp, WOLFSSL_X509_CRL **crl) { WOLFSSL_ENTER("wolfSSL_d2i_X509_CRL_fp"); return (WOLFSSL_X509_CRL *)wolfSSL_d2i_X509_fp_ex(fp, (void **)crl, CRL_TYPE); } #endif /* !NO_FILESYSTEM */ WOLFSSL_X509_CRL* wolfSSL_d2i_X509_CRL(WOLFSSL_X509_CRL** crl, const unsigned char* in, int len) { WOLFSSL_X509_CRL *newcrl = NULL; int ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_d2i_X509_CRL"); if (in == NULL) { WOLFSSL_MSG("Bad argument value"); } else { newcrl = (WOLFSSL_X509_CRL*)XMALLOC(sizeof(WOLFSSL_X509_CRL), NULL, DYNAMIC_TYPE_TMP_BUFFER); if (newcrl == NULL){ WOLFSSL_MSG("New CRL allocation failed"); } else { ret = InitCRL(newcrl, NULL); if (ret < 0) { WOLFSSL_MSG("Init tmp CRL failed"); } else { ret = BufferLoadCRL(newcrl, in, len, WOLFSSL_FILETYPE_ASN1, NO_VERIFY); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Buffer Load CRL failed"); } else { if (crl) { *crl = newcrl; } } } } } if((ret != WOLFSSL_SUCCESS) && (newcrl != NULL)) { wolfSSL_X509_CRL_free(newcrl); newcrl = NULL; } return newcrl; } void wolfSSL_X509_CRL_free(WOLFSSL_X509_CRL *crl) { WOLFSSL_ENTER("wolfSSL_X509_CRL_free"); FreeCRL(crl, 1); return; } #endif /* HAVE_CRL */ #ifndef NO_WOLFSSL_STUB WOLFSSL_ASN1_TIME* wolfSSL_X509_CRL_get_lastUpdate(WOLFSSL_X509_CRL* crl) { (void)crl; WOLFSSL_STUB("X509_CRL_get_lastUpdate"); return 0; } #endif #ifndef NO_WOLFSSL_STUB WOLFSSL_ASN1_TIME* wolfSSL_X509_CRL_get_nextUpdate(WOLFSSL_X509_CRL* crl) { (void)crl; WOLFSSL_STUB("X509_CRL_get_nextUpdate"); return 0; } #endif #ifndef NO_WOLFSSL_STUB int wolfSSL_X509_CRL_verify(WOLFSSL_X509_CRL* crl, WOLFSSL_EVP_PKEY* key) { (void)crl; (void)key; WOLFSSL_STUB("X509_CRL_verify"); return 0; } #endif #endif /* OPENSSL_EXTRA */ #ifdef OPENSSL_EXTRA /* Gets pointer to X509_STORE that was used to create context. * * Return valid pointer on success, NULL if ctx was NULL or not initialized */ WOLFSSL_X509_STORE* wolfSSL_X509_STORE_CTX_get0_store( WOLFSSL_X509_STORE_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_get0_store"); if (ctx == NULL) return NULL; return ctx->store; } WOLFSSL_X509* wolfSSL_X509_STORE_CTX_get0_cert(WOLFSSL_X509_STORE_CTX* ctx) { if (ctx == NULL) return NULL; return ctx->current_cert; } void wolfSSL_X509_STORE_CTX_set_time(WOLFSSL_X509_STORE_CTX* ctx, unsigned long flags, time_t t) { (void)flags; if (ctx == NULL || ctx->param == NULL) return; ctx->param->check_time = t; ctx->param->flags |= WOLFSSL_USE_CHECK_TIME; } #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) #ifndef NO_WOLFSSL_STUB int wolfSSL_X509_STORE_CTX_set_purpose(WOLFSSL_X509_STORE_CTX *ctx, int purpose) { (void)ctx; (void)purpose; WOLFSSL_STUB("wolfSSL_X509_STORE_CTX_set_purpose"); return 0; } #endif #endif /* WOLFSSL_QT || OPENSSL_ALL */ #ifndef NO_WOLFSSL_STUB /* Returns default file name and path of config file. However a wolfssl.cnf file is not currently supported */ char* wolfSSL_CONF_get1_default_config_file(void) { WOLFSSL_ENTER("wolfSSL_CONF_get1_default_config_file"); WOLFSSL_STUB("CONF_get1_default_config_file"); return NULL; } #endif /****************************************************************************** * wolfSSL_X509_VERIFY_PARAM_set1_host - sets the DNS hostname to name * hostnames is cleared if name is NULL or empty. * * RETURNS: * */ int wolfSSL_X509_VERIFY_PARAM_set1_host(WOLFSSL_X509_VERIFY_PARAM* pParam, const char* name, unsigned int nameSz) { unsigned int sz = 0; if (pParam == NULL) return WOLFSSL_FAILURE; XMEMSET(pParam->hostName, 0, WOLFSSL_HOST_NAME_MAX); if (name == NULL) return WOLFSSL_SUCCESS; sz = (unsigned int)XSTRLEN(name); /* If name is NUL-terminated, namelen can be set to zero. */ if(nameSz == 0 || nameSz > sz) nameSz = sz; if (nameSz > 0 && name[nameSz - 1] == '\0') nameSz--; if (nameSz > WOLFSSL_HOST_NAME_MAX-1) nameSz = WOLFSSL_HOST_NAME_MAX-1; if (nameSz > 0) XMEMCPY(pParam->hostName, name, nameSz); pParam->hostName[nameSz] = '\0'; return WOLFSSL_SUCCESS; } /****************************************************************************** * wolfSSL_get0_param - return a pointer to the SSL verification parameters * * RETURNS: * returns pointer to the SSL verification parameters on success, * otherwise returns NULL */ WOLFSSL_X509_VERIFY_PARAM* wolfSSL_get0_param(WOLFSSL* ssl) { if (ssl == NULL) { return NULL; } return ssl->param; } /* Set the host flag in the X509_VERIFY_PARAM structure */ void wolfSSL_X509_VERIFY_PARAM_set_hostflags(WOLFSSL_X509_VERIFY_PARAM* param, unsigned int flags) { if (param != NULL) { param->hostFlags = flags; } } /* Sets the expected IP address to ipasc. * * param is a pointer to the X509_VERIFY_PARAM structure * ipasc is a NULL-terminated string with N.N.N.N for IPv4 and * HH:HH ... HH:HH for IPv6. There is no validation performed on the * parameter, and it must be an exact match with the IP in the cert. * * return 1 for success and 0 for failure*/ int wolfSSL_X509_VERIFY_PARAM_set1_ip_asc(WOLFSSL_X509_VERIFY_PARAM *param, const char *ipasc) { int ret = WOLFSSL_FAILURE; if (param != NULL) { if (ipasc == NULL) { param->ipasc[0] = '\0'; } else { XSTRNCPY(param->ipasc, ipasc, WOLFSSL_MAX_IPSTR-1); param->ipasc[WOLFSSL_MAX_IPSTR-1] = '\0'; } ret = WOLFSSL_SUCCESS; } return ret; } #ifndef NO_WOLFSSL_STUB void wolfSSL_X509_OBJECT_free_contents(WOLFSSL_X509_OBJECT* obj) { (void)obj; WOLFSSL_STUB("X509_OBJECT_free_contents"); } #endif #ifndef NO_ASN_TIME int wolfSSL_X509_cmp_current_time(const WOLFSSL_ASN1_TIME* asnTime) { return wolfSSL_X509_cmp_time(asnTime, NULL); } /* return -1 if asnTime is earlier than or equal to cmpTime, and 1 otherwise * return 0 on error */ int wolfSSL_X509_cmp_time(const WOLFSSL_ASN1_TIME* asnTime, time_t* cmpTime) { int ret = WOLFSSL_FAILURE, i = 0; time_t tmpTime, *pTime = &tmpTime; byte data_ptr[MAX_TIME_STRING_SZ], inv = 0; struct tm ts, *tmpTs, *ct; #if defined(NEED_TMP_TIME) /* for use with gmtime_r */ struct tm tmpTimeStorage; tmpTs = &tmpTimeStorage; #else tmpTs = NULL; #endif (void)tmpTs; if (asnTime == NULL) { return WOLFSSL_FAILURE; } if (cmpTime == NULL) { /* Use current time */ *pTime = XTIME(0); } else { pTime = cmpTime; } /* Convert ASN1_time to time_t */ XMEMSET(&ts, 0, sizeof(struct tm)); /* Check type */ if (asnTime->type == ASN_UTC_TIME) { /* 2-digit year */ XMEMCPY(data_ptr, &asnTime->data[i], ASN_UTC_TIME_SIZE); ts.tm_year = (data_ptr[i] - '0') * 10; i++; ts.tm_year += data_ptr[i] - '0'; i++; if (ts.tm_year < 70) { ts.tm_year += 100; } } else if (asnTime->type == ASN_GENERALIZED_TIME) { /* 4-digit year */ XMEMCPY(data_ptr, &asnTime->data[i], ASN_GENERALIZED_TIME_SIZE); ts.tm_year = (data_ptr[i] - '0') * 1000; i++; ts.tm_year += (data_ptr[i] - '0') * 100; i++; ts.tm_year += (data_ptr[i] - '0') * 10; i++; ts.tm_year += data_ptr[i] - '0'; i++; ts.tm_year -= 1900; } else { /* Invalid type */ inv = 1; } if (inv != 1) { ts.tm_mon = (data_ptr[i] - '0') * 10; i++; ts.tm_mon += (data_ptr[i] - '0') - 1; i++; /* January is 0 not 1 */ ts.tm_mday = (data_ptr[i] - '0') * 10; i++; ts.tm_mday += (data_ptr[i] - '0'); i++; ts.tm_hour = (data_ptr[i] - '0') * 10; i++; ts.tm_hour += (data_ptr[i] - '0'); i++; ts.tm_min = (data_ptr[i] - '0') * 10; i++; ts.tm_min += (data_ptr[i] - '0'); i++; ts.tm_sec = (data_ptr[i] - '0') * 10; i++; ts.tm_sec += (data_ptr[i] - '0'); /* Convert to time struct*/ ct = XGMTIME(pTime, tmpTs); if (ct == NULL) return GETTIME_ERROR; /* DateGreaterThan returns 1 for >; 0 for <= */ ret = DateGreaterThan(&ts, ct) ? 1 : -1; } return ret; } #endif /* !NO_ASN_TIME */ #if defined(OPENSSL_EXTRA) && !defined(NO_ASN_TIME) && !defined(USER_TIME) && \ !defined(TIME_OVERRIDES) WOLFSSL_ASN1_TIME *wolfSSL_X509_time_adj_ex(WOLFSSL_ASN1_TIME *asnTime, int offset_day, long offset_sec, time_t *in_tm) { /* get current time if in_tm is null */ time_t t = in_tm ? *in_tm : XTIME(0); return wolfSSL_ASN1_TIME_adj(asnTime, t, offset_day, offset_sec); } WOLFSSL_ASN1_TIME *wolfSSL_X509_time_adj(WOLFSSL_ASN1_TIME *asnTime, long offset_sec, time_t *in_tm) { return wolfSSL_X509_time_adj_ex(asnTime, 0, offset_sec, in_tm); } #endif #ifndef NO_WOLFSSL_STUB int wolfSSL_sk_X509_REVOKED_num(WOLFSSL_X509_REVOKED* revoked) { (void)revoked; WOLFSSL_STUB("sk_X509_REVOKED_num"); return 0; } #endif #ifndef NO_WOLFSSL_STUB WOLFSSL_X509_REVOKED* wolfSSL_X509_CRL_get_REVOKED(WOLFSSL_X509_CRL* crl) { (void)crl; WOLFSSL_STUB("X509_CRL_get_REVOKED"); return 0; } #endif #ifndef NO_WOLFSSL_STUB WOLFSSL_X509_REVOKED* wolfSSL_sk_X509_REVOKED_value( WOLFSSL_X509_REVOKED* revoked, int value) { (void)revoked; (void)value; WOLFSSL_STUB("sk_X509_REVOKED_value"); return 0; } #endif /* Used to create a new WOLFSSL_ASN1_INTEGER structure. * returns a pointer to new structure on success and NULL on failure */ WOLFSSL_ASN1_INTEGER* wolfSSL_ASN1_INTEGER_new(void) { WOLFSSL_ASN1_INTEGER* a; a = (WOLFSSL_ASN1_INTEGER*)XMALLOC(sizeof(WOLFSSL_ASN1_INTEGER), NULL, DYNAMIC_TYPE_OPENSSL); if (a == NULL) { return NULL; } XMEMSET(a, 0, sizeof(WOLFSSL_ASN1_INTEGER)); a->data = a->intData; a->dataMax = WOLFSSL_ASN1_INTEGER_MAX; a->length = 0; return a; } /* free's internal elements of WOLFSSL_ASN1_INTEGER and free's "in" itself */ void wolfSSL_ASN1_INTEGER_free(WOLFSSL_ASN1_INTEGER* in) { if (in != NULL) { if (in->isDynamic) { XFREE(in->data, NULL, DYNAMIC_TYPE_OPENSSL); } XFREE(in, NULL, DYNAMIC_TYPE_OPENSSL); } } /* Duplicate all WOLFSSL_ASN1_INTEGER members from src to dup * src : WOLFSSL_ASN1_INTEGER to duplicate * Returns pointer to duplicate WOLFSSL_ASN1_INTEGER */ WOLFSSL_ASN1_INTEGER* wolfSSL_ASN1_INTEGER_dup(const WOLFSSL_ASN1_INTEGER* src) { WOLFSSL_ASN1_INTEGER* dup; WOLFSSL_ENTER("wolfSSL_ASN1_INTEGER_dup"); if (!src) return NULL; dup = wolfSSL_ASN1_INTEGER_new(); if (dup == NULL) return NULL; dup->negative = src->negative; dup->dataMax = src->dataMax; dup->isDynamic = src->isDynamic; #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) dup->length = src->length; #endif XSTRNCPY((char*)dup->intData,(const char*)src->intData,WOLFSSL_ASN1_INTEGER_MAX); if (dup->isDynamic && src->data && dup->dataMax) { dup->data = (unsigned char*) XMALLOC(src->dataMax,NULL,DYNAMIC_TYPE_OPENSSL); if (dup->data == NULL) { wolfSSL_ASN1_INTEGER_free(dup); return NULL; } XMEMCPY(dup->data,src->data,dup->dataMax); } return dup; } /* sets the value of WOLFSSL_ASN1_INTEGER a to the long value v. */ int wolfSSL_ASN1_INTEGER_set(WOLFSSL_ASN1_INTEGER *a, long v) { int ret = WOLFSSL_SUCCESS; /* return 1 for success and 0 for failure */ int j; unsigned int i = 0; unsigned char tmp[sizeof(long)+1] = {0}; if (a != NULL) { /* dynamically create data buffer, +2 for type and length */ a->data = (unsigned char*)XMALLOC((sizeof(long)+1) + 2, NULL, DYNAMIC_TYPE_OPENSSL); if (a->data == NULL) { wolfSSL_ASN1_INTEGER_free(a); ret = WOLFSSL_FAILURE; } else { a->dataMax = (int)(sizeof(long)+1) + 2; a->isDynamic = 1; } } else { /* Invalid parameter */ ret = WOLFSSL_FAILURE; } if (ret != WOLFSSL_FAILURE) { /* Set type */ a->data[i++] = ASN_INTEGER; /* Check for negative */ if (v < 0) { a->negative = 1; v *= -1; } /* Create char buffer */ for (j = 0; j < (int)sizeof(long); j++) { if (v == 0) { break; } tmp[j] = (unsigned char)(v & 0xff); v >>= 8; } /* Set length */ a->data[i++] = (unsigned char)((j == 0) ? ++j : j); /* +2 for type and length */ a->length = j + 2; /* Copy to data */ for (; j > 0; j--) { a->data[i++] = tmp[j-1]; } } return ret; } WOLFSSL_ASN1_INTEGER* wolfSSL_X509_get_serialNumber(WOLFSSL_X509* x509) { WOLFSSL_ASN1_INTEGER* a; int i = 0; WOLFSSL_ENTER("wolfSSL_X509_get_serialNumber"); a = wolfSSL_ASN1_INTEGER_new(); if (a == NULL) return NULL; /* Make sure there is space for the data, ASN.1 type and length. */ if (x509->serialSz > (WOLFSSL_ASN1_INTEGER_MAX - 2)) { /* dynamically create data buffer, +2 for type and length */ a->data = (unsigned char*)XMALLOC(x509->serialSz + 2, NULL, DYNAMIC_TYPE_OPENSSL); if (a->data == NULL) { wolfSSL_ASN1_INTEGER_free(a); return NULL; } a->dataMax = x509->serialSz + 2; a->isDynamic = 1; } else { /* Use array instead of dynamic memory */ a->data = a->intData; a->dataMax = WOLFSSL_ASN1_INTEGER_MAX; } #ifdef WOLFSSL_QT XMEMCPY(&a->data[i], x509->serial, x509->serialSz); a->length = x509->serialSz; #else a->data[i++] = ASN_INTEGER; i += SetLength(x509->serialSz, a->data + i); XMEMCPY(&a->data[i], x509->serial, x509->serialSz); a->length = x509->serialSz + 2; #endif x509->serialNumber = a; return a; } #endif /* OPENSSL_EXTRA */ #if defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(WOLFSSL_NGINX) || \ defined(WOLFSSL_HAPROXY) || defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL) #ifndef NO_ASN_TIME int wolfSSL_ASN1_TIME_print(WOLFSSL_BIO* bio, const WOLFSSL_ASN1_TIME* asnTime) { char buf[MAX_TIME_STRING_SZ]; int ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_ASN1_TIME_print"); if (bio == NULL || asnTime == NULL) { WOLFSSL_MSG("NULL function argument"); return WOLFSSL_FAILURE; } if (wolfSSL_ASN1_TIME_to_string((WOLFSSL_ASN1_TIME*)asnTime, buf, sizeof(buf)) == NULL) { XMEMSET(buf, 0, MAX_TIME_STRING_SZ); XMEMCPY(buf, "Bad time value", 14); ret = WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bio, buf, (int)XSTRLEN(buf)) <= 0) { WOLFSSL_MSG("Unable to write to bio"); return WOLFSSL_FAILURE; } return ret; } char* wolfSSL_ASN1_TIME_to_string(WOLFSSL_ASN1_TIME* t, char* buf, int len) { WOLFSSL_ENTER("wolfSSL_ASN1_TIME_to_string"); if (t == NULL || buf == NULL || len < 5) { WOLFSSL_MSG("Bad argument"); return NULL; } if (t->length > len) { WOLFSSL_MSG("Length of date is longer then buffer"); return NULL; } if (!GetTimeString(t->data, t->type, buf, len)) { return NULL; } return buf; } #endif /* !NO_ASN_TIME */ #endif /* WOLFSSL_MYSQL_COMPATIBLE || WOLFSSL_NGINX || WOLFSSL_HAPROXY || OPENSSL_EXTRA*/ #ifdef OPENSSL_EXTRA #ifndef NO_WOLFSSL_STUB int wolfSSL_ASN1_INTEGER_cmp(const WOLFSSL_ASN1_INTEGER* a, const WOLFSSL_ASN1_INTEGER* b) { (void)a; (void)b; WOLFSSL_STUB("ASN1_INTEGER_cmp"); return 0; } #endif #ifndef NO_WOLFSSL_STUB long wolfSSL_ASN1_INTEGER_get(const WOLFSSL_ASN1_INTEGER* i) { (void)i; WOLFSSL_STUB("ASN1_INTEGER_get"); return 0; } #endif /* get X509_STORE_CTX ex_data, max idx is MAX_EX_DATA */ void* wolfSSL_X509_STORE_CTX_get_ex_data(WOLFSSL_X509_STORE_CTX* ctx, int idx) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_get_ex_data"); #if defined(HAVE_EX_DATA) || defined(FORTRESS) if (ctx != NULL) { return wolfSSL_CRYPTO_get_ex_data(&ctx->ex_data, idx); } #else (void)ctx; (void)idx; #endif return NULL; } /* set X509_STORE_CTX ex_data, max idx is MAX_EX_DATA. Return WOLFSSL_SUCCESS * on success, WOLFSSL_FAILURE on error. */ int wolfSSL_X509_STORE_CTX_set_ex_data(WOLFSSL_X509_STORE_CTX* ctx, int idx, void *data) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_set_ex_data"); #if defined(HAVE_EX_DATA) || defined(FORTRESS) if (ctx != NULL) { return wolfSSL_CRYPTO_set_ex_data(&ctx->ex_data, idx, data); } #else (void)ctx; (void)idx; (void)data; #endif return WOLFSSL_FAILURE; } #if defined(WOLFSSL_APACHE_HTTPD) || defined(OPENSSL_ALL) void wolfSSL_X509_STORE_CTX_set_depth(WOLFSSL_X509_STORE_CTX* ctx, int depth) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_set_depth"); if (ctx) ctx->depth = depth; } #endif WOLFSSL_X509* wolfSSL_X509_STORE_CTX_get0_current_issuer( WOLFSSL_X509_STORE_CTX* ctx) { int ret; WOLFSSL_X509* issuer; WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_get0_current_issuer"); if (ctx == NULL) { return NULL; } ret = wolfSSL_X509_STORE_CTX_get1_issuer(&issuer, ctx, ctx->current_cert); if (ret == WOLFSSL_SUCCESS) { return issuer; } return NULL; } /* Gets an index to store SSL structure at. * * Returns positive index on success and negative values on failure */ int wolfSSL_get_ex_data_X509_STORE_CTX_idx(void) { WOLFSSL_ENTER("wolfSSL_get_ex_data_X509_STORE_CTX_idx"); /* store SSL at index 0 */ return 0; } /* Set an error stat in the X509 STORE CTX * */ void wolfSSL_X509_STORE_CTX_set_error(WOLFSSL_X509_STORE_CTX* ctx, int er) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_set_error"); if (ctx != NULL) { ctx->error = er; } } /* Set the error depth in the X509 STORE CTX */ void wolfSSL_X509_STORE_CTX_set_error_depth(WOLFSSL_X509_STORE_CTX* ctx, int depth) { WOLFSSL_ENTER("wolfSSL_X509_STORE_CTX_set_error_depth"); if (ctx != NULL) { ctx->error_depth = depth; } } /* Sets a function callback that will send information about the state of all * WOLFSSL objects that have been created by the WOLFSSL_CTX structure passed * in. * * ctx WOLFSSL_CTX structure to set callback function in * f callback function to use */ void wolfSSL_CTX_set_info_callback(WOLFSSL_CTX* ctx, void (*f)(const WOLFSSL* ssl, int type, int val)) { WOLFSSL_ENTER("wolfSSL_CTX_set_info_callback"); if (ctx == NULL) { WOLFSSL_MSG("Bad function argument"); } else { ctx->CBIS = f; } } unsigned long wolfSSL_ERR_peek_error(void) { WOLFSSL_ENTER("wolfSSL_ERR_peek_error"); return wolfSSL_ERR_peek_error_line_data(NULL, NULL, NULL, NULL); } int wolfSSL_ERR_GET_LIB(unsigned long err) { switch (err) { case PEM_R_NO_START_LINE: case PEM_R_PROBLEMS_GETTING_PASSWORD: case PEM_R_BAD_PASSWORD_READ: case PEM_R_BAD_DECRYPT: return ERR_LIB_PEM; case EVP_R_BAD_DECRYPT: case EVP_R_BN_DECODE_ERROR: case EVP_R_DECODE_ERROR: case EVP_R_PRIVATE_KEY_DECODE_ERROR: return ERR_LIB_EVP; default: return 0; } } /* This function is to find global error values that are the same through out * all library version. With wolfSSL having only one set of error codes the * return value is pretty straight forward. The only thing needed is all wolfSSL * error values are typically negative. * * Returns the error reason */ int wolfSSL_ERR_GET_REASON(unsigned long err) { int ret = (int)err; WOLFSSL_ENTER("wolfSSL_ERR_GET_REASON"); #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) /* Nginx looks for this error to know to stop parsing certificates. */ if (err == ((ERR_LIB_PEM << 24) | PEM_R_NO_START_LINE)) return PEM_R_NO_START_LINE; #endif /* check if error value is in range of wolfSSL errors */ ret = 0 - ret; /* setting as negative value */ /* wolfCrypt range is less than MAX (-100) wolfSSL range is MIN (-300) and lower */ if (ret < MAX_CODE_E && ret > MIN_CODE_E) { return ret; } else { WOLFSSL_MSG("Not in range of typical error values"); ret = (int)err; } return ret; } /* returns a string that describes the alert * * alertID the alert value to look up */ const char* wolfSSL_alert_type_string_long(int alertID) { WOLFSSL_ENTER("wolfSSL_alert_type_string_long"); switch (alertID) { case close_notify: { static const char close_notify_str[] = "close_notify"; return close_notify_str; } case unexpected_message: { static const char unexpected_message_str[] = "unexpected_message"; return unexpected_message_str; } case bad_record_mac: { static const char bad_record_mac_str[] = "bad_record_mac"; return bad_record_mac_str; } case record_overflow: { static const char record_overflow_str[] = "record_overflow"; return record_overflow_str; } case decompression_failure: { static const char decompression_failure_str[] = "decompression_failure"; return decompression_failure_str; } case handshake_failure: { static const char handshake_failure_str[] = "handshake_failure"; return handshake_failure_str; } case no_certificate: { static const char no_certificate_str[] = "no_certificate"; return no_certificate_str; } case bad_certificate: { static const char bad_certificate_str[] = "bad_certificate"; return bad_certificate_str; } case unsupported_certificate: { static const char unsupported_certificate_str[] = "unsupported_certificate"; return unsupported_certificate_str; } case certificate_revoked: { static const char certificate_revoked_str[] = "certificate_revoked"; return certificate_revoked_str; } case certificate_expired: { static const char certificate_expired_str[] = "certificate_expired"; return certificate_expired_str; } case certificate_unknown: { static const char certificate_unknown_str[] = "certificate_unknown"; return certificate_unknown_str; } case illegal_parameter: { static const char illegal_parameter_str[] = "illegal_parameter"; return illegal_parameter_str; } case unknown_ca: { static const char unknown_ca_str[] = "unknown_ca"; return unknown_ca_str; } case decode_error: { static const char decode_error_str[] = "decode_error"; return decode_error_str; } case decrypt_error: { static const char decrypt_error_str[] = "decrypt_error"; return decrypt_error_str; } #ifdef WOLFSSL_MYSQL_COMPATIBLE /* catch name conflict for enum protocol with MYSQL build */ case wc_protocol_version: { static const char wc_protocol_version_str[] = "wc_protocol_version"; return wc_protocol_version_str; } #else case protocol_version: { static const char protocol_version_str[] = "protocol_version"; return protocol_version_str; } #endif case no_renegotiation: { static const char no_renegotiation_str[] = "no_renegotiation"; return no_renegotiation_str; } case unrecognized_name: { static const char unrecognized_name_str[] = "unrecognized_name"; return unrecognized_name_str; } case bad_certificate_status_response: { static const char bad_certificate_status_response_str[] = "bad_certificate_status_response"; return bad_certificate_status_response_str; } case no_application_protocol: { static const char no_application_protocol_str[] = "no_application_protocol"; return no_application_protocol_str; } default: WOLFSSL_MSG("Unknown Alert"); return NULL; } } const char* wolfSSL_alert_desc_string_long(int alertID) { WOLFSSL_ENTER("wolfSSL_alert_desc_string_long"); return wolfSSL_alert_type_string_long(alertID); } /* Gets the current state of the WOLFSSL structure * * ssl WOLFSSL structure to get state of * * Returns a human readable string of the WOLFSSL structure state */ const char* wolfSSL_state_string_long(const WOLFSSL* ssl) { static const char* OUTPUT_STR[14][6][3] = { { {"SSLv3 Initialization","SSLv3 Initialization","SSLv3 Initialization"}, {"TLSv1 Initialization","TLSv2 Initialization","TLSv2 Initialization"}, {"TLSv1_1 Initialization","TLSv1_1 Initialization","TLSv1_1 Initialization"}, {"TLSv1_2 Initialization","TLSv1_2 Initialization","TLSv1_2 Initialization"}, {"DTLSv1 Initialization","DTLSv1 Initialization","DTLSv1 Initialization"}, {"DTLSv1_2 Initialization","DTLSv1_2 Initialization","DTLSv1_2 Initialization"}, }, { {"SSLv3 read Server Hello Verify Request", "SSLv3 write Server Hello Verify Request", "SSLv3 Server Hello Verify Request"}, {"TLSv1 read Server Hello Verify Request", "TLSv1 write Server Hello Verify Request", "TLSv1 Server Hello Verify Request"}, {"TLSv1_1 read Server Hello Verify Request", "TLSv1_1 write Server Hello Verify Request", "TLSv1_1 Server Hello Verify Request"}, {"TLSv1_2 read Server Hello Verify Request", "TLSv1_2 write Server Hello Verify Request", "TLSv1_2 Server Hello Verify Request"}, {"DTLSv1 read Server Hello Verify Request", "DTLSv1 write Server Hello Verify Request", "DTLSv1 Server Hello Verify Request"}, {"DTLSv1_2 read Server Hello Verify Request", "DTLSv1_2 write Server Hello Verify Request", "DTLSv1_2 Server Hello Verify Request"}, }, { {"SSLv3 read Server Hello", "SSLv3 write Server Hello", "SSLv3 Server Hello"}, {"TLSv1 read Server Hello", "TLSv1 write Server Hello", "TLSv1 Server Hello"}, {"TLSv1_1 read Server Hello", "TLSv1_1 write Server Hello", "TLSv1_1 Server Hello"}, {"TLSv1_2 read Server Hello", "TLSv1_2 write Server Hello", "TLSv1_2 Server Hello"}, {"DTLSv1 read Server Hello", "DTLSv1 write Server Hello", "DTLSv1 Server Hello"}, {"DTLSv1_2 read Server Hello" "DTLSv1_2 write Server Hello", "DTLSv1_2 Server Hello", }, }, { {"SSLv3 read Server Session Ticket", "SSLv3 write Server Session Ticket", "SSLv3 Server Session Ticket"}, {"TLSv1 read Server Session Ticket", "TLSv1 write Server Session Ticket", "TLSv1 Server Session Ticket"}, {"TLSv1_1 read Server Session Ticket", "TLSv1_1 write Server Session Ticket", "TLSv1_1 Server Session Ticket"}, {"TLSv1_2 read Server Session Ticket", "TLSv1_2 write Server Session Ticket", "TLSv1_2 Server Session Ticket"}, {"DTLSv1 read Server Session Ticket", "DTLSv1 write Server Session Ticket", "DTLSv1 Server Session Ticket"}, {"DTLSv1_2 read Server Session Ticket", "DTLSv1_2 write Server Session Ticket", "DTLSv1_2 Server Session Ticket"}, }, { {"SSLv3 read Server Cert", "SSLv3 write Server Cert", "SSLv3 Server Cert"}, {"TLSv1 read Server Cert", "TLSv1 write Server Cert", "TLSv1 Server Cert"}, {"TLSv1_1 read Server Cert", "TLSv1_1 write Server Cert", "TLSv1_1 Server Cert"}, {"TLSv1_2 read Server Cert", "TLSv1_2 write Server Cert", "TLSv1_2 Server Cert"}, {"DTLSv1 read Server Cert", "DTLSv1 write Server Cert", "DTLSv1 Server Cert"}, {"DTLSv1_2 read Server Cert", "DTLSv1_2 write Server Cert", "DTLSv1_2 Server Cert"}, }, { {"SSLv3 read Server Key Exchange", "SSLv3 write Server Key Exchange", "SSLv3 Server Key Exchange"}, {"TLSv1 read Server Key Exchange", "TLSv1 write Server Key Exchange", "TLSv1 Server Key Exchange"}, {"TLSv1_1 read Server Key Exchange", "TLSv1_1 write Server Key Exchange", "TLSv1_1 Server Key Exchange"}, {"TLSv1_2 read Server Key Exchange", "TLSv1_2 write Server Key Exchange", "TLSv1_2 Server Key Exchange"}, {"DTLSv1 read Server Key Exchange", "DTLSv1 write Server Key Exchange", "DTLSv1 Server Key Exchange"}, {"DTLSv1_2 read Server Key Exchange", "DTLSv1_2 write Server Key Exchange", "DTLSv1_2 Server Key Exchange"}, }, { {"SSLv3 read Server Hello Done", "SSLv3 write Server Hello Done", "SSLv3 Server Hello Done"}, {"TLSv1 read Server Hello Done", "TLSv1 write Server Hello Done", "TLSv1 Server Hello Done"}, {"TLSv1_1 read Server Hello Done", "TLSv1_1 write Server Hello Done", "TLSv1_1 Server Hello Done"}, {"TLSv1_2 read Server Hello Done", "TLSv1_2 write Server Hello Done", "TLSv1_2 Server Hello Done"}, {"DTLSv1 read Server Hello Done", "DTLSv1 write Server Hello Done", "DTLSv1 Server Hello Done"}, {"DTLSv1_2 read Server Hello Done", "DTLSv1_2 write Server Hello Done", "DTLSv1_2 Server Hello Done"}, }, { {"SSLv3 read Server Change CipherSpec", "SSLv3 write Server Change CipherSpec", "SSLv3 Server Change CipherSpec"}, {"TLSv1 read Server Change CipherSpec", "TLSv1 write Server Change CipherSpec", "TLSv1 Server Change CipherSpec"}, {"TLSv1_1 read Server Change CipherSpec", "TLSv1_1 write Server Change CipherSpec", "TLSv1_1 Server Change CipherSpec"}, {"TLSv1_2 read Server Change CipherSpec", "TLSv1_2 write Server Change CipherSpec", "TLSv1_2 Server Change CipherSpec"}, {"DTLSv1 read Server Change CipherSpec", "DTLSv1 write Server Change CipherSpec", "DTLSv1 Server Change CipherSpec"}, {"DTLSv1_2 read Server Change CipherSpec", "DTLSv1_2 write Server Change CipherSpec", "DTLSv1_2 Server Change CipherSpec"}, }, { {"SSLv3 read Server Finished", "SSLv3 write Server Finished", "SSLv3 Server Finished"}, {"TLSv1 read Server Finished", "TLSv1 write Server Finished", "TLSv1 Server Finished"}, {"TLSv1_1 read Server Finished", "TLSv1_1 write Server Finished", "TLSv1_1 Server Finished"}, {"TLSv1_2 read Server Finished", "TLSv1_2 write Server Finished", "TLSv1_2 Server Finished"}, {"DTLSv1 read Server Finished", "DTLSv1 write Server Finished", "DTLSv1 Server Finished"}, {"DTLSv1_2 read Server Finished", "DTLSv1_2 write Server Finished", "DTLSv1_2 Server Finished"}, }, { {"SSLv3 read Client Hello", "SSLv3 write Client Hello", "SSLv3 Client Hello"}, {"TLSv1 read Client Hello", "TLSv1 write Client Hello", "TLSv1 Client Hello"}, {"TLSv1_1 read Client Hello", "TLSv1_1 write Client Hello", "TLSv1_1 Client Hello"}, {"TLSv1_2 read Client Hello", "TLSv1_2 write Client Hello", "TLSv1_2 Client Hello"}, {"DTLSv1 read Client Hello", "DTLSv1 write Client Hello", "DTLSv1 Client Hello"}, {"DTLSv1_2 read Client Hello", "DTLSv1_2 write Client Hello", "DTLSv1_2 Client Hello"}, }, { {"SSLv3 read Client Key Exchange", "SSLv3 write Client Key Exchange", "SSLv3 Client Key Exchange"}, {"TLSv1 read Client Key Exchange", "TLSv1 write Client Key Exchange", "TLSv1 Client Key Exchange"}, {"TLSv1_1 read Client Key Exchange", "TLSv1_1 write Client Key Exchange", "TLSv1_1 Client Key Exchange"}, {"TLSv1_2 read Client Key Exchange", "TLSv1_2 write Client Key Exchange", "TLSv1_2 Client Key Exchange"}, {"DTLSv1 read Client Key Exchange", "DTLSv1 write Client Key Exchange", "DTLSv1 Client Key Exchange"}, {"DTLSv1_2 read Client Key Exchange", "DTLSv1_2 write Client Key Exchange", "DTLSv1_2 Client Key Exchange"}, }, { {"SSLv3 read Client Change CipherSpec", "SSLv3 write Client Change CipherSpec", "SSLv3 Client Change CipherSpec"}, {"TLSv1 read Client Change CipherSpec", "TLSv1 write Client Change CipherSpec", "TLSv1 Client Change CipherSpec"}, {"TLSv1_1 read Client Change CipherSpec", "TLSv1_1 write Client Change CipherSpec", "TLSv1_1 Client Change CipherSpec"}, {"TLSv1_2 read Client Change CipherSpec", "TLSv1_2 write Client Change CipherSpec", "TLSv1_2 Client Change CipherSpec"}, {"DTLSv1 read Client Change CipherSpec", "DTLSv1 write Client Change CipherSpec", "DTLSv1 Client Change CipherSpec"}, {"DTLSv1_2 read Client Change CipherSpec", "DTLSv1_2 write Client Change CipherSpec", "DTLSv1_2 Client Change CipherSpec"}, }, { {"SSLv3 read Client Finished", "SSLv3 write Client Finished", "SSLv3 Client Finished"}, {"TLSv1 read Client Finished", "TLSv1 write Client Finished", "TLSv1 Client Finished"}, {"TLSv1_1 read Client Finished", "TLSv1_1 write Client Finished", "TLSv1_1 Client Finished"}, {"TLSv1_2 read Client Finished", "TLSv1_2 write Client Finished", "TLSv1_2 Client Finished"}, {"DTLSv1 read Client Finished", "DTLSv1 write Client Finished", "DTLSv1 Client Finished"}, {"DTLSv1_2 read Client Finished", "DTLSv1_2 write Client Finished", "DTLSv1_2 Client Finished"}, }, { {"SSLv3 Handshake Done", "SSLv3 Handshake Done", "SSLv3 Handshake Done"}, {"TLSv1 Handshake Done", "TLSv1 Handshake Done", "TLSv1 Handshake Done"}, {"TLSv1_1 Handshake Done", "TLSv1_1 Handshake Done", "TLSv1_1 Handshake Done"}, {"TLSv1_2 Handshake Done", "TLSv1_2 Handshake Done", "TLSv1_2 Handshake Done"}, {"DTLSv1 Handshake Done", "DTLSv1 Handshake Done", "DTLSv1 Handshake Done"}, {"DTLSv1_2 Handshake Done" "DTLSv1_2 Handshake Done" "DTLSv1_2 Handshake Done"} } }; enum ProtocolVer { SSL_V3 = 0, TLS_V1, TLS_V1_1, TLS_V1_2, DTLS_V1, DTLS_V1_2, UNKNOWN = 100 }; enum IOMode { SS_READ = 0, SS_WRITE, SS_NEITHER }; enum SslState { ss_null_state = 0, ss_server_helloverify, ss_server_hello, ss_sessionticket, ss_server_cert, ss_server_keyexchange, ss_server_hellodone, ss_server_changecipherspec, ss_server_finished, ss_client_hello, ss_client_keyexchange, ss_client_changecipherspec, ss_client_finished, ss_handshake_done }; int protocol = 0; int cbmode = 0; int state = 0; WOLFSSL_ENTER("wolfSSL_state_string_long"); if (ssl == NULL) { WOLFSSL_MSG("Null argument passed in"); return NULL; } /* Get state of callback */ if (ssl->cbmode == SSL_CB_MODE_WRITE){ cbmode = SS_WRITE; } else if (ssl->cbmode == SSL_CB_MODE_READ){ cbmode = SS_READ; } else { cbmode = SS_NEITHER; } /* Get protocol version */ switch (ssl->version.major){ case SSLv3_MAJOR: switch (ssl->version.minor){ case TLSv1_MINOR: protocol = TLS_V1; break; case TLSv1_1_MINOR: protocol = TLS_V1_1; break; case TLSv1_2_MINOR: protocol = TLS_V1_2; break; case SSLv3_MINOR: protocol = SSL_V3; break; default: protocol = UNKNOWN; } break; case DTLS_MAJOR: switch (ssl->version.minor){ case DTLS_MINOR: protocol = DTLS_V1; break; case DTLSv1_2_MINOR: protocol = DTLS_V1_2; break; default: protocol = UNKNOWN; } break; default: protocol = UNKNOWN; } /* accept process */ if (ssl->cbmode == SSL_CB_MODE_READ){ state = ssl->cbtype; switch (state) { case hello_verify_request: state = ss_server_helloverify; break; case session_ticket: state = ss_sessionticket; break; case server_hello: state = ss_server_hello; break; case server_hello_done: state = ss_server_hellodone; break; case certificate: state = ss_server_cert; break; case server_key_exchange: state = ss_server_keyexchange; break; case client_hello: state = ss_client_hello; break; case client_key_exchange: state = ss_client_keyexchange; break; case finished: if (ssl->options.side == WOLFSSL_SERVER_END) state = ss_client_finished; else if (ssl->options.side == WOLFSSL_CLIENT_END) state = ss_server_finished; else { WOLFSSL_MSG("Unknown State"); state = ss_null_state; } break; default: WOLFSSL_MSG("Unknown State"); state = ss_null_state; } } else { /* Send process */ if (ssl->options.side == WOLFSSL_SERVER_END) state = ssl->options.serverState; else state = ssl->options.clientState; switch(state){ case SERVER_HELLOVERIFYREQUEST_COMPLETE: state = ss_server_helloverify; break; case SERVER_HELLO_COMPLETE: state = ss_server_hello; break; case SERVER_CERT_COMPLETE: state = ss_server_cert; break; case SERVER_KEYEXCHANGE_COMPLETE: state = ss_server_keyexchange; break; case SERVER_HELLODONE_COMPLETE: state = ss_server_hellodone; break; case SERVER_CHANGECIPHERSPEC_COMPLETE: state = ss_server_changecipherspec; break; case SERVER_FINISHED_COMPLETE: state = ss_server_finished; break; case CLIENT_HELLO_COMPLETE: state = ss_client_hello; break; case CLIENT_KEYEXCHANGE_COMPLETE: state = ss_client_keyexchange; break; case CLIENT_CHANGECIPHERSPEC_COMPLETE: state = ss_client_changecipherspec; break; case CLIENT_FINISHED_COMPLETE: state = ss_client_finished; break; case HANDSHAKE_DONE: state = ss_handshake_done; break; default: WOLFSSL_MSG("Unknown State"); state = ss_null_state; } } if (protocol == UNKNOWN) return NULL; else return OUTPUT_STR[state][protocol][cbmode]; } /* * Sets default PEM callback password if null is passed into * the callback parameter of a PEM_read_bio_* function. * * Returns callback phrase size on success or WOLFSSL_FAILURE otherwise. */ int wolfSSL_PEM_def_callback(char* name, int num, int w, void* key) { int sz; (void)w; WOLFSSL_ENTER("wolfSSL_PEM_def_callback"); /* We assume that the user passes a default password as userdata */ if (key) { sz = (int)XSTRLEN((const char*)key); sz = (sz > num) ? num : sz; XMEMCPY(name, key, sz); return sz; } else { WOLFSSL_MSG("Error, default password cannot be created."); return WOLFSSL_FAILURE; } } #endif /* OPENSSL_EXTRA */ #if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER) static long wolf_set_options(long old_op, long op) { /* if SSL_OP_ALL then turn all bug workarounds on */ if ((op & SSL_OP_ALL) == SSL_OP_ALL) { WOLFSSL_MSG("\tSSL_OP_ALL"); } /* by default cookie exchange is on with DTLS */ if ((op & SSL_OP_COOKIE_EXCHANGE) == SSL_OP_COOKIE_EXCHANGE) { WOLFSSL_MSG("\tSSL_OP_COOKIE_EXCHANGE : on by default"); } if ((op & WOLFSSL_OP_NO_SSLv2) == WOLFSSL_OP_NO_SSLv2) { WOLFSSL_MSG("\tWOLFSSL_OP_NO_SSLv2 : wolfSSL does not support SSLv2"); } #ifdef SSL_OP_NO_TLSv1_3 if ((op & SSL_OP_NO_TLSv1_3) == SSL_OP_NO_TLSv1_3) { WOLFSSL_MSG("\tSSL_OP_NO_TLSv1_3"); } #endif if ((op & SSL_OP_NO_TLSv1_2) == SSL_OP_NO_TLSv1_2) { WOLFSSL_MSG("\tSSL_OP_NO_TLSv1_2"); } if ((op & SSL_OP_NO_TLSv1_1) == SSL_OP_NO_TLSv1_1) { WOLFSSL_MSG("\tSSL_OP_NO_TLSv1_1"); } if ((op & SSL_OP_NO_TLSv1) == SSL_OP_NO_TLSv1) { WOLFSSL_MSG("\tSSL_OP_NO_TLSv1"); } if ((op & SSL_OP_NO_SSLv3) == SSL_OP_NO_SSLv3) { WOLFSSL_MSG("\tSSL_OP_NO_SSLv3"); } if ((op & SSL_OP_CIPHER_SERVER_PREFERENCE) == SSL_OP_CIPHER_SERVER_PREFERENCE) { WOLFSSL_MSG("\tSSL_OP_CIPHER_SERVER_PREFERENCE"); } if ((op & SSL_OP_NO_COMPRESSION) == SSL_OP_NO_COMPRESSION) { #ifdef HAVE_LIBZ WOLFSSL_MSG("SSL_OP_NO_COMPRESSION"); #else WOLFSSL_MSG("SSL_OP_NO_COMPRESSION: compression not compiled in"); #endif } return old_op | op; } #endif #ifdef OPENSSL_EXTRA long wolfSSL_set_options(WOLFSSL* ssl, long op) { word16 haveRSA = 1; word16 havePSK = 0; int keySz = 0; WOLFSSL_ENTER("wolfSSL_set_options"); if (ssl == NULL) { return 0; } ssl->options.mask = wolf_set_options(ssl->options.mask, op); #ifdef SSL_OP_NO_TLSv1_3 if ((ssl->options.mask & SSL_OP_NO_TLSv1_3) == SSL_OP_NO_TLSv1_3) { if (ssl->version.minor == TLSv1_3_MINOR) ssl->version.minor = TLSv1_2_MINOR; } #endif if ((ssl->options.mask & SSL_OP_NO_TLSv1_2) == SSL_OP_NO_TLSv1_2) { if (ssl->version.minor == TLSv1_2_MINOR) ssl->version.minor = TLSv1_1_MINOR; } if ((ssl->options.mask & SSL_OP_NO_TLSv1_1) == SSL_OP_NO_TLSv1_1) { if (ssl->version.minor == TLSv1_1_MINOR) ssl->version.minor = TLSv1_MINOR; } if ((ssl->options.mask & SSL_OP_NO_TLSv1) == SSL_OP_NO_TLSv1) { if (ssl->version.minor == TLSv1_MINOR) ssl->version.minor = SSLv3_MINOR; } if ((ssl->options.mask & SSL_OP_NO_COMPRESSION) == SSL_OP_NO_COMPRESSION) { #ifdef HAVE_LIBZ ssl->options.usingCompression = 0; #endif } /* in the case of a version change the cipher suites should be reset */ #ifndef NO_PSK havePSK = ssl->options.havePSK; #endif #ifdef NO_RSA haveRSA = 0; #endif #ifndef NO_CERTS keySz = ssl->buffers.keySz; #endif InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK, ssl->options.haveDH, ssl->options.haveNTRU, ssl->options.haveECDSAsig, ssl->options.haveECC, ssl->options.haveStaticECC, ssl->options.side); return ssl->options.mask; } long wolfSSL_get_options(const WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_options"); if(ssl == NULL) return WOLFSSL_FAILURE; return ssl->options.mask; } long wolfSSL_clear_options(WOLFSSL* ssl, long opt) { WOLFSSL_ENTER("SSL_clear_options"); if(ssl == NULL) return WOLFSSL_FAILURE; ssl->options.mask &= ~opt; return ssl->options.mask; } #if defined(HAVE_SECURE_RENEGOTIATION) \ || defined(HAVE_SERVER_RENEGOTIATION_INFO) /* clears the counter for number of renegotiations done * returns the current count before it is cleared */ long wolfSSL_clear_num_renegotiations(WOLFSSL *s) { long total; WOLFSSL_ENTER("wolfSSL_clear_num_renegotiations"); if (s == NULL) return 0; total = s->secure_rene_count; s->secure_rene_count = 0; return total; } /* return the number of renegotiations since wolfSSL_new */ long wolfSSL_total_renegotiations(WOLFSSL *s) { WOLFSSL_ENTER("wolfSSL_total_renegotiations"); return wolfSSL_num_renegotiations(s); } /* return the number of renegotiations since wolfSSL_new */ long wolfSSL_num_renegotiations(WOLFSSL* s) { if (s == NULL) { return 0; } return s->secure_rene_count; } #endif /* HAVE_SECURE_RENEGOTIATION || HAVE_SERVER_RENEGOTIATION_INFO */ #ifndef NO_DH long wolfSSL_set_tmp_dh(WOLFSSL *ssl, WOLFSSL_DH *dh) { int pSz, gSz; byte *p, *g; int ret = 0; WOLFSSL_ENTER("wolfSSL_set_tmp_dh"); if (!ssl || !dh) return BAD_FUNC_ARG; /* Get needed size for p and g */ pSz = wolfSSL_BN_bn2bin(dh->p, NULL); gSz = wolfSSL_BN_bn2bin(dh->g, NULL); if (pSz <= 0 || gSz <= 0) return WOLFSSL_FATAL_ERROR; p = (byte*)XMALLOC(pSz, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); if (!p) return MEMORY_E; g = (byte*)XMALLOC(gSz, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); if (!g) { XFREE(p, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); return MEMORY_E; } pSz = wolfSSL_BN_bn2bin(dh->p, p); gSz = wolfSSL_BN_bn2bin(dh->g, g); if (pSz >= 0 && gSz >= 0) /* Conversion successful */ ret = wolfSSL_SetTmpDH(ssl, p, pSz, g, gSz); XFREE(p, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(g, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); return pSz > 0 && gSz > 0 ? ret : WOLFSSL_FATAL_ERROR; } #endif /* !NO_DH */ #ifdef HAVE_PK_CALLBACKS long wolfSSL_set_tlsext_debug_arg(WOLFSSL* ssl, void *arg) { if (ssl == NULL) { return WOLFSSL_FAILURE; } ssl->loggingCtx = arg; return WOLFSSL_SUCCESS; } #endif /* HAVE_PK_CALLBACKS */ #if defined(OPENSSL_ALL) || defined(WOLFSSL_HAPROXY) const unsigned char *SSL_SESSION_get0_id_context(const SSL_SESSION *sess, unsigned int *sid_ctx_length) { const byte *c = wolfSSL_SESSION_get_id((SSL_SESSION *)sess, sid_ctx_length); return c; } #endif /*** TBD ***/ #ifndef NO_WOLFSSL_STUB WOLFSSL_API int wolfSSL_sk_SSL_COMP_zero(WOLFSSL_STACK* st) { (void)st; WOLFSSL_STUB("wolfSSL_sk_SSL_COMP_zero"); /* wolfSSL_set_options(ssl, SSL_OP_NO_COMPRESSION); */ return WOLFSSL_FAILURE; } #endif #ifdef HAVE_CERTIFICATE_STATUS_REQUEST long wolfSSL_set_tlsext_status_type(WOLFSSL *s, int type) { WOLFSSL_ENTER("wolfSSL_set_tlsext_status_type"); if (s == NULL){ return BAD_FUNC_ARG; } if (type == TLSEXT_STATUSTYPE_ocsp){ int r = 0; r = TLSX_UseCertificateStatusRequest(&s->extensions, type, 0, s, s->heap, s->devId); return (long)r; } else { WOLFSSL_MSG( "SSL_set_tlsext_status_type only supports TLSEXT_STATUSTYPE_ocsp type."); return SSL_FAILURE; } } #endif /* HAVE_CERTIFICATE_STATUS_REQUEST */ #ifndef NO_WOLFSSL_STUB WOLFSSL_API long wolfSSL_get_tlsext_status_exts(WOLFSSL *s, void *arg) { (void)s; (void)arg; WOLFSSL_STUB("wolfSSL_get_tlsext_status_exts"); return WOLFSSL_FAILURE; } #endif /*** TBD ***/ #ifndef NO_WOLFSSL_STUB WOLFSSL_API long wolfSSL_set_tlsext_status_exts(WOLFSSL *s, void *arg) { (void)s; (void)arg; WOLFSSL_STUB("wolfSSL_set_tlsext_status_exts"); return WOLFSSL_FAILURE; } #endif /*** TBD ***/ #ifndef NO_WOLFSSL_STUB WOLFSSL_API long wolfSSL_get_tlsext_status_ids(WOLFSSL *s, void *arg) { (void)s; (void)arg; WOLFSSL_STUB("wolfSSL_get_tlsext_status_ids"); return WOLFSSL_FAILURE; } #endif /*** TBD ***/ #ifndef NO_WOLFSSL_STUB WOLFSSL_API long wolfSSL_set_tlsext_status_ids(WOLFSSL *s, void *arg) { (void)s; (void)arg; WOLFSSL_STUB("wolfSSL_set_tlsext_status_ids"); return WOLFSSL_FAILURE; } #endif /*** TBD ***/ #ifndef NO_WOLFSSL_STUB WOLFSSL_API int SSL_SESSION_set1_id(WOLFSSL_SESSION *s, const unsigned char *sid, unsigned int sid_len) { (void)s; (void)sid; (void)sid_len; WOLFSSL_STUB("SSL_SESSION_set1_id"); return WOLFSSL_FAILURE; } #endif #ifndef NO_WOLFSSL_STUB /*** TBD ***/ WOLFSSL_API int SSL_SESSION_set1_id_context(WOLFSSL_SESSION *s, const unsigned char *sid_ctx, unsigned int sid_ctx_len) { (void)s; (void)sid_ctx; (void)sid_ctx_len; WOLFSSL_STUB("SSL_SESSION_set1_id_context"); return WOLFSSL_FAILURE; } #endif #if defined(OPENSSL_ALL) || defined(WOLFSSL_APACHE_HTTPD) \ || defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_WPAS) WOLFSSL_X509_ALGOR* wolfSSL_X509_ALGOR_new(void) { WOLFSSL_X509_ALGOR* ret; ret = (WOLFSSL_X509_ALGOR*)XMALLOC(sizeof(WOLFSSL_X509_ALGOR), NULL, DYNAMIC_TYPE_OPENSSL); if (ret) { XMEMSET(ret, 0, sizeof(WOLFSSL_X509_ALGOR)); } return ret; } void wolfSSL_X509_ALGOR_free(WOLFSSL_X509_ALGOR *alg) { if (alg) { wolfSSL_ASN1_OBJECT_free(alg->algorithm); wolfSSL_ASN1_TYPE_free(alg->parameter); XFREE(alg, NULL, DYNAMIC_TYPE_OPENSSL); } } /* Returns X509_ALGOR struct with signature algorithm */ const WOLFSSL_X509_ALGOR* wolfSSL_X509_get0_tbs_sigalg(const WOLFSSL_X509 *x509) { WOLFSSL_ENTER("X509_get0_tbs_sigalg"); if (x509 == NULL) { WOLFSSL_MSG("x509 struct NULL error"); return NULL; } return &x509->algor; } /* Sets paobj pointer to X509_ALGOR signature algorithm */ void wolfSSL_X509_ALGOR_get0(const WOLFSSL_ASN1_OBJECT **paobj, int *pptype, const void **ppval, const WOLFSSL_X509_ALGOR *algor) { WOLFSSL_ENTER("X509_ALGOR_get0"); if (!algor) { WOLFSSL_MSG("algor object is NULL"); return; } if (paobj) *paobj = algor->algorithm; if (ppval) *ppval = algor->algorithm; if (pptype) { if (algor->parameter) { *pptype = algor->parameter->type; } else { /* Default to V_ASN1_OBJECT */ *pptype = V_ASN1_OBJECT; } } } /** * Populate algor members. * * @param algor The object to be set * @param aobj The value to be set in algor->algorithm * @param ptype The type of algor->parameter * @param pval The value of algor->parameter * @return WOLFSSL_SUCCESS on success * WOLFSSL_FAILURE on missing parameters or bad malloc */ int wolfSSL_X509_ALGOR_set0(WOLFSSL_X509_ALGOR *algor, WOLFSSL_ASN1_OBJECT *aobj, int ptype, void *pval) { if (!algor) { return WOLFSSL_FAILURE; } if (aobj) { algor->algorithm = aobj; } if (pval) { if (!algor->parameter) { algor->parameter = wolfSSL_ASN1_TYPE_new(); if (!algor->parameter) { return WOLFSSL_FAILURE; } } wolfSSL_ASN1_TYPE_set(algor->parameter, ptype, pval); } return WOLFSSL_SUCCESS; } /** * Set `a` in a smart way. * * @param a Object to set * @param type The type of object in value * @param value Object to set */ void wolfSSL_ASN1_TYPE_set(WOLFSSL_ASN1_TYPE *a, int type, void *value) { if (!a || !value) { return; } switch (type) { case V_ASN1_OBJECT: a->value.object = value; break; case V_ASN1_UTCTIME: a->value.utctime = value; break; case V_ASN1_GENERALIZEDTIME: a->value.generalizedtime = value; break; default: WOLFSSL_MSG("Unknown or unsupported ASN1_TYPE"); return; } a->type = type; } /** * Allocate a new WOLFSSL_ASN1_TYPE object. * * @return New zero'ed WOLFSSL_ASN1_TYPE object */ WOLFSSL_ASN1_TYPE* wolfSSL_ASN1_TYPE_new(void) { WOLFSSL_ASN1_TYPE* ret = (WOLFSSL_ASN1_TYPE*)XMALLOC(sizeof(WOLFSSL_ASN1_TYPE), NULL, DYNAMIC_TYPE_OPENSSL); if (!ret) return NULL; XMEMSET(ret, 0, sizeof(WOLFSSL_ASN1_TYPE)); return ret; } /** * Free WOLFSSL_ASN1_TYPE and all its members. * * @param at Object to free */ void wolfSSL_ASN1_TYPE_free(WOLFSSL_ASN1_TYPE* at) { if (at) { switch (at->type) { case V_ASN1_OBJECT: wolfSSL_ASN1_OBJECT_free(at->value.object); break; case V_ASN1_UTCTIME: wolfSSL_ASN1_TIME_free(at->value.utctime); break; case V_ASN1_GENERALIZEDTIME: wolfSSL_ASN1_TIME_free(at->value.generalizedtime); break; default: WOLFSSL_MSG("Unknown or unsupported ASN1_TYPE"); break; } XFREE(at, NULL, DYNAMIC_TYPE_OPENSSL); } } /** * Allocate a new WOLFSSL_X509_PUBKEY object. * * @return New zero'ed WOLFSSL_X509_PUBKEY object */ WOLFSSL_X509_PUBKEY *wolfSSL_X509_PUBKEY_new(void) { WOLFSSL_X509_PUBKEY *ret; ret = (WOLFSSL_X509_PUBKEY*)XMALLOC(sizeof(WOLFSSL_X509_PUBKEY), NULL, DYNAMIC_TYPE_OPENSSL); if (!ret) { return NULL; } XMEMSET(ret, 0, sizeof(WOLFSSL_X509_PUBKEY)); ret->algor = wolfSSL_X509_ALGOR_new(); if (!ret->algor) { wolfSSL_X509_PUBKEY_free(ret); return NULL; } return ret; } /** * Free WOLFSSL_X509_PUBKEY and all its members. * * @param at Object to free */ void wolfSSL_X509_PUBKEY_free(WOLFSSL_X509_PUBKEY *x) { if (x) { if (x->algor) { wolfSSL_X509_ALGOR_free(x->algor); } if (x->pkey) { wolfSSL_EVP_PKEY_free(x->pkey); } XFREE(x, NULL, DYNAMIC_TYPE_OPENSSL); } } /* Returns X509_PUBKEY structure containing X509_ALGOR and EVP_PKEY */ WOLFSSL_X509_PUBKEY* wolfSSL_X509_get_X509_PUBKEY(const WOLFSSL_X509* x509) { WOLFSSL_ENTER("X509_get_X509_PUBKEY"); if (x509 == NULL) { WOLFSSL_MSG("x509 struct NULL error"); return NULL; } return (WOLFSSL_X509_PUBKEY*)&x509->key; } /* Sets ppkalg pointer to X509_PUBKEY algorithm. Returns WOLFSSL_SUCCESS on success or WOLFSSL_FAILURE on error. */ int wolfSSL_X509_PUBKEY_get0_param(WOLFSSL_ASN1_OBJECT **ppkalg, const unsigned char **pk, int *ppklen, WOLFSSL_X509_ALGOR **pa, WOLFSSL_X509_PUBKEY *pub) { WOLFSSL_ENTER("X509_PUBKEY_get0_param"); if (!pub || !pub->pubKeyOID) { WOLFSSL_MSG("X509_PUBKEY struct not populated"); return WOLFSSL_FAILURE; } if (!pub->algor) { if (!(pub->algor = wolfSSL_X509_ALGOR_new())) { return WOLFSSL_FAILURE; } pub->algor->algorithm = wolfSSL_OBJ_nid2obj(pub->pubKeyOID); if (pub->algor->algorithm == NULL) { WOLFSSL_MSG("Failed to create object from NID"); return WOLFSSL_FAILURE; } } if (pa) *pa = pub->algor; if (ppkalg) *ppkalg = pub->algor->algorithm; if (pk) wolfSSL_EVP_PKEY_get_der(pub->pkey, (unsigned char **)pk); if (ppklen) *ppklen = wolfSSL_EVP_PKEY_get_der(pub->pkey, NULL); return WOLFSSL_SUCCESS; } /* Returns a pointer to the pkey when passed a key */ WOLFSSL_EVP_PKEY* wolfSSL_X509_PUBKEY_get(WOLFSSL_X509_PUBKEY* key) { WOLFSSL_ENTER("wolfSSL_X509_PUBKEY_get"); if(key == NULL || key->pkey == NULL){ WOLFSSL_LEAVE("wolfSSL_X509_PUBKEY_get", BAD_FUNC_ARG); return NULL; } WOLFSSL_LEAVE("wolfSSL_X509_PUBKEY_get", WOLFSSL_SUCCESS); return key->pkey; } int wolfSSL_X509_PUBKEY_set(WOLFSSL_X509_PUBKEY **x, WOLFSSL_EVP_PKEY *key) { WOLFSSL_X509_PUBKEY *pk = NULL; WOLFSSL_ENTER("wolfSSL_X509_PUBKEY_set"); if (!x || !key) { return WOLFSSL_FAILURE; } if (!(pk = wolfSSL_X509_PUBKEY_new())) { return WOLFSSL_FAILURE; } switch (key->type) { #ifndef NO_RSA case EVP_PKEY_RSA: pk->algor->algorithm= wolfSSL_OBJ_nid2obj(RSAk); break; #endif #ifndef NO_DSA case EVP_PKEY_DSA: pk->algor->algorithm = wolfSSL_OBJ_nid2obj(DSAk); break; #endif #ifdef HAVE_ECC case EVP_PKEY_EC: pk->algor->algorithm = wolfSSL_OBJ_nid2obj(ECDSAk); break; #endif default: WOLFSSL_MSG("Unknown key type"); goto error; } if (!pk->algor->algorithm) { WOLFSSL_MSG("Failed to create algorithm object"); goto error; } if (!wolfSSL_EVP_PKEY_up_ref(key)) { WOLFSSL_MSG("Failed to up key reference"); goto error; } pk->pkey = key; wolfSSL_X509_PUBKEY_free(*x); *x = pk; return WOLFSSL_SUCCESS; error: if (pk) { wolfSSL_X509_PUBKEY_free(pk); } return WOLFSSL_FAILURE; } #endif /* OPENSSL_ALL || WOLFSSL_APACHE_HTTPD || WOLFSSL_HAPROXY*/ #ifndef NO_WOLFSSL_STUB /*** TBD ***/ WOLFSSL_API WOLFSSL_EVP_PKEY *wolfSSL_get_privatekey(const WOLFSSL *ssl) { (void)ssl; WOLFSSL_STUB("SSL_get_privatekey"); return NULL; } #endif #ifndef NO_WOLFSSL_STUB /*** TBD ***/ WOLFSSL_API int i2t_ASN1_OBJECT(char *buf, int buf_len, WOLFSSL_ASN1_OBJECT *a) { (void)buf; (void)buf_len; (void)a; WOLFSSL_STUB("i2t_ASN1_OBJECT"); return -1; } #endif /* Return number of bytes written to BIO on success. 0 on failure. */ WOLFSSL_API int wolfSSL_i2a_ASN1_OBJECT(WOLFSSL_BIO *bp, WOLFSSL_ASN1_OBJECT *a) { int length = 0; word32 idx = 0; const char null_str[] = "NULL"; WOLFSSL_ENTER("wolfSSL_i2a_ASN1_OBJECT"); if (bp == NULL) return WOLFSSL_FAILURE; if (a == NULL) { /* Write "NULL" */ if (wolfSSL_BIO_write(bp, null_str, (int)XSTRLEN(null_str)) == (int)XSTRLEN(null_str)) { return (int)XSTRLEN(null_str); } else { return WOLFSSL_FAILURE; } } if ((a->obj == NULL) || (a->obj[idx++] != ASN_OBJECT_ID)) { WOLFSSL_MSG("Bad ASN1 Object"); return WOLFSSL_FAILURE; } if (GetLength((const byte*)a->obj, &idx, &length, a->objSz) < 0 || length < 0) { return WOLFSSL_FAILURE; } if (wolfSSL_BIO_write(bp, a->obj + idx, length) == (int)length) { return length; } return WOLFSSL_FAILURE; } #if defined(OPENSSL_ALL) || defined(WOLFSSL_HAPROXY) #ifndef NO_WOLFSSL_STUB /*** TBD ***/ WOLFSSL_API size_t SSL_get_finished(const WOLFSSL *s, void *buf, size_t count) { (void)s; (void)buf; (void)count; WOLFSSL_STUB("SSL_get_finished"); return WOLFSSL_FAILURE; } #endif #ifndef NO_WOLFSSL_STUB /*** TBD ***/ WOLFSSL_API size_t SSL_get_peer_finished(const WOLFSSL *s, void *buf, size_t count) { (void)s; (void)buf; (void)count; WOLFSSL_STUB("SSL_get_peer_finished"); return WOLFSSL_FAILURE; } #endif #endif /* WOLFSSL_HAPROXY */ #ifndef NO_WOLFSSL_STUB /*** TBD ***/ WOLFSSL_API void SSL_CTX_set_tmp_dh_callback(WOLFSSL_CTX *ctx, WOLFSSL_DH *(*dh) (WOLFSSL *ssl, int is_export, int keylength)) { (void)ctx; (void)dh; WOLFSSL_STUB("SSL_CTX_set_tmp_dh_callback"); } #endif #ifndef NO_WOLFSSL_STUB /*** TBD ***/ WOLFSSL_API WOLF_STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void) { WOLFSSL_STUB("SSL_COMP_get_compression_methods"); return NULL; } #endif int wolfSSL_sk_SSL_CIPHER_num(const WOLF_STACK_OF(WOLFSSL_CIPHER)* p) { WOLFSSL_ENTER("wolfSSL_sk_SSL_CIPHER_num"); if (p == NULL) { return WOLFSSL_FATAL_ERROR; } return (int)p->num; } #if !defined(NO_FILESYSTEM) #ifndef NO_WOLFSSL_STUB /*** TBD ***/ WOLFSSL_API WOLFSSL_EVP_PKEY *wolfSSL_PEM_read_PrivateKey(XFILE fp, WOLFSSL_EVP_PKEY **x, pem_password_cb *cb, void *u) { (void)fp; (void)x; (void)cb; (void)u; WOLFSSL_STUB("PEM_read_PrivateKey"); return NULL; } #endif #endif #if !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR) /* Loads certificate(s) files in pem format into X509_STORE struct from either * a file or directory. * Returns WOLFSSL_SUCCESS on success or WOLFSSL_FAILURE if an error occurs. */ WOLFSSL_API int wolfSSL_X509_STORE_load_locations(WOLFSSL_X509_STORE *str, const char *file, const char *dir) { WOLFSSL_CTX* ctx; char *name = NULL; int ret = WOLFSSL_SUCCESS; int successes = 0; #ifdef WOLFSSL_SMALL_STACK ReadDirCtx* readCtx = NULL; #else ReadDirCtx readCtx[1]; #endif WOLFSSL_ENTER("X509_STORE_load_locations"); if (str == NULL || str->cm == NULL || (file == NULL && dir == NULL)) return WOLFSSL_FAILURE; /* tmp ctx for setting our cert manager */ ctx = wolfSSL_CTX_new(cm_pick_method()); if (ctx == NULL) return WOLFSSL_FAILURE; wolfSSL_CertManagerFree(ctx->cm); ctx->cm = str->cm; #ifdef HAVE_CRL if (str->cm->crl == NULL) { if (wolfSSL_CertManagerEnableCRL(str->cm, 0) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Enable CRL failed"); wolfSSL_CTX_free(ctx); return WOLFSSL_FAILURE; } } #endif /* Load individual file */ if (file) { /* Try to process file with type DETECT_CERT_TYPE to parse the correct certificate header and footer type */ ret = ProcessFile(ctx, file, WOLFSSL_FILETYPE_PEM, DETECT_CERT_TYPE, NULL, 0, str->cm->crl, 0); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Failed to load file"); ret = WOLFSSL_FAILURE; } } /* Load files in dir */ if (dir && ret == WOLFSSL_SUCCESS) { #ifdef WOLFSSL_SMALL_STACK readCtx = (ReadDirCtx*)XMALLOC(sizeof(ReadDirCtx), ctx->heap, DYNAMIC_TYPE_TMP_BUFFER); if (readCtx == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } #endif /* try to load each regular file in dir */ ret = wc_ReadDirFirst(readCtx, dir, &name); while (ret == 0 && name) { WOLFSSL_MSG(name); /* Try to process file with type DETECT_CERT_TYPE to parse the correct certificate header and footer type */ ret = ProcessFile(ctx, name, WOLFSSL_FILETYPE_PEM, DETECT_CERT_TYPE, NULL, 0, str->cm->crl, 0); /* Not failing on load errors */ if (ret != WOLFSSL_SUCCESS) WOLFSSL_MSG("Failed to load file in path, continuing"); else successes++; ret = wc_ReadDirNext(readCtx, dir, &name); } wc_ReadDirClose(readCtx); /* Success if at least one file in dir was loaded */ if (successes > 0) ret = WOLFSSL_SUCCESS; else { WOLFSSL_ERROR(ret); ret = WOLFSSL_FAILURE; } #ifdef WOLFSSL_SMALL_STACK XFREE(readCtx, ctx->heap, DYNAMIC_TYPE_DIRCTX); #endif } ctx->cm = NULL; wolfSSL_CTX_free(ctx); return ret; } #endif /* !NO_FILESYSTEM && !NO_WOLFSSL_DIR */ #ifndef NO_WOLFSSL_STUB /*** TBD ***/ WOLFSSL_API WOLFSSL_CIPHER* wolfSSL_sk_SSL_CIPHER_value(void *ciphers, int idx) { (void)ciphers; (void)idx; WOLFSSL_STUB("wolfSSL_sk_SSL_CIPHER_value"); return NULL; } #endif WOLFSSL_API void ERR_load_SSL_strings(void) { } #ifdef HAVE_OCSP WOLFSSL_API long wolfSSL_get_tlsext_status_ocsp_resp(WOLFSSL *s, unsigned char **resp) { if (s == NULL || resp == NULL) return 0; *resp = s->ocspResp; return s->ocspRespSz; } WOLFSSL_API long wolfSSL_set_tlsext_status_ocsp_resp(WOLFSSL *s, unsigned char *resp, int len) { if (s == NULL) return WOLFSSL_FAILURE; s->ocspResp = resp; s->ocspRespSz = len; return WOLFSSL_SUCCESS; } #endif /* HAVE_OCSP */ #endif /* OPENSSL_EXTRA */ #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) long wolfSSL_get_verify_result(const WOLFSSL *ssl) { if (ssl == NULL) { return WOLFSSL_FAILURE; } return ssl->peerVerifyRet; } #endif #ifdef OPENSSL_EXTRA #ifndef NO_WOLFSSL_STUB /* shows the number of accepts attempted by CTX in it's lifetime */ long wolfSSL_CTX_sess_accept(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_accept"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB /* shows the number of connects attempted CTX in it's lifetime */ long wolfSSL_CTX_sess_connect(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_connect"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB /* shows the number of accepts completed by CTX in it's lifetime */ long wolfSSL_CTX_sess_accept_good(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_accept_good"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB /* shows the number of connects completed by CTX in it's lifetime */ long wolfSSL_CTX_sess_connect_good(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_connect_good"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB /* shows the number of renegotiation accepts attempted by CTX */ long wolfSSL_CTX_sess_accept_renegotiate(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_accept_renegotiate"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB /* shows the number of renegotiation accepts attempted by CTX */ long wolfSSL_CTX_sess_connect_renegotiate(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_connect_renegotiate"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB long wolfSSL_CTX_sess_hits(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_hits"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB long wolfSSL_CTX_sess_cb_hits(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_cb_hits"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB long wolfSSL_CTX_sess_cache_full(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_cache_full"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB long wolfSSL_CTX_sess_misses(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_misses"); (void)ctx; return 0; } #endif #ifndef NO_WOLFSSL_STUB long wolfSSL_CTX_sess_timeouts(WOLFSSL_CTX* ctx) { WOLFSSL_STUB("wolfSSL_CTX_sess_timeouts"); (void)ctx; return 0; } #endif /* Return the total number of sessions */ long wolfSSL_CTX_sess_number(WOLFSSL_CTX* ctx) { word32 total = 0; WOLFSSL_ENTER("wolfSSL_CTX_sess_number"); (void)ctx; #ifdef WOLFSSL_SESSION_STATS if (wolfSSL_get_session_stats(NULL, &total, NULL, NULL) != SSL_SUCCESS) { WOLFSSL_MSG("Error getting session stats"); } #else WOLFSSL_MSG("Please use macro WOLFSSL_SESSION_STATS for session stats"); #endif return (long)total; } #ifndef NO_CERTS long wolfSSL_CTX_add_extra_chain_cert(WOLFSSL_CTX* ctx, WOLFSSL_X509* x509) { byte* chain = NULL; long chainSz = 0; int derSz; const byte* der; int ret; int idx = 0; DerBuffer *derBuffer = NULL; WOLFSSL_ENTER("wolfSSL_CTX_add_extra_chain_cert"); if (ctx == NULL || x509 == NULL) { WOLFSSL_MSG("Bad Argument"); return WOLFSSL_FAILURE; } der = wolfSSL_X509_get_der(x509, &derSz); if (der == NULL || derSz <= 0) { WOLFSSL_MSG("Error getting X509 DER"); return WOLFSSL_FAILURE; } if (ctx->certificate == NULL) { WOLFSSL_ENTER("wolfSSL_use_certificate_chain_buffer_format"); /* Process buffer makes first certificate the leaf. */ ret = ProcessBuffer(ctx, der, derSz, WOLFSSL_FILETYPE_ASN1, CERT_TYPE, NULL, NULL, 1, GET_VERIFY_SETTING_CTX(ctx)); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_LEAVE("wolfSSL_CTX_add_extra_chain_cert", ret); return WOLFSSL_FAILURE; } } else { /* TODO: Do this elsewhere. */ ret = AllocDer(&derBuffer, derSz, CERT_TYPE, ctx->heap); if (ret != 0) { WOLFSSL_MSG("Memory Error"); return WOLFSSL_FAILURE; } XMEMCPY(derBuffer->buffer, der, derSz); ret = AddCA(ctx->cm, &derBuffer, WOLFSSL_USER_CA, GET_VERIFY_SETTING_CTX(ctx)); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_LEAVE("wolfSSL_CTX_add_extra_chain_cert", ret); return WOLFSSL_FAILURE; } /* adding cert to existing chain */ if (ctx->certChain != NULL && ctx->certChain->length > 0) { chainSz += ctx->certChain->length; } chainSz += OPAQUE24_LEN + derSz; chain = (byte*)XMALLOC(chainSz, ctx->heap, DYNAMIC_TYPE_DER); if (chain == NULL) { WOLFSSL_MSG("Memory Error"); return WOLFSSL_FAILURE; } if (ctx->certChain != NULL && ctx->certChain->length > 0) { XMEMCPY(chain, ctx->certChain->buffer, ctx->certChain->length); idx = ctx->certChain->length; } c32to24(derSz, chain + idx); idx += OPAQUE24_LEN, XMEMCPY(chain + idx, der, derSz); idx += derSz; #ifdef WOLFSSL_TLS13 ctx->certChainCnt++; #endif FreeDer(&ctx->certChain); ret = AllocDer(&ctx->certChain, idx, CERT_TYPE, ctx->heap); if (ret == 0) { XMEMCPY(ctx->certChain->buffer, chain, idx); } } /* on success WOLFSSL_X509 memory is responsibility of ctx */ wolfSSL_X509_free(x509); if (chain != NULL) XFREE(chain, ctx->heap, DYNAMIC_TYPE_DER); return WOLFSSL_SUCCESS; } long wolfSSL_CTX_set_tlsext_status_arg(WOLFSSL_CTX* ctx, void* arg) { if (ctx == NULL || ctx->cm == NULL) { return WOLFSSL_FAILURE; } ctx->cm->ocspIOCtx = arg; return WOLFSSL_SUCCESS; } #endif /* NO_CERTS */ /* Get the session cache mode for CTX * * ctx WOLFSSL_CTX struct to get cache mode from * * Returns a bit mask that has the session cache mode */ WOLFSSL_API long wolfSSL_CTX_get_session_cache_mode(WOLFSSL_CTX* ctx) { long m = 0; WOLFSSL_ENTER("SSL_CTX_set_session_cache_mode"); if (ctx == NULL) { return m; } if (ctx->sessionCacheOff != 1) { m |= SSL_SESS_CACHE_SERVER; } if (ctx->sessionCacheFlushOff == 1) { m |= SSL_SESS_CACHE_NO_AUTO_CLEAR; } #ifdef HAVE_EXT_CACHE if (ctx->internalCacheOff == 1) { m |= SSL_SESS_CACHE_NO_INTERNAL_STORE; } #endif return m; } int wolfSSL_CTX_get_read_ahead(WOLFSSL_CTX* ctx) { if (ctx == NULL) { return WOLFSSL_FAILURE; } return ctx->readAhead; } int wolfSSL_CTX_set_read_ahead(WOLFSSL_CTX* ctx, int v) { if (ctx == NULL) { return WOLFSSL_FAILURE; } ctx->readAhead = (byte)v; return WOLFSSL_SUCCESS; } long wolfSSL_CTX_set_tlsext_opaque_prf_input_callback_arg(WOLFSSL_CTX* ctx, void* arg) { if (ctx == NULL) { return WOLFSSL_FAILURE; } ctx->userPRFArg = arg; return WOLFSSL_SUCCESS; } #ifndef NO_DES3 /* 0 on success */ int wolfSSL_DES_set_key(WOLFSSL_const_DES_cblock* myDes, WOLFSSL_DES_key_schedule* key) { #ifdef WOLFSSL_CHECK_DESKEY return wolfSSL_DES_set_key_checked(myDes, key); #else wolfSSL_DES_set_key_unchecked(myDes, key); return 0; #endif } /* return true in fail case (1) */ static int DES_check(word32 mask, word32 mask2, unsigned char* key) { word32 value[2]; /* sanity check on length made in wolfSSL_DES_set_key_checked */ value[0] = mask; value[1] = mask2; return (XMEMCMP(value, key, sizeof(value)) == 0)? 1: 0; } /* check that the key is odd parity and is not a weak key * returns -1 if parity is wrong, -2 if weak/null key and 0 on success */ int wolfSSL_DES_set_key_checked(WOLFSSL_const_DES_cblock* myDes, WOLFSSL_DES_key_schedule* key) { if (myDes == NULL || key == NULL) { WOLFSSL_MSG("Bad argument passed to wolfSSL_DES_set_key_checked"); return -2; } else { word32 sz = sizeof(WOLFSSL_DES_key_schedule); /* sanity check before call to DES_check */ if (sz != (sizeof(word32) * 2)) { WOLFSSL_MSG("Unexpected WOLFSSL_DES_key_schedule size"); return -2; } /* check odd parity */ if (wolfSSL_DES_check_key_parity(myDes) != 1) { WOLFSSL_MSG("Odd parity test fail"); return -1; } if (wolfSSL_DES_is_weak_key(myDes) == 1) { WOLFSSL_MSG("Weak key found"); return -2; } /* passed tests, now copy over key */ XMEMCPY(key, myDes, sizeof(WOLFSSL_const_DES_cblock)); return 0; } } /* check is not weak. Weak key list from Nist "Recommendation for the Triple * Data Encryption Algorithm (TDEA) Block Cipher" * * returns 1 if is weak 0 if not */ int wolfSSL_DES_is_weak_key(WOLFSSL_const_DES_cblock* key) { word32 mask, mask2; WOLFSSL_ENTER("wolfSSL_DES_is_weak_key"); if (key == NULL) { WOLFSSL_MSG("NULL key passed in"); return 1; } mask = 0x01010101; mask2 = 0x01010101; if (DES_check(mask, mask2, *key)) { WOLFSSL_MSG("Weak key found"); return 1; } mask = 0xFEFEFEFE; mask2 = 0xFEFEFEFE; if (DES_check(mask, mask2, *key)) { WOLFSSL_MSG("Weak key found"); return 1; } mask = 0xE0E0E0E0; mask2 = 0xF1F1F1F1; if (DES_check(mask, mask2, *key)) { WOLFSSL_MSG("Weak key found"); return 1; } mask = 0x1F1F1F1F; mask2 = 0x0E0E0E0E; if (DES_check(mask, mask2, *key)) { WOLFSSL_MSG("Weak key found"); return 1; } /* semi-weak *key check (list from same Nist paper) */ mask = 0x011F011F; mask2 = 0x010E010E; if (DES_check(mask, mask2, *key) || DES_check(ByteReverseWord32(mask), ByteReverseWord32(mask2), *key)) { WOLFSSL_MSG("Weak key found"); return 1; } mask = 0x01E001E0; mask2 = 0x01F101F1; if (DES_check(mask, mask2, *key) || DES_check(ByteReverseWord32(mask), ByteReverseWord32(mask2), *key)) { WOLFSSL_MSG("Weak key found"); return 1; } mask = 0x01FE01FE; mask2 = 0x01FE01FE; if (DES_check(mask, mask2, *key) || DES_check(ByteReverseWord32(mask), ByteReverseWord32(mask2), *key)) { WOLFSSL_MSG("Weak key found"); return 1; } mask = 0x1FE01FE0; mask2 = 0x0EF10EF1; if (DES_check(mask, mask2, *key) || DES_check(ByteReverseWord32(mask), ByteReverseWord32(mask2), *key)) { WOLFSSL_MSG("Weak key found"); return 1; } mask = 0x1FFE1FFE; mask2 = 0x0EFE0EFE; if (DES_check(mask, mask2, *key) || DES_check(ByteReverseWord32(mask), ByteReverseWord32(mask2), *key)) { WOLFSSL_MSG("Weak key found"); return 1; } return 0; } void wolfSSL_DES_set_key_unchecked(WOLFSSL_const_DES_cblock* myDes, WOLFSSL_DES_key_schedule* key) { if (myDes != NULL && key != NULL) { XMEMCPY(key, myDes, sizeof(WOLFSSL_const_DES_cblock)); } } /* Sets the parity of the DES key for use */ void wolfSSL_DES_set_odd_parity(WOLFSSL_DES_cblock* myDes) { word32 i; word32 sz = sizeof(WOLFSSL_DES_cblock); WOLFSSL_ENTER("wolfSSL_DES_set_odd_parity"); for (i = 0; i < sz; i++) { unsigned char c = (*myDes)[i]; if (( ((c >> 1) & 0x01) ^ ((c >> 2) & 0x01) ^ ((c >> 3) & 0x01) ^ ((c >> 4) & 0x01) ^ ((c >> 5) & 0x01) ^ ((c >> 6) & 0x01) ^ ((c >> 7) & 0x01)) == (c & 0x01)) { WOLFSSL_MSG("Flipping parity bit"); (*myDes)[i] = c ^ 0x01; } } } int wolfSSL_DES_check_key_parity(WOLFSSL_DES_cblock *myDes) { word32 i; word32 sz = sizeof(WOLFSSL_DES_cblock); WOLFSSL_ENTER("wolfSSL_DES_check_key_parity"); for (i = 0; i < sz; i++) { unsigned char c = (*myDes)[i]; if (( ((c >> 1) & 0x01) ^ ((c >> 2) & 0x01) ^ ((c >> 3) & 0x01) ^ ((c >> 4) & 0x01) ^ ((c >> 5) & 0x01) ^ ((c >> 6) & 0x01) ^ ((c >> 7) & 0x01)) == (c & 0x01)) { return 0; } } return 1; } #ifdef WOLFSSL_DES_ECB /* Encrypt or decrypt input message desa with key and get output in desb. * if enc is DES_ENCRYPT,input message is encrypted or * if enc is DES_DECRYPT,input message is decrypted. * */ void wolfSSL_DES_ecb_encrypt(WOLFSSL_DES_cblock* desa, WOLFSSL_DES_cblock* desb, WOLFSSL_DES_key_schedule* key, int enc) { Des myDes; WOLFSSL_ENTER("wolfSSL_DES_ecb_encrypt"); if (desa == NULL || key == NULL || desb == NULL || (enc != DES_ENCRYPT && enc != DES_DECRYPT)) { WOLFSSL_MSG("Bad argument passed to wolfSSL_DES_ecb_encrypt"); } else { if (wc_Des_SetKey(&myDes, (const byte*) key, (const byte*) NULL, !enc) != 0) { WOLFSSL_MSG("wc_Des_SetKey return error."); return; } if (enc){ if (wc_Des_EcbEncrypt(&myDes, (byte*) desb, (const byte*) desa, sizeof(WOLFSSL_DES_cblock)) != 0){ WOLFSSL_MSG("wc_Des_EcbEncrypt return error."); } } else { if (wc_Des_EcbDecrypt(&myDes, (byte*) desb, (const byte*) desa, sizeof(WOLFSSL_DES_cblock)) != 0){ WOLFSSL_MSG("wc_Des_EcbDecrpyt return error."); } } } } #endif #endif /* NO_DES3 */ #ifndef NO_RC4 /* Set the key state for Arc4 structure. * * key Arc4 structure to use * len length of data buffer * data initial state to set Arc4 structure */ void wolfSSL_RC4_set_key(WOLFSSL_RC4_KEY* key, int len, const unsigned char* data) { typedef char rc4_test[sizeof(WOLFSSL_RC4_KEY) >= sizeof(Arc4) ? 1 : -1]; (void)sizeof(rc4_test); WOLFSSL_ENTER("wolfSSL_RC4_set_key"); if (key == NULL || len < 0) { WOLFSSL_MSG("bad argument passed in"); return; } XMEMSET(key, 0, sizeof(WOLFSSL_RC4_KEY)); wc_Arc4SetKey((Arc4*)key, data, (word32)len); } /* Encrypt/decrypt with Arc4 structure. * * len length of buffer to encrypt/decrypt (in/out) * in buffer to encrypt/decrypt * out results of encryption/decryption */ void wolfSSL_RC4(WOLFSSL_RC4_KEY* key, size_t len, const unsigned char* in, unsigned char* out) { WOLFSSL_ENTER("wolfSSL_RC4"); if (key == NULL || in == NULL || out == NULL) { WOLFSSL_MSG("Bad argument passed in"); return; } wc_Arc4Process((Arc4*)key, out, in, (word32)len); } #endif /* NO_RC4 */ #ifndef NO_AES #ifdef WOLFSSL_AES_DIRECT /* AES encrypt direct, it is expected to be blocks of AES_BLOCK_SIZE for input. * * input Data to encrypt * output Encrypted data after done * key AES key to use for encryption */ void wolfSSL_AES_encrypt(const unsigned char* input, unsigned char* output, AES_KEY *key) { WOLFSSL_ENTER("wolfSSL_AES_encrypt"); if (input == NULL || output == NULL || key == NULL) { WOLFSSL_MSG("Null argument passed in"); return; } wc_AesEncryptDirect((Aes*)key, output, input); } /* AES decrypt direct, it is expected to be blocks of AES_BLOCK_SIZE for input. * * input Data to decrypt * output Decrypted data after done * key AES key to use for encryption */ void wolfSSL_AES_decrypt(const unsigned char* input, unsigned char* output, AES_KEY *key) { WOLFSSL_ENTER("wolfSSL_AES_decrypt"); if (input == NULL || output == NULL || key == NULL) { WOLFSSL_MSG("Null argument passed in"); return; } wc_AesDecryptDirect((Aes*)key, output, input); } #endif /* WOLFSSL_AES_DIRECT */ /* Setup of an AES key to use for encryption. * * key key in bytes to use for encryption * bits size of key in bits * aes AES structure to initialize */ int wolfSSL_AES_set_encrypt_key(const unsigned char *key, const int bits, AES_KEY *aes) { typedef char aes_test[sizeof(AES_KEY) >= sizeof(Aes) ? 1 : -1]; (void)sizeof(aes_test); WOLFSSL_ENTER("wolfSSL_AES_set_encrypt_key"); if (key == NULL || aes == NULL) { WOLFSSL_MSG("Null argument passed in"); return -1; } XMEMSET(aes, 0, sizeof(AES_KEY)); if (wc_AesSetKey((Aes*)aes, key, ((bits)/8), NULL, AES_ENCRYPTION) != 0) { WOLFSSL_MSG("Error in setting AES key"); return -1; } return 0; } /* Setup of an AES key to use for decryption. * * key key in bytes to use for decryption * bits size of key in bits * aes AES structure to initialize */ int wolfSSL_AES_set_decrypt_key(const unsigned char *key, const int bits, AES_KEY *aes) { typedef char aes_test[sizeof(AES_KEY) >= sizeof(Aes) ? 1 : -1]; (void)sizeof(aes_test); WOLFSSL_ENTER("wolfSSL_AES_set_decrypt_key"); if (key == NULL || aes == NULL) { WOLFSSL_MSG("Null argument passed in"); return -1; } XMEMSET(aes, 0, sizeof(AES_KEY)); if (wc_AesSetKey((Aes*)aes, key, ((bits)/8), NULL, AES_DECRYPTION) != 0) { WOLFSSL_MSG("Error in setting AES key"); return -1; } return 0; } #ifdef HAVE_AES_ECB /* Encrypt/decrypt a 16 byte block of data using the key passed in. * * in buffer to encrypt/decrypt * out buffer to hold result of encryption/decryption * key AES structure to use with encryption/decryption * enc AES_ENCRPT for encryption and AES_DECRYPT for decryption */ void wolfSSL_AES_ecb_encrypt(const unsigned char *in, unsigned char* out, AES_KEY *key, const int enc) { Aes* aes; WOLFSSL_ENTER("wolfSSL_AES_ecb_encrypt"); if (key == NULL || in == NULL || out == NULL) { WOLFSSL_MSG("Error, Null argument passed in"); return; } aes = (Aes*)key; if (enc == AES_ENCRYPT) { if (wc_AesEcbEncrypt(aes, out, in, AES_BLOCK_SIZE) != 0) { WOLFSSL_MSG("Error with AES CBC encrypt"); } } else { #ifdef HAVE_AES_DECRYPT if (wc_AesEcbDecrypt(aes, out, in, AES_BLOCK_SIZE) != 0) { WOLFSSL_MSG("Error with AES CBC decrypt"); } #else WOLFSSL_MSG("AES decryption not compiled in"); #endif } } #endif /* HAVE_AES_ECB */ #ifdef HAVE_AES_CBC /* Encrypt data using key and iv passed in. iv gets updated to most recent iv * state after encryption/decryption. * * in buffer to encrypt/decrypt * out buffer to hold result of encryption/decryption * len length of input buffer * key AES structure to use with encryption/decryption * iv iv to use with operation * enc AES_ENCRPT for encryption and AES_DECRYPT for decryption */ void wolfSSL_AES_cbc_encrypt(const unsigned char *in, unsigned char* out, size_t len, AES_KEY *key, unsigned char* iv, const int enc) { Aes* aes; WOLFSSL_ENTER("wolfSSL_AES_cbc_encrypt"); if (key == NULL || in == NULL || out == NULL || iv == NULL || len == 0) { WOLFSSL_MSG("Error, Null argument passed in"); return; } aes = (Aes*)key; if (wc_AesSetIV(aes, (const byte*)iv) != 0) { WOLFSSL_MSG("Error with setting iv"); return; } if (enc == AES_ENCRYPT) { if (wc_AesCbcEncrypt(aes, out, in, (word32)len) != 0) { WOLFSSL_MSG("Error with AES CBC encrypt"); } } else { if (wc_AesCbcDecrypt(aes, out, in, (word32)len) != 0) { WOLFSSL_MSG("Error with AES CBC decrypt"); } } /* to be compatible copy iv to iv buffer after completing operation */ XMEMCPY(iv, (byte*)(aes->reg), AES_BLOCK_SIZE); } #endif /* HAVE_AES_CBC */ /* Encrypt data using CFB mode with key and iv passed in. iv gets updated to * most recent iv state after encryption/decryption. * * in buffer to encrypt/decrypt * out buffer to hold result of encryption/decryption * len length of input buffer * key AES structure to use with encryption/decryption * iv iv to use with operation * num contains the amount of block used * enc AES_ENCRPT for encryption and AES_DECRYPT for decryption */ void wolfSSL_AES_cfb128_encrypt(const unsigned char *in, unsigned char* out, size_t len, AES_KEY *key, unsigned char* iv, int* num, const int enc) { #ifndef WOLFSSL_AES_CFB WOLFSSL_MSG("CFB mode not enabled please use macro WOLFSSL_AES_CFB"); (void)in; (void)out; (void)len; (void)key; (void)iv; (void)num; (void)enc; return; #else Aes* aes; WOLFSSL_ENTER("wolfSSL_AES_cbc_encrypt"); if (key == NULL || in == NULL || out == NULL || iv == NULL) { WOLFSSL_MSG("Error, Null argument passed in"); return; } aes = (Aes*)key; if (wc_AesSetIV(aes, (const byte*)iv) != 0) { WOLFSSL_MSG("Error with setting iv"); return; } if (enc == AES_ENCRYPT) { if (wc_AesCfbEncrypt(aes, out, in, (word32)len) != 0) { WOLFSSL_MSG("Error with AES CBC encrypt"); } } else { if (wc_AesCfbDecrypt(aes, out, in, (word32)len) != 0) { WOLFSSL_MSG("Error with AES CBC decrypt"); } } /* to be compatible copy iv to iv buffer after completing operation */ XMEMCPY(iv, (byte*)(aes->reg), AES_BLOCK_SIZE); /* store number of left over bytes to num */ *num = (aes->left)? AES_BLOCK_SIZE - aes->left : 0; #endif /* WOLFSSL_AES_CFB */ } #endif /* NO_AES */ #ifndef NO_FILESYSTEM #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wformat-nonliteral" #endif #endif #if !defined(NO_FILESYSTEM) && defined (OPENSSL_EXTRA) /* returns amount printed on success, negative in fail case */ int wolfSSL_BIO_vprintf(WOLFSSL_BIO* bio, const char* format, va_list args) { int ret = -1; if (bio == NULL) return WOLFSSL_FATAL_ERROR; switch (bio->type) { case WOLFSSL_BIO_FILE: if (bio->ptr == NULL) { va_end(args); return -1; } ret = vfprintf((XFILE)bio->ptr, format, args); break; case WOLFSSL_BIO_MEMORY: #if defined(OPENSSL_EXTRA) && !defined(_WIN32) case WOLFSSL_BIO_SSL: { int count; char* pt = NULL; va_list copy; va_copy(copy, args); count = vsnprintf(NULL, 0, format, args); if (count >= 0) { pt = (char*)XMALLOC(count + 1, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (pt != NULL) { count = vsnprintf(pt, count + 1, format, copy); if (count >= 0) { ret = wolfSSL_BIO_write(bio, pt, count); } XFREE(pt, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); } } va_end(copy); } break; #endif default: WOLFSSL_MSG("Unsupported WOLFSSL_BIO type for wolfSSL_BIO_printf"); break; } return ret; } /* returns amount printed on success, negative in fail case */ int wolfSSL_BIO_printf(WOLFSSL_BIO* bio, const char* format, ...) { int ret; va_list args; va_start(args, format); ret = wolfSSL_BIO_vprintf(bio, format, args); va_end(args); return ret; } #endif /* !defined(NO_FILESYSTEM) && defined (OPENSSL_EXTRA) */ #if !defined(NO_FILESYSTEM) && defined(__clang__) #pragma clang diagnostic pop #endif #undef LINE_LEN #define LINE_LEN 16 int wolfSSL_BIO_dump(WOLFSSL_BIO *bio, const char *buf, int length) { int ret = 0; if (bio == NULL) return 0; #ifndef NO_FILESYSTEM if (bio->type == WOLFSSL_BIO_FILE) { int i; char line[80]; if (!buf) { return fputs("\tNULL", (XFILE)bio->ptr); } sprintf(line, "\t"); for (i = 0; i < LINE_LEN; i++) { if (i < length) sprintf(line + 1 + i * 3,"%02x ", buf[i]); else sprintf(line + 1 + i * 3, " "); } sprintf(line + 1 + LINE_LEN * 3, "| "); for (i = 0; i < LINE_LEN; i++) { if (i < length) { sprintf(line + 3 + LINE_LEN * 3 + i, "%c", 31 < buf[i] && buf[i] < 127 ? buf[i] : '.'); } } ret += fputs(line, (XFILE)bio->ptr); if (length > LINE_LEN) ret += wolfSSL_BIO_dump(bio, buf + LINE_LEN, length - LINE_LEN); } #else (void)buf; (void)length; #endif return ret; } #ifndef NO_ASN_TIME int wolfSSL_ASN1_UTCTIME_print(WOLFSSL_BIO* bio, const WOLFSSL_ASN1_UTCTIME* a) { WOLFSSL_ENTER("ASN1_UTCTIME_print"); if (bio == NULL || a == NULL) { return WOLFSSL_FAILURE; } if (a->type != ASN_UTC_TIME) { WOLFSSL_MSG("Error, not UTC_TIME"); return WOLFSSL_FAILURE; } return wolfSSL_ASN1_TIME_print(bio, a); } /* Checks the ASN1 syntax of "a" * returns WOLFSSL_SUCCESS (1) if correct otherwise WOLFSSL_FAILURE (0) */ int wolfSSL_ASN1_TIME_check(const WOLFSSL_ASN1_TIME* a) { char buf[MAX_TIME_STRING_SZ]; WOLFSSL_ENTER("wolfSSL_ASN1_TIME_check"); /* if can parse the WOLFSSL_ASN1_TIME passed in then consider syntax good */ if (wolfSSL_ASN1_TIME_to_string((WOLFSSL_ASN1_TIME*)a, buf, MAX_TIME_STRING_SZ) == NULL) { return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #endif /* !NO_ASN_TIME */ #ifndef NO_WOLFSSL_STUB int wolfSSL_ASN1_TIME_diff(int *pday, int *psec, const WOLFSSL_ASN1_TIME *from, const WOLFSSL_ASN1_TIME *to) { WOLFSSL_STUB("wolfSSL_ASN1_TIME_diff"); (void)pday; (void)psec; (void)from; (void)to; return 0; } WOLFSSL_API WOLFSSL_ASN1_TIME *wolfSSL_ASN1_TIME_set(WOLFSSL_ASN1_TIME *s, time_t t) { WOLFSSL_STUB("wolfSSL_ASN1_TIME_set"); (void)s; (void)t; return s; } #endif /* !NO_WOLFSSL_STUB */ /* Return the month as a string. * * n The number of the month as a two characters (1 based). * returns the month as a string. */ static WC_INLINE const char* MonthStr(const char* n) { static const char monthStr[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; return monthStr[(n[0] - '0') * 10 + (n[1] - '0') - 1]; } int wolfSSL_ASN1_GENERALIZEDTIME_print(WOLFSSL_BIO* bio, const WOLFSSL_ASN1_GENERALIZEDTIME* asnTime) { const char* p; WOLFSSL_ENTER("wolfSSL_ASN1_GENERALIZEDTIME_print"); if (bio == NULL || asnTime == NULL) return BAD_FUNC_ARG; if (asnTime->type != ASN_GENERALIZED_TIME) { WOLFSSL_MSG("Error, not GENERALIZED_TIME"); return WOLFSSL_FAILURE; } p = (const char *)(asnTime->data); /* GetTimeString not always available. */ wolfSSL_BIO_write(bio, MonthStr(p + 4), 3); wolfSSL_BIO_write(bio, " ", 1); /* Day */ wolfSSL_BIO_write(bio, p + 6, 2); wolfSSL_BIO_write(bio, " ", 1); /* Hour */ wolfSSL_BIO_write(bio, p + 8, 2); wolfSSL_BIO_write(bio, ":", 1); /* Min */ wolfSSL_BIO_write(bio, p + 10, 2); wolfSSL_BIO_write(bio, ":", 1); /* Secs */ wolfSSL_BIO_write(bio, p + 12, 2); wolfSSL_BIO_write(bio, " ", 1); wolfSSL_BIO_write(bio, p, 4); return 0; } void wolfSSL_ASN1_GENERALIZEDTIME_free(WOLFSSL_ASN1_TIME* asn1Time) { WOLFSSL_ENTER("wolfSSL_ASN1_GENERALIZEDTIME_free"); if (asn1Time == NULL) return; XMEMSET(asn1Time->data, 0, sizeof(asn1Time->data)); } int wolfSSL_sk_num(WOLFSSL_STACK* sk) { WOLFSSL_ENTER("wolfSSL_sk_num"); if (sk == NULL) return 0; return (int)sk->num; } void* wolfSSL_sk_value(WOLFSSL_STACK* sk, int i) { #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) int offset = i; #endif WOLFSSL_ENTER("wolfSSL_sk_value"); for (; sk != NULL && i > 0; i--) sk = sk->next; if (sk == NULL) return NULL; switch (sk->type) { case STACK_TYPE_X509: return (void*)sk->data.x509; case STACK_TYPE_CIPHER: #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) sk->data.cipher.offset = offset; #endif return (void*)&sk->data.cipher; case STACK_TYPE_GEN_NAME: return (void*)sk->data.gn; case STACK_TYPE_ACCESS_DESCRIPTION: return (void*)sk->data.access; case STACK_TYPE_OBJ: return (void*)sk->data.obj; case STACK_TYPE_X509_EXT: return (void*)sk->data.ext; case STACK_TYPE_CONF_VALUE: return (void*)sk->data.conf->value; case STACK_TYPE_NULL: default: return (void*)sk->data.generic; } } /* Free the structure for ASN1_OBJECT stack */ void wolfSSL_sk_free(WOLFSSL_STACK* sk) { WOLFSSL_ENTER("wolfSSL_sk_free"); if (sk == NULL) { WOLFSSL_MSG("Error, BAD_FUNC_ARG"); return; } switch (sk->type) { case STACK_TYPE_X509: wolfSSL_sk_X509_free(sk); break; #if defined(OPENSSL_ALL) case STACK_TYPE_CIPHER: wolfSSL_sk_CIPHER_free(sk); break; #endif case STACK_TYPE_GEN_NAME: wolfSSL_sk_GENERAL_NAME_free(sk); break; #if defined(OPENSSL_ALL) || defined (WOLFSSL_QT) case STACK_TYPE_ACCESS_DESCRIPTION: wolfSSL_sk_ACCESS_DESCRIPTION_free(sk); break; #endif case STACK_TYPE_OBJ: wolfSSL_sk_ASN1_OBJECT_free(sk); break; #ifdef OPENSSL_ALL case STACK_TYPE_X509_INFO: wolfSSL_sk_X509_INFO_free(sk); break; case STACK_TYPE_X509_NAME: wolfSSL_sk_X509_NAME_free(sk); break; case STACK_TYPE_CONF_VALUE: wolfSSL_sk_CONF_VALUE_free(sk); break; #endif case STACK_TYPE_NULL: default: wolfSSL_sk_GENERIC_free(sk); } } /* Frees each node in the stack and frees the stack. * Does not free any internal members of the stack nodes. */ void wolfSSL_sk_GENERIC_pop_free(WOLFSSL_STACK* sk, void (*f) (void*)) { WOLFSSL_STACK* node; WOLFSSL_STACK* tmp; WOLFSSL_ENTER("wolfSSL_sk_GENERIC_pop_free"); if (sk == NULL) return; /* parse through stack freeing each node */ node = sk->next; while (node) { tmp = node; node = node->next; if (f) f(tmp->data.generic); tmp->data.generic = NULL; XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL); } /* free head of stack */ XFREE(sk, NULL, DYNAMIC_TYPE_ASN1); } /* return 1 on success 0 on fail */ int wolfSSL_sk_GENERIC_push(WOLFSSL_STACK* sk, void* generic) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_GENERIC_push"); if (sk == NULL || generic == NULL) { return WOLFSSL_FAILURE; } /* no previous values in stack */ if (sk->data.generic == NULL) { sk->data.generic = generic; sk->num += 1; return WOLFSSL_SUCCESS; } /* stack already has value(s) create a new node and add more */ node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK),NULL,DYNAMIC_TYPE_SSL); if (node == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } XMEMSET(node, 0, sizeof(WOLFSSL_STACK)); /* push new node onto head of stack */ node->type = sk->type; node->data.generic = sk->data.generic; node->next = sk->next; sk->next = node; sk->data.generic = generic; sk->num += 1; return WOLFSSL_SUCCESS; } void wolfSSL_sk_GENERIC_free(WOLFSSL_STACK* sk) { wolfSSL_sk_GENERIC_pop_free(sk, NULL); } /* Free all nodes in a stack */ void wolfSSL_sk_pop_free(WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)* sk, wolfSSL_sk_freefunc func) { WOLFSSL_ENTER("wolfSSL_sk_pop_free"); if (sk == NULL) { WOLFSSL_MSG("Error, BAD_FUNC_ARG"); return; } switch(sk->type) { #if defined(OPENSSL_ALL) || defined (WOLFSSL_QT) case STACK_TYPE_ACCESS_DESCRIPTION: wolfSSL_sk_ACCESS_DESCRIPTION_pop_free(sk, wolfSSL_ACCESS_DESCRIPTION_free); break; #endif case STACK_TYPE_X509: wolfSSL_sk_X509_pop_free(sk,(void (*)(WOLFSSL_X509*))func); break; case STACK_TYPE_OBJ: wolfSSL_sk_ASN1_OBJECT_pop_free(sk, (void (*)(WOLFSSL_ASN1_OBJECT*))func); break; case STACK_TYPE_GEN_NAME: wolfSSL_sk_GENERAL_NAME_pop_free(sk, (void (*)(WOLFSSL_GENERAL_NAME*))func); break; #ifdef OPENSSL_ALL case STACK_TYPE_X509_NAME: wolfSSL_sk_X509_NAME_pop_free(sk, (void (*)(WOLFSSL_X509_NAME*))func); break; case STACK_TYPE_X509_EXT: wolfSSL_sk_X509_EXTENSION_pop_free(sk, (void (*)(WOLFSSL_X509_EXTENSION*))func); break; #endif #if defined(OPENSSL_ALL) case STACK_TYPE_X509_INFO: wolfSSL_sk_X509_INFO_pop_free(sk, (void (*)(WOLFSSL_X509_INFO*))func); break; #endif default: wolfSSL_sk_GENERIC_pop_free(sk, (void (*)(void*))func); break; } } #if defined(OPENSSL_ALL) /* Free the structure for WOLFSSL_CONF_VALUE stack * * sk stack to free nodes in */ void wolfSSL_sk_CONF_VALUE_free(WOLF_STACK_OF(WOLFSSL_CONF_VALUE)* sk) { WOLFSSL_STACK* node; WOLFSSL_STACK* tmp; WOLFSSL_ENTER("wolfSSL_sk_CONF_VALUE_free"); if (sk == NULL) return; /* parse through stack freeing each node */ node = sk->next; while (node) { tmp = node; node = node->next; XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL); } /* free head of stack */ XFREE(sk, NULL, DYNAMIC_TYPE_ASN1); } #endif /* Creates and returns a new null stack. */ WOLFSSL_STACK* wolfSSL_sk_new_null(void) { WOLFSSL_STACK* sk; WOLFSSL_ENTER("wolfSSL_sk_new_null"); sk = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_OPENSSL); if (sk == NULL) { WOLFSSL_MSG("WOLFSSL_STACK memory error"); return NULL; } XMEMSET(sk, 0, sizeof(WOLFSSL_STACK)); sk->type = STACK_TYPE_NULL; return sk; } /* frees the wolfSSL_BASIC_CONSTRAINTS object */ void wolfSSL_BASIC_CONSTRAINTS_free(WOLFSSL_BASIC_CONSTRAINTS *bc) { WOLFSSL_ENTER("wolfSSL_BASIC_CONSTRAINTS_free"); if (bc == NULL) { WOLFSSL_MSG("Argument is NULL"); return; } if (bc->pathlen) { wolfSSL_ASN1_INTEGER_free(bc->pathlen); } XFREE(bc, NULL, DYNAMIC_TYPE_OPENSSL); } /* frees the wolfSSL_AUTHORITY_KEYID object */ void wolfSSL_AUTHORITY_KEYID_free(WOLFSSL_AUTHORITY_KEYID *id) { WOLFSSL_ENTER("wolfSSL_AUTHORITY_KEYID_free"); if(id == NULL) { WOLFSSL_MSG("Argument is NULL"); return; } if (id->keyid) { wolfSSL_ASN1_STRING_free(id->keyid); } if (id->issuer) { wolfSSL_ASN1_OBJECT_free(id->issuer); } if (id->serial) { wolfSSL_ASN1_INTEGER_free(id->serial); } XFREE(id, NULL, DYNAMIC_TYPE_OPENSSL); } int wolfSSL_sk_SSL_COMP_num(WOLF_STACK_OF(WOLFSSL_COMP)* sk) { if (sk == NULL) return 0; return (int)sk->num; } #endif /* OPENSSL_EXTRA */ #if defined(OPENSSL_EXTRA) || defined(HAVE_EXT_CACHE) /* stunnel 4.28 needs * * Callback that is called if a session tries to resume but could not find * the session to resume it. */ void wolfSSL_CTX_sess_set_get_cb(WOLFSSL_CTX* ctx, WOLFSSL_SESSION*(*f)(WOLFSSL*, unsigned char*, int, int*)) { if (ctx == NULL) return; #ifdef HAVE_EXT_CACHE ctx->get_sess_cb = f; #else (void)f; #endif } void wolfSSL_CTX_sess_set_new_cb(WOLFSSL_CTX* ctx, int (*f)(WOLFSSL*, WOLFSSL_SESSION*)) { if (ctx == NULL) return; #ifdef HAVE_EXT_CACHE ctx->new_sess_cb = f; #else (void)f; #endif } void wolfSSL_CTX_sess_set_remove_cb(WOLFSSL_CTX* ctx, void (*f)(WOLFSSL_CTX*, WOLFSSL_SESSION*)) { if (ctx == NULL) return; #ifdef HAVE_EXT_CACHE ctx->rem_sess_cb = f; #else (void)f; #endif } #endif /* OPENSSL_EXTRA || HAVE_EXT_CACHE */ #ifdef OPENSSL_EXTRA /* * * Note: It is expected that the importing and exporting function have been * built with the same settings. For example if session tickets was * enabled with the wolfSSL library exporting a session then it is * expected to be turned on with the wolfSSL library importing the session. */ int wolfSSL_i2d_SSL_SESSION(WOLFSSL_SESSION* sess, unsigned char** p) { int size = 0; #ifdef HAVE_EXT_CACHE int idx = 0; #ifdef SESSION_CERTS int i; #endif unsigned char *data; if (sess == NULL) { return BAD_FUNC_ARG; } /* bornOn | timeout | sessionID len | sessionID | masterSecret | haveEMS */ size += OPAQUE32_LEN + OPAQUE32_LEN + OPAQUE8_LEN + sess->sessionIDSz + SECRET_LEN + OPAQUE8_LEN; #ifdef SESSION_CERTS /* Peer chain */ size += OPAQUE8_LEN; for (i = 0; i < sess->chain.count; i++) size += OPAQUE16_LEN + sess->chain.certs[i].length; #endif #if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \ defined(HAVE_SESSION_TICKET)) /* Protocol version */ size += OPAQUE16_LEN; #endif #if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \ (defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)) /* cipher suite */ size += OPAQUE16_LEN; #endif #ifndef NO_CLIENT_CACHE /* ServerID len | ServerID */ size += OPAQUE16_LEN + sess->idLen; #endif #ifdef OPENSSL_EXTRA /* session context ID len | session context ID */ size += OPAQUE8_LEN + sess->sessionCtxSz; #endif #ifdef WOLFSSL_TLS13 /* namedGroup */ size += OPAQUE16_LEN; #endif #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK) #ifdef WOLFSSL_TLS13 /* ticketSeen | ticketAdd */ size += OPAQUE32_LEN + OPAQUE32_LEN; #ifndef WOLFSSL_TLS13_DRAFT_18 /* ticketNonce */ size += OPAQUE8_LEN + sess->ticketNonce.len; #endif #endif #ifdef WOLFSSL_EARLY_DATA size += OPAQUE32_LEN; #endif #endif #ifdef HAVE_SESSION_TICKET /* ticket len | ticket */ size += OPAQUE16_LEN + sess->ticketLen; #endif if (p != NULL) { if (*p == NULL) *p = (unsigned char*)XMALLOC(size, NULL, DYNAMIC_TYPE_OPENSSL); if (*p == NULL) return 0; data = *p; c32toa(sess->bornOn, data + idx); idx += OPAQUE32_LEN; c32toa(sess->timeout, data + idx); idx += OPAQUE32_LEN; data[idx++] = sess->sessionIDSz; XMEMCPY(data + idx, sess->sessionID, sess->sessionIDSz); idx += sess->sessionIDSz; XMEMCPY(data + idx, sess->masterSecret, SECRET_LEN); idx += SECRET_LEN; data[idx++] = (byte)sess->haveEMS; #ifdef SESSION_CERTS data[idx++] = (byte)sess->chain.count; for (i = 0; i < sess->chain.count; i++) { c16toa((word16)sess->chain.certs[i].length, data + idx); idx += OPAQUE16_LEN; XMEMCPY(data + idx, sess->chain.certs[i].buffer, sess->chain.certs[i].length); idx += sess->chain.certs[i].length; } #endif #if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \ defined(HAVE_SESSION_TICKET)) data[idx++] = sess->version.major; data[idx++] = sess->version.minor; #endif #if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \ (defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)) data[idx++] = sess->cipherSuite0; data[idx++] = sess->cipherSuite; #endif #ifndef NO_CLIENT_CACHE c16toa(sess->idLen, data + idx); idx += OPAQUE16_LEN; XMEMCPY(data + idx, sess->serverID, sess->idLen); idx += sess->idLen; #endif #ifdef OPENSSL_EXTRA data[idx++] = sess->sessionCtxSz; XMEMCPY(data + idx, sess->sessionCtx, sess->sessionCtxSz); idx += sess->sessionCtxSz; #endif #ifdef WOLFSSL_TLS13 c16toa(sess->namedGroup, data + idx); idx += OPAQUE16_LEN; #endif #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK) #ifdef WOLFSSL_TLS13 c32toa(sess->ticketSeen, data + idx); idx += OPAQUE32_LEN; c32toa(sess->ticketAdd, data + idx); idx += OPAQUE32_LEN; #ifndef WOLFSSL_TLS13_DRAFT_18 data[idx++] = sess->ticketNonce.len; XMEMCPY(data + idx, sess->ticketNonce.data, sess->ticketNonce.len); idx += sess->ticketNonce.len; #endif #endif #ifdef WOLFSSL_EARLY_DATA c32toa(sess->maxEarlyDataSz, data + idx); idx += OPAQUE32_LEN; #endif #endif #ifdef HAVE_SESSION_TICKET c16toa(sess->ticketLen, data + idx); idx += OPAQUE16_LEN; XMEMCPY(data + idx, sess->ticket, sess->ticketLen); idx += sess->ticketLen; #endif } #endif (void)sess; (void)p; #ifdef HAVE_EXT_CACHE (void)idx; #endif return size; } /* TODO: no function to free new session. * * Note: It is expected that the importing and exporting function have been * built with the same settings. For example if session tickets was * enabled with the wolfSSL library exporting a session then it is * expected to be turned on with the wolfSSL library importing the session. */ WOLFSSL_SESSION* wolfSSL_d2i_SSL_SESSION(WOLFSSL_SESSION** sess, const unsigned char** p, long i) { WOLFSSL_SESSION* s = NULL; int ret = 0; #if defined(HAVE_EXT_CACHE) int idx; byte* data; #ifdef SESSION_CERTS int j; word16 length; #endif #endif (void)p; (void)i; (void)ret; if (sess != NULL) s = *sess; #ifdef HAVE_EXT_CACHE if (p == NULL || *p == NULL) return NULL; if (s == NULL) { s = (WOLFSSL_SESSION*)XMALLOC(sizeof(WOLFSSL_SESSION), NULL, DYNAMIC_TYPE_OPENSSL); if (s == NULL) return NULL; XMEMSET(s, 0, sizeof(WOLFSSL_SESSION)); s->isAlloced = 1; #ifdef HAVE_SESSION_TICKET s->isDynamic = 0; #endif } idx = 0; data = (byte*)*p; /* bornOn | timeout | sessionID len */ if (i < OPAQUE32_LEN + OPAQUE32_LEN + OPAQUE8_LEN) { ret = BUFFER_ERROR; goto end; } ato32(data + idx, &s->bornOn); idx += OPAQUE32_LEN; ato32(data + idx, &s->timeout); idx += OPAQUE32_LEN; s->sessionIDSz = data[idx++]; /* sessionID | secret | haveEMS */ if (i - idx < s->sessionIDSz + SECRET_LEN + OPAQUE8_LEN) { ret = BUFFER_ERROR; goto end; } XMEMCPY(s->sessionID, data + idx, s->sessionIDSz); idx += s->sessionIDSz; XMEMCPY(s->masterSecret, data + idx, SECRET_LEN); idx += SECRET_LEN; s->haveEMS = data[idx++]; #ifdef SESSION_CERTS /* Certificate chain */ if (i - idx == 0) { ret = BUFFER_ERROR; goto end; } s->chain.count = data[idx++]; for (j = 0; j < s->chain.count; j++) { if (i - idx < OPAQUE16_LEN) { ret = BUFFER_ERROR; goto end; } ato16(data + idx, &length); idx += OPAQUE16_LEN; s->chain.certs[j].length = length; if (i - idx < length) { ret = BUFFER_ERROR; goto end; } XMEMCPY(s->chain.certs[j].buffer, data + idx, length); idx += length; } #endif #if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \ defined(HAVE_SESSION_TICKET)) /* Protocol Version */ if (i - idx < OPAQUE16_LEN) { ret = BUFFER_ERROR; goto end; } s->version.major = data[idx++]; s->version.minor = data[idx++]; #endif #if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \ (defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)) /* Cipher suite */ if (i - idx < OPAQUE16_LEN) { ret = BUFFER_ERROR; goto end; } s->cipherSuite0 = data[idx++]; s->cipherSuite = data[idx++]; #endif #ifndef NO_CLIENT_CACHE /* ServerID len */ if (i - idx < OPAQUE16_LEN) { ret = BUFFER_ERROR; goto end; } ato16(data + idx, &s->idLen); idx += OPAQUE16_LEN; /* ServerID */ if (i - idx < s->idLen) { ret = BUFFER_ERROR; goto end; } XMEMCPY(s->serverID, data + idx, s->idLen); idx += s->idLen; #endif #ifdef OPENSSL_EXTRA /* byte for length of session context ID */ if (i - idx < OPAQUE8_LEN) { ret = BUFFER_ERROR; goto end; } s->sessionCtxSz = data[idx++]; /* app session context ID */ if (i - idx < s->sessionCtxSz) { ret = BUFFER_ERROR; goto end; } XMEMCPY(s->sessionCtx, data + idx, s->sessionCtxSz); idx += s->sessionCtxSz; #endif #ifdef WOLFSSL_TLS13 if (i - idx < OPAQUE16_LEN) { ret = BUFFER_ERROR; goto end; } ato16(data + idx, &s->namedGroup); idx += OPAQUE16_LEN; #endif #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK) #ifdef WOLFSSL_TLS13 if (i - idx < (OPAQUE32_LEN * 2)) { ret = BUFFER_ERROR; goto end; } ato32(data + idx, &s->ticketSeen); idx += OPAQUE32_LEN; ato32(data + idx, &s->ticketAdd); idx += OPAQUE32_LEN; #ifndef WOLFSSL_TLS13_DRAFT_18 if (i - idx < OPAQUE8_LEN) { ret = BUFFER_ERROR; goto end; } s->ticketNonce.len = data[idx++]; if (i - idx < s->ticketNonce.len) { ret = BUFFER_ERROR; goto end; } XMEMCPY(s->ticketNonce.data, data + idx, s->ticketNonce.len); idx += s->ticketNonce.len; #endif #endif #ifdef WOLFSSL_EARLY_DATA if (i - idx < OPAQUE32_LEN) { ret = BUFFER_ERROR; goto end; } ato32(data + idx, &s->maxEarlyDataSz); idx += OPAQUE32_LEN; #endif #endif #ifdef HAVE_SESSION_TICKET /* ticket len */ if (i - idx < OPAQUE16_LEN) { ret = BUFFER_ERROR; goto end; } ato16(data + idx, &s->ticketLen); idx += OPAQUE16_LEN; /* Dispose of ol dynamic ticket and ensure space for new ticket. */ if (s->isDynamic) XFREE(s->ticket, NULL, DYNAMIC_TYPE_SESSION_TICK); if (s->ticketLen <= SESSION_TICKET_LEN) s->ticket = s->staticTicket; else { s->ticket = (byte*)XMALLOC(s->ticketLen, NULL, DYNAMIC_TYPE_SESSION_TICK); if (s->ticket == NULL) { ret = MEMORY_ERROR; goto end; } s->isDynamic = 1; } /* ticket */ if (i - idx < s->ticketLen) { ret = BUFFER_ERROR; goto end; } XMEMCPY(s->ticket, data + idx, s->ticketLen); idx += s->ticketLen; #endif (void)idx; if (sess != NULL) *sess = s; *p += idx; end: if (ret != 0 && (sess == NULL || *sess != s)) wolfSSL_SESSION_free(s); #endif return s; } long wolfSSL_SESSION_get_timeout(const WOLFSSL_SESSION* sess) { long timeout = 0; WOLFSSL_ENTER("wolfSSL_SESSION_get_timeout"); if (sess) timeout = sess->timeout; return timeout; } long wolfSSL_SESSION_get_time(const WOLFSSL_SESSION* sess) { long bornOn = 0; WOLFSSL_ENTER("wolfSSL_SESSION_get_time"); if (sess) bornOn = sess->bornOn; return bornOn; } #endif /* OPENSSL_EXTRA */ #ifdef KEEP_PEER_CERT char* wolfSSL_X509_get_subjectCN(WOLFSSL_X509* x509) { if (x509 == NULL) return NULL; return x509->subjectCN; } #endif /* KEEP_PEER_CERT */ #ifdef OPENSSL_EXTRA #if defined(FORTRESS) && !defined(NO_FILESYSTEM) int wolfSSL_cmp_peer_cert_to_file(WOLFSSL* ssl, const char *fname) { int ret = WOLFSSL_FATAL_ERROR; WOLFSSL_ENTER("wolfSSL_cmp_peer_cert_to_file"); if (ssl != NULL && fname != NULL) { #ifdef WOLFSSL_SMALL_STACK byte staticBuffer[1]; /* force heap usage */ #else byte staticBuffer[FILE_BUFFER_SIZE]; #endif byte* myBuffer = staticBuffer; int dynamic = 0; XFILE file; long sz = 0; WOLFSSL_CTX* ctx = ssl->ctx; WOLFSSL_X509* peer_cert = &ssl->peerCert; DerBuffer* fileDer = NULL; file = XFOPEN(fname, "rb"); if (file == XBADFILE) return WOLFSSL_BAD_FILE; if (XFSEEK(file, 0, XSEEK_END) != 0) { XFCLOSE(file); return WOLFSSL_BAD_FILE; } sz = XFTELL(file); XREWIND(file); if (sz > MAX_WOLFSSL_FILE_SIZE || sz < 0) { WOLFSSL_MSG("cmp_peer_cert_to_file size error"); XFCLOSE(file); return WOLFSSL_BAD_FILE; } if (sz > (long)sizeof(staticBuffer)) { WOLFSSL_MSG("Getting dynamic buffer"); myBuffer = (byte*)XMALLOC(sz, ctx->heap, DYNAMIC_TYPE_FILE); dynamic = 1; } if ((myBuffer != NULL) && (sz > 0) && (XFREAD(myBuffer, 1, sz, file) == (size_t)sz) && (PemToDer(myBuffer, (long)sz, CERT_TYPE, &fileDer, ctx->heap, NULL, NULL) == 0) && (fileDer->length != 0) && (fileDer->length == peer_cert->derCert->length) && (XMEMCMP(peer_cert->derCert->buffer, fileDer->buffer, fileDer->length) == 0)) { ret = 0; } FreeDer(&fileDer); if (dynamic) XFREE(myBuffer, ctx->heap, DYNAMIC_TYPE_FILE); XFCLOSE(file); } return ret; } #endif #endif /* OPENSSL_EXTRA */ #endif /* !WOLFCRYPT_ONLY */ #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) const WOLFSSL_ObjectInfo wolfssl_object_info[] = { #ifndef NO_CERTS /* oidCertExtType */ { NID_basic_constraints, BASIC_CA_OID, oidCertExtType, "basicConstraints", "X509v3 Basic Constraints"}, { NID_subject_alt_name, ALT_NAMES_OID, oidCertExtType, "subjectAltName", "X509v3 Subject Alternative Name"}, { CRL_DIST_OID, CRL_DIST_OID, oidCertExtType, "crlDistributionPoints", "X509v3 CRL Distribution Points"}, { NID_info_access, AUTH_INFO_OID, oidCertExtType, "authorityInfoAccess", "Authority Information Access"}, { NID_authority_key_identifier, AUTH_KEY_OID, oidCertExtType, "authorityKeyIdentifier", "X509v3 Authority Key Identifier"}, { NID_subject_key_identifier, SUBJ_KEY_OID, oidCertExtType, "subjectKeyIdentifier", "X509v3 Subject Key Identifier"}, { NID_key_usage, KEY_USAGE_OID, oidCertExtType, "keyUsage", "X509v3 Key Usage"}, { NID_inhibit_any_policy, INHIBIT_ANY_OID, oidCertExtType, "inhibitAnyPolicy", "X509v3 Inhibit Any Policy"}, { NID_ext_key_usage, KEY_USAGE_OID, oidCertExtType, "extendedKeyUsage", "X509v3 Extended Key Usage"}, { NID_name_constraints, NAME_CONS_OID, oidCertExtType, "nameConstraints", "X509v3 Name Constraints"}, { NID_certificate_policies, CERT_POLICY_OID, oidCertExtType, "certificatePolicies", "X509v3 Certificate Policies"}, /* oidCertAuthInfoType */ { AIA_OCSP_OID, AIA_OCSP_OID, oidCertAuthInfoType, "authorityInfoAccess", "Authority Information Access"}, { AIA_CA_ISSUER_OID, AIA_CA_ISSUER_OID, oidCertAuthInfoType, "caIssuers", "CA Issuers"}, /* oidCertPolicyType */ { NID_any_policy, CP_ANY_OID, oidCertPolicyType, "anyPolicy", "X509v3 Any Policy"}, /* oidCertAltNameType */ { NID_hw_name_oid, HW_NAME_OID, oidCertAltNameType, "Hardware name",""}, /* oidCertKeyUseType */ { NID_anyExtendedKeyUsage, EKU_ANY_OID, oidCertKeyUseType, "anyExtendedKeyUsage", "Any Extended Key Usage"}, { EKU_SERVER_AUTH_OID, EKU_SERVER_AUTH_OID, oidCertKeyUseType, "serverAuth", "TLS Web Server Authentication"}, { EKU_CLIENT_AUTH_OID, EKU_CLIENT_AUTH_OID, oidCertKeyUseType, "clientAuth", "TLS Web Client Authentication"}, { EKU_OCSP_SIGN_OID, EKU_OCSP_SIGN_OID, oidCertKeyUseType, "OCSPSigning", "OCSP Signing"}, /* oidCertNameType */ { NID_commonName, NID_commonName, oidCertNameType, "CN", "commonName"}, { NID_surname, NID_surname, oidCertNameType, "SN", "surname"}, { NID_serialNumber, NID_serialNumber, oidCertNameType, "serialNumber", "serialNumber"}, { NID_countryName, NID_countryName, oidCertNameType, "C", "countryName"}, { NID_localityName, NID_localityName, oidCertNameType, "L", "localityName"}, { NID_stateOrProvinceName, NID_stateOrProvinceName, oidCertNameType, "ST", "stateOrProvinceName"}, { NID_organizationName, NID_organizationName, oidCertNameType, "O", "organizationName"}, { NID_organizationalUnitName, NID_organizationalUnitName, oidCertNameType, "OU", "organizationalUnitName"}, { NID_emailAddress, NID_emailAddress, oidCertNameType, "emailAddress", "emailAddress"}, { NID_domainComponent, NID_domainComponent, oidCertNameType, "DC", "domainComponent"}, { NID_businessCategory, NID_businessCategory, oidCertNameType, "businessCategory", "businessCategory"}, { NID_jurisdictionCountryName, NID_jurisdictionCountryName, oidCertNameType, "jurisdictionC", "jurisdictionCountryName"}, { NID_jurisdictionStateOrProvinceName, NID_jurisdictionStateOrProvinceName, oidCertNameType, "jurisdictionST", "jurisdictionStateOrProvinceName"}, #endif #ifdef OPENSSL_EXTRA /* OPENSSL_EXTRA_X509_SMALL only needs the above */ /* oidHashType */ #ifdef WOLFSSL_MD2 { NID_md2, MD2h, oidHashType, "MD2", "md2"}, #endif #ifdef WOLFSSL_MD5 { NID_md5, MD5h, oidHashType, "MD5", "md5"}, #endif #ifndef NO_SHA { NID_sha1, SHAh, oidHashType, "SHA1", "sha1"}, #endif #ifdef WOLFSSL_SHA224 { NID_sha224, SHA224h, oidHashType, "SHA224", "sha224"}, #endif #ifndef NO_SHA256 { NID_sha256, SHA256h, oidHashType, "SHA256", "sha256"}, #endif #ifdef WOLFSSL_SHA384 { NID_sha384, SHA384h, oidHashType, "SHA384", "sha384"}, #endif #ifdef WOLFSSL_SHA512 { NID_sha512, SHA512h, oidHashType, "SHA512", "sha512"}, #endif /* oidSigType */ #ifndef NO_DSA #ifndef NO_SHA { CTC_SHAwDSA, CTC_SHAwDSA, oidSigType, "DSA-SHA1", "dsaWithSHA1"}, #endif #endif /* NO_DSA */ #ifndef NO_RSA #ifdef WOLFSSL_MD2 { CTC_MD2wRSA, CTC_MD2wRSA, oidSigType, "RSA-MD2", "md2WithRSAEncryption"}, #endif #ifndef NO_MD5 { CTC_MD5wRSA, CTC_MD5wRSA, oidSigType, "RSA-MD5", "md5WithRSAEncryption"}, #endif #ifndef NO_SHA { CTC_SHAwRSA, CTC_SHAwRSA, oidSigType, "RSA-SHA1", "sha1WithRSAEncryption"}, #endif #ifdef WOLFSSL_SHA224 { CTC_SHA224wRSA, CTC_SHA224wRSA, oidSigType, "RSA-SHA224", "sha224WithRSAEncryption"}, #endif #ifndef NO_SHA256 { CTC_SHA256wRSA, CTC_SHA256wRSA, oidSigType, "RSA-SHA256", "sha256WithRSAEncryption"}, #endif #ifdef WOLFSSL_SHA384 { CTC_SHA384wRSA, CTC_SHA384wRSA, oidSigType, "RSA-SHA384", "sha384WithRSAEncryption"}, #endif #ifdef WOLFSSL_SHA512 { CTC_SHA512wRSA, CTC_SHA512wRSA, oidSigType, "RSA-SHA512", "sha512WithRSAEncryption"}, #endif #endif /* NO_RSA */ #ifdef HAVE_ECC #ifndef NO_SHA { CTC_SHAwECDSA, CTC_SHAwECDSA, oidSigType, "ecdsa-with-SHA1", "shaWithECDSA"}, #endif #ifdef WOLFSSL_SHA224 { CTC_SHA224wECDSA, CTC_SHA224wECDSA, oidSigType, "ecdsa-with-SHA224","sha224WithECDSA"}, #endif #ifndef NO_SHA256 { CTC_SHA256wECDSA, CTC_SHA256wECDSA, oidSigType, "ecdsa-with-SHA256","sha256WithECDSA"}, #endif #ifdef WOLFSSL_SHA384 { CTC_SHA384wECDSA, CTC_SHA384wECDSA, oidSigType, "ecdsa-with-SHA384","sha384WithECDSA"}, #endif #ifdef WOLFSSL_SHA512 { CTC_SHA512wECDSA, CTC_SHA512wECDSA, oidSigType, "ecdsa-with-SHA512","sha512WithECDSA"}, #endif #endif /* HAVE_ECC */ /* oidKeyType */ #ifndef NO_DSA { DSAk, DSAk, oidKeyType, "DSA", "dsaEncryption"}, { NID_dsa, DSAk, oidKeyType, "DSA", "dsaEncryption"}, #endif /* NO_DSA */ #ifndef NO_RSA { RSAk, RSAk, oidKeyType, "RSA", "rsaEncryption"}, { NID_rsaEncryption, RSAk, oidKeyType, "RSA", "rsaEncryption"}, #endif /* NO_RSA */ #ifdef HAVE_NTRU { NTRUk, NTRUk, oidKeyType, "NTRU", "ntruEncryption"}, #endif /* HAVE_NTRU */ #ifdef HAVE_ECC { ECDSAk, ECDSAk, oidKeyType, "ECDSA", "ecdsaEncryption"}, { NID_X9_62_id_ecPublicKey, ECDSAk, oidKeyType, "id-ecPublicKey", "id-ecPublicKey"}, #endif /* HAVE_ECC */ #ifndef NO_DH { NID_dhKeyAgreement, DHk, oidKeyType, "dhKeyAgreement", "dhKeyAgreement"}, #endif /* oidCurveType */ #ifdef HAVE_ECC { NID_X9_62_prime192v1, ECC_SECP192R1_OID, oidCurveType, "prime192v1", "prime192v1"}, { NID_X9_62_prime192v2, ECC_PRIME192V2_OID, oidCurveType, "prime192v2", "prime192v2"}, { NID_X9_62_prime192v3, ECC_PRIME192V3_OID, oidCurveType, "prime192v3", "prime192v3"}, { NID_X9_62_prime239v1, ECC_PRIME239V1_OID, oidCurveType, "prime239v1", "prime239v1"}, { NID_X9_62_prime239v2, ECC_PRIME239V2_OID, oidCurveType, "prime239v2", "prime239v2"}, { NID_X9_62_prime239v3, ECC_PRIME239V3_OID, oidCurveType, "prime239v3", "prime239v3"}, { NID_X9_62_prime256v1, ECC_SECP256R1_OID, oidCurveType, "prime256v1", "prime256v1"}, { NID_secp112r1, ECC_SECP112R1_OID, oidCurveType, "secp112r1", "secp112r1"}, { NID_secp112r2, ECC_SECP112R2_OID, oidCurveType, "secp112r2", "secp112r2"}, { NID_secp128r1, ECC_SECP128R1_OID, oidCurveType, "secp128r1", "secp128r1"}, { NID_secp128r2, ECC_SECP128R2_OID, oidCurveType, "secp128r2", "secp128r2"}, { NID_secp160r1, ECC_SECP160R1_OID, oidCurveType, "secp160r1", "secp160r1"}, { NID_secp160r2, ECC_SECP160R2_OID, oidCurveType, "secp160r2", "secp160r2"}, { NID_secp224r1, ECC_SECP224R1_OID, oidCurveType, "secp224r1", "secp224r1"}, { NID_secp384r1, ECC_SECP384R1_OID, oidCurveType, "secp384r1", "secp384r1"}, { NID_secp521r1, ECC_SECP521R1_OID, oidCurveType, "secp521r1", "secp521r1"}, { NID_secp160k1, ECC_SECP160K1_OID, oidCurveType, "secp160k1", "secp160k1"}, { NID_secp192k1, ECC_SECP192K1_OID, oidCurveType, "secp192k1", "secp192k1"}, { NID_secp224k1, ECC_SECP224K1_OID, oidCurveType, "secp224k1", "secp224k1"}, { NID_secp256k1, ECC_SECP256K1_OID, oidCurveType, "secp256k1", "secp256k1"}, { NID_brainpoolP160r1, ECC_BRAINPOOLP160R1_OID, oidCurveType, "brainpoolP160r1", "brainpoolP160r1"}, { NID_brainpoolP192r1, ECC_BRAINPOOLP192R1_OID, oidCurveType, "brainpoolP192r1", "brainpoolP192r1"}, { NID_brainpoolP224r1, ECC_BRAINPOOLP224R1_OID, oidCurveType, "brainpoolP224r1", "brainpoolP224r1"}, { NID_brainpoolP256r1, ECC_BRAINPOOLP256R1_OID, oidCurveType, "brainpoolP256r1", "brainpoolP256r1"}, { NID_brainpoolP320r1, ECC_BRAINPOOLP320R1_OID, oidCurveType, "brainpoolP320r1", "brainpoolP320r1"}, { NID_brainpoolP384r1, ECC_BRAINPOOLP384R1_OID, oidCurveType, "brainpoolP384r1", "brainpoolP384r1"}, { NID_brainpoolP512r1, ECC_BRAINPOOLP512R1_OID, oidCurveType, "brainpoolP512r1", "brainpoolP512r1"}, #endif /* HAVE_ECC */ /* oidBlkType */ #ifdef WOLFSSL_AES_128 { AES128CBCb, AES128CBCb, oidBlkType, "AES-128-CBC", "aes-128-cbc"}, #endif #ifdef WOLFSSL_AES_192 { AES192CBCb, AES192CBCb, oidBlkType, "AES-192-CBC", "aes-192-cbc"}, #endif #ifdef WOLFSSL_AES_256 { AES256CBCb, AES256CBCb, oidBlkType, "AES-256-CBC", "aes-256-cbc"}, #endif #ifndef NO_DES3 { NID_des, DESb, oidBlkType, "DES-CBC", "des-cbc"}, { NID_des3, DES3b, oidBlkType, "DES-EDE3-CBC", "des-ede3-cbc"}, #endif /* !NO_DES3 */ /* oidOcspType */ #ifdef HAVE_OCSP { NID_id_pkix_OCSP_basic, OCSP_BASIC_OID, oidOcspType, "basicOCSPResponse", "Basic OCSP Response"}, { OCSP_NONCE_OID, OCSP_NONCE_OID, oidOcspType, "Nonce", "OCSP Nonce"}, #endif /* HAVE_OCSP */ #ifndef NO_PWDBASED /* oidKdfType */ { PBKDF2_OID, PBKDF2_OID, oidKdfType, "PBKDFv2", "PBKDF2"}, /* oidPBEType */ { PBE_SHA1_RC4_128, PBE_SHA1_RC4_128, oidPBEType, "PBE-SHA1-RC4-128", "pbeWithSHA1And128BitRC4"}, { PBE_SHA1_DES, PBE_SHA1_DES, oidPBEType, "PBE-SHA1-DES", "pbeWithSHA1AndDES-CBC"}, { PBE_SHA1_DES3, PBE_SHA1_DES3, oidPBEType, "PBE-SHA1-3DES", "pbeWithSHA1And3-KeyTripleDES-CBC"}, #endif /* oidKeyWrapType */ #ifdef WOLFSSL_AES_128 { AES128_WRAP, AES128_WRAP, oidKeyWrapType, "AES-128 wrap", "aes128-wrap"}, #endif #ifdef WOLFSSL_AES_192 { AES192_WRAP, AES192_WRAP, oidKeyWrapType, "AES-192 wrap", "aes192-wrap"}, #endif #ifdef WOLFSSL_AES_256 { AES256_WRAP, AES256_WRAP, oidKeyWrapType, "AES-256 wrap", "aes256-wrap"}, #endif #ifndef NO_PKCS7 #ifndef NO_DH /* oidCmsKeyAgreeType */ #ifndef NO_SHA { dhSinglePass_stdDH_sha1kdf_scheme, dhSinglePass_stdDH_sha1kdf_scheme, oidCmsKeyAgreeType, "dhSinglePass-stdDH-sha1kdf-scheme", "dhSinglePass-stdDH-sha1kdf-scheme"}, #endif #ifdef WOLFSSL_SHA224 { dhSinglePass_stdDH_sha224kdf_scheme, dhSinglePass_stdDH_sha224kdf_scheme, oidCmsKeyAgreeType, "dhSinglePass-stdDH-sha224kdf-scheme", "dhSinglePass-stdDH-sha224kdf-scheme"}, #endif #ifndef NO_SHA256 { dhSinglePass_stdDH_sha256kdf_scheme, dhSinglePass_stdDH_sha256kdf_scheme, oidCmsKeyAgreeType, "dhSinglePass-stdDH-sha256kdf-scheme", "dhSinglePass-stdDH-sha256kdf-scheme"}, #endif #ifdef WOLFSSL_SHA384 { dhSinglePass_stdDH_sha384kdf_scheme, dhSinglePass_stdDH_sha384kdf_scheme, oidCmsKeyAgreeType, "dhSinglePass-stdDH-sha384kdf-scheme", "dhSinglePass-stdDH-sha384kdf-scheme"}, #endif #ifdef WOLFSSL_SHA512 { dhSinglePass_stdDH_sha512kdf_scheme, dhSinglePass_stdDH_sha512kdf_scheme, oidCmsKeyAgreeType, "dhSinglePass-stdDH-sha512kdf-scheme", "dhSinglePass-stdDH-sha512kdf-scheme"}, #endif #endif #endif #if defined(WOLFSSL_APACHE_HTTPD) /* "1.3.6.1.5.5.7.8.7" */ { NID_id_on_dnsSRV, NID_id_on_dnsSRV, oidCertNameType, WOLFSSL_SN_DNS_SRV, WOLFSSL_LN_DNS_SRV }, /* "1.3.6.1.4.1.311.20.2.3" */ { NID_ms_upn, WOLFSSL_MS_UPN_SUM, oidCertExtType, WOLFSSL_SN_MS_UPN, WOLFSSL_LN_MS_UPN }, /* "1.3.6.1.5.5.7.1.24" */ { NID_tlsfeature, WOLFSSL_TLS_FEATURE_SUM, oidTlsExtType, WOLFSSL_SN_TLS_FEATURE, WOLFSSL_LN_TLS_FEATURE }, #endif #endif /* OPENSSL_EXTRA */ }; #define WOLFSSL_OBJECT_INFO_SZ \ (sizeof(wolfssl_object_info) / sizeof(*wolfssl_object_info)) const size_t wolfssl_object_info_sz = WOLFSSL_OBJECT_INFO_SZ; #endif #if defined(OPENSSL_EXTRA) || \ (defined(OPENSSL_EXTRA_X509_SMALL) && !defined(NO_RSA)) static WC_RNG globalRNG; static int initGlobalRNG = 0; #endif #if defined(OPENSSL_EXTRA) && \ !defined(NO_RSA) && !defined(HAVE_USER_RSA) && !defined(HAVE_FAST_RSA) WC_RNG* WOLFSSL_RSA_GetRNG(WOLFSSL_RSA *rsa, WC_RNG **tmpRNG, int *initTmpRng) { WC_RNG* rng = NULL; if (!rsa || !initTmpRng) { return NULL; } *initTmpRng = 0; #if !defined(HAVE_FIPS) && !defined(HAVE_USER_RSA) && \ !defined(HAVE_FAST_RSA) && defined(WC_RSA_BLINDING) rng = ((RsaKey*)rsa->internal)->rng; #endif if (rng == NULL && tmpRNG) { if (!*tmpRNG) { #ifdef WOLFSSL_SMALL_STACK *tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_TMP_BUFFER); if (*tmpRNG == NULL) return NULL; #else WOLFSSL_MSG("*tmpRNG is null"); return NULL; #endif } if (wc_InitRng(*tmpRNG) == 0) { rng = *tmpRNG; *initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; #ifdef WOLFSSL_SMALL_STACK if (*tmpRNG) XFREE(*tmpRNG, NULL, DYNAMIC_TYPE_TMP_BUFFER); *tmpRNG = NULL; #endif } } return rng; } #endif #ifndef WOLFCRYPT_ONLY #ifdef OPENSSL_EXTRA /* Not thread safe! Can be called multiple times. * Checks if the global RNG has been created. If not then one is created. * * Returns SSL_SUCCESS when no error is encountered. */ static int wolfSSL_RAND_Init(void) { if (initGlobalRNG == 0) { if (wc_InitRng(&globalRNG) < 0) { WOLFSSL_MSG("wolfSSL Init Global RNG failed"); return 0; } initGlobalRNG = 1; } return SSL_SUCCESS; } /* SSL_SUCCESS on ok */ int wolfSSL_RAND_seed(const void* seed, int len) { WOLFSSL_MSG("wolfSSL_RAND_seed"); (void)seed; (void)len; return wolfSSL_RAND_Init(); } /* Returns the path for reading seed data from. * Uses the env variable $RANDFILE first if set, if not then used $HOME/.rnd * * Note uses stdlib by default unless XGETENV macro is overwritten * * fname buffer to hold path * len length of fname buffer * * Returns a pointer to fname on success and NULL on failure */ const char* wolfSSL_RAND_file_name(char* fname, unsigned long len) { #ifndef NO_FILESYSTEM char* rt; char ap[] = "/.rnd"; WOLFSSL_ENTER("wolfSSL_RAND_file_name"); if (fname == NULL) { return NULL; } XMEMSET(fname, 0, len); /* if access to stdlib.h */ if ((rt = XGETENV("RANDFILE")) != NULL) { if (len > XSTRLEN(rt)) { XMEMCPY(fname, rt, XSTRLEN(rt)); } else { WOLFSSL_MSG("RANDFILE too large for buffer"); rt = NULL; } } /* $RANDFILE was not set or is too large, check $HOME */ if (rt == NULL) { WOLFSSL_MSG("Environment variable RANDFILE not set"); if ((rt = XGETENV("HOME")) == NULL) { WOLFSSL_MSG("Environment variable HOME not set"); return NULL; } if (len > XSTRLEN(rt) + XSTRLEN(ap)) { fname[0] = '\0'; XSTRNCAT(fname, rt, len); XSTRNCAT(fname, ap, len - XSTRLEN(rt)); return fname; } else { WOLFSSL_MSG("HOME too large for buffer"); return NULL; } } return fname; #else /* no filesystem defined */ WOLFSSL_ENTER("wolfSSL_RAND_file_name"); WOLFSSL_MSG("No filesystem feature enabled, not compiled in"); (void)fname; (void)len; return NULL; #endif } /* Writes 1024 bytes from the RNG to the given file name. * * fname name of file to write to * * Returns the number of bytes written */ int wolfSSL_RAND_write_file(const char* fname) { int bytes = 0; WOLFSSL_ENTER("RAND_write_file"); if (fname == NULL) { return SSL_FAILURE; } #ifndef NO_FILESYSTEM { #ifndef WOLFSSL_SMALL_STACK unsigned char buf[1024]; #else unsigned char* buf = (unsigned char *)XMALLOC(1024, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (buf == NULL) { WOLFSSL_MSG("malloc failed"); return SSL_FAILURE; } #endif bytes = 1024; /* default size of buf */ if (initGlobalRNG == 0 && wolfSSL_RAND_Init() != SSL_SUCCESS) { WOLFSSL_MSG("No RNG to use"); #ifdef WOLFSSL_SMALL_STACK XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif return 0; } if (wc_RNG_GenerateBlock(&globalRNG, buf, bytes) != 0) { WOLFSSL_MSG("Error generating random buffer"); bytes = 0; } else { XFILE f; f = XFOPEN(fname, "wb"); if (f == XBADFILE) { WOLFSSL_MSG("Error opening the file"); bytes = 0; } else { XFWRITE(buf, 1, bytes, f); XFCLOSE(f); } } ForceZero(buf, bytes); #ifdef WOLFSSL_SMALL_STACK XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif } #endif return bytes; } #ifndef FREERTOS_TCP /* These constant values are protocol values made by egd */ #if defined(USE_WOLFSSL_IO) && !defined(USE_WINDOWS_API) #define WOLFSSL_EGD_NBLOCK 0x01 #include #endif /* This collects entropy from the path nm and seeds the global PRNG with it. * Makes a call to wolfSSL_RAND_Init which is not thread safe. * * nm is the file path to the egd server * * Returns the number of bytes read. */ int wolfSSL_RAND_egd(const char* nm) { #if defined(USE_WOLFSSL_IO) && !defined(USE_WINDOWS_API) && !defined(HAVE_FIPS) && \ defined(HAVE_HASHDRBG) struct sockaddr_un rem; int fd; int ret = WOLFSSL_SUCCESS; word32 bytes = 0; word32 idx = 0; #ifndef WOLFSSL_SMALL_STACK unsigned char buf[256]; #else unsigned char* buf; buf = (unsigned char*)XMALLOC(256, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (buf == NULL) { WOLFSSL_MSG("Not enough memory"); return WOLFSSL_FATAL_ERROR; } #endif if (nm == NULL) { #ifdef WOLFSSL_SMALL_STACK XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif return WOLFSSL_FATAL_ERROR; } fd = socket(AF_UNIX, SOCK_STREAM, 0); if (fd < 0) { WOLFSSL_MSG("Error creating socket"); #ifdef WOLFSSL_SMALL_STACK XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif return WOLFSSL_FATAL_ERROR; } if (ret == WOLFSSL_SUCCESS) { rem.sun_family = AF_UNIX; XSTRNCPY(rem.sun_path, nm, sizeof(rem.sun_path) - 1); rem.sun_path[sizeof(rem.sun_path)-1] = '\0'; } /* connect to egd server */ if (ret == WOLFSSL_SUCCESS) { if (connect(fd, (struct sockaddr*)&rem, sizeof(struct sockaddr_un)) == -1) { WOLFSSL_MSG("error connecting to egd server"); ret = WOLFSSL_FATAL_ERROR; } } while (ret == WOLFSSL_SUCCESS && bytes < 255 && idx + 2 < 256) { if (ret == WOLFSSL_SUCCESS) { buf[idx] = WOLFSSL_EGD_NBLOCK; buf[idx + 1] = 255 - bytes; /* request 255 bytes from server */ ret = (int)write(fd, buf + idx, 2); if (ret <= 0 || ret != 2) { if (errno == EAGAIN) { ret = WOLFSSL_SUCCESS; continue; } WOLFSSL_MSG("error requesting entropy from egd server"); ret = WOLFSSL_FATAL_ERROR; break; } } /* attempting to read */ buf[idx] = 0; ret = (int)read(fd, buf + idx, 256 - bytes); if (ret == 0) { WOLFSSL_MSG("error reading entropy from egd server"); ret = WOLFSSL_FATAL_ERROR; break; } if (ret > 0 && buf[idx] > 0) { bytes += buf[idx]; /* egd stores amount sent in first byte */ if (bytes + idx > 255 || buf[idx] > ret) { WOLFSSL_MSG("Buffer error"); ret = WOLFSSL_FATAL_ERROR; break; } XMEMMOVE(buf + idx, buf + idx + 1, buf[idx]); idx = bytes; ret = WOLFSSL_SUCCESS; if (bytes >= 255) { break; } } else { if (errno == EAGAIN || errno == EINTR) { WOLFSSL_MSG("EGD would read"); ret = WOLFSSL_SUCCESS; /* try again */ } else if (buf[idx] == 0) { /* if egd returned 0 then there is no more entropy to be had. Do not try more reads. */ ret = WOLFSSL_SUCCESS; break; } else { WOLFSSL_MSG("Error with read"); ret = WOLFSSL_FATAL_ERROR; } } } if (bytes > 0 && ret == WOLFSSL_SUCCESS) { wolfSSL_RAND_Init(); /* call to check global RNG is created */ if (wc_RNG_DRBG_Reseed(&globalRNG, (const byte*) buf, bytes) != 0) { WOLFSSL_MSG("Error with reseeding DRBG structure"); ret = WOLFSSL_FATAL_ERROR; } #ifdef SHOW_SECRETS { /* print out entropy found */ word32 i; printf("EGD Entropy = "); for (i = 0; i < bytes; i++) { printf("%02X", buf[i]); } printf("\n"); } #endif } ForceZero(buf, bytes); #ifdef WOLFSSL_SMALL_STACK XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif close(fd); if (ret == WOLFSSL_SUCCESS) { return bytes; } else { return ret; } #else WOLFSSL_MSG("Type of socket needed is not available"); WOLFSSL_MSG("\tor using mode where DRBG API is not available"); (void)nm; return WOLFSSL_FATAL_ERROR; #endif /* USE_WOLFSSL_IO && !USE_WINDOWS_API && !HAVE_FIPS && HAVE_HASHDRBG */ } #endif /* !FREERTOS_TCP */ void wolfSSL_RAND_Cleanup(void) { WOLFSSL_ENTER("wolfSSL_RAND_Cleanup()"); if (initGlobalRNG != 0) { wc_FreeRng(&globalRNG); initGlobalRNG = 0; } } int wolfSSL_RAND_pseudo_bytes(unsigned char* buf, int num) { return wolfSSL_RAND_bytes(buf, num); } /* SSL_SUCCESS on ok */ int wolfSSL_RAND_bytes(unsigned char* buf, int num) { int ret = 0; int initTmpRng = 0; WC_RNG* rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG; #else WC_RNG tmpRNG[1]; #endif WOLFSSL_ENTER("wolfSSL_RAND_bytes"); #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return ret; #endif if (initGlobalRNG) rng = &globalRNG; else if(wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } if (rng) { if (wc_RNG_GenerateBlock(rng, buf, num) != 0) WOLFSSL_MSG("Bad wc_RNG_GenerateBlock"); else ret = WOLFSSL_SUCCESS; } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return ret; } int wolfSSL_RAND_poll(void) { byte entropy[16]; int ret = 0; word32 entropy_sz = 16; WOLFSSL_ENTER("wolfSSL_RAND_poll"); if (initGlobalRNG == 0){ WOLFSSL_MSG("Global RNG no Init"); return WOLFSSL_FAILURE; } ret = wc_GenerateSeed(&globalRNG.seed, entropy, entropy_sz); if (ret != 0){ WOLFSSL_MSG("Bad wc_RNG_GenerateBlock"); ret = WOLFSSL_FAILURE; }else ret = WOLFSSL_SUCCESS; return ret; } #endif /* OPENSSL_EXTRA */ #ifdef OPENSSL_EXTRA WOLFSSL_ASN1_INTEGER* wolfSSL_BN_to_ASN1_INTEGER(const WOLFSSL_BIGNUM *bn, WOLFSSL_ASN1_INTEGER *ai) { WOLFSSL_ASN1_INTEGER* a; int len; WOLFSSL_ENTER("wolfSSL_BN_to_ASN1_INTEGER"); if (ai == NULL) { a = wolfSSL_ASN1_INTEGER_new(); if (a == NULL) return NULL; a->type = V_ASN1_INTEGER; } else { a = ai; } if (a) { if (wolfSSL_BN_is_negative(bn) && !wolfSSL_BN_is_zero(bn)) { a->type |= V_ASN1_NEG_INTEGER; a->negative = 1; } len = wolfSSL_BN_num_bytes(bn); if (len == 0) len = 1; /* allocate buffer */ if (len > (int)sizeof(a->intData)) { /* create new data buffer and copy over */ a->data = (byte*)XMALLOC(len, NULL, DYNAMIC_TYPE_OPENSSL); if (a->data == NULL) { if (a != ai) wolfSSL_ASN1_INTEGER_free(a); return NULL; } a->isDynamic = 1; } else { XMEMSET(a->intData, 0, sizeof(a->intData)); a->data = a->intData; } a->length = len; /* populate data */ if (wolfSSL_BN_is_zero(bn)) { a->data[0] = 0; } else { len = wolfSSL_BN_bn2bin(bn, a->data); } a->length = len; } return a; } #ifdef OPENSSL_ALL void *wolfSSL_ASN1_item_new(const WOLFSSL_ASN1_ITEM *template) { void *ret = NULL; const WOLFSSL_ASN1_TEMPLATE *member = NULL; size_t i; WOLFSSL_ENTER("wolfSSL_ASN1_item_new"); if (!template) { return NULL; } if (!(ret = XMALLOC(template->size, NULL, DYNAMIC_TYPE_OPENSSL))) { return NULL; } XMEMSET(ret, 0, template->size); for (member = template->members, i = 0; i < template->mcount; member++, i++) { switch (member->type) { case WOLFSSL_X509_ALGOR_ASN1: { WOLFSSL_X509_ALGOR* algor = wolfSSL_X509_ALGOR_new(); if (!algor) { goto error; } *(WOLFSSL_X509_ALGOR**)(((byte*)ret) + member->offset) = algor; break; } case WOLFSSL_ASN1_BIT_STRING_ASN1: { WOLFSSL_ASN1_BIT_STRING* bit_str = wolfSSL_ASN1_BIT_STRING_new(); if (!bit_str) { goto error; } *(WOLFSSL_ASN1_BIT_STRING**)(((byte*)ret) + member->offset) = bit_str; break; } default: WOLFSSL_MSG("Type not supported in wolfSSL_ASN1_item_new"); goto error; } } return ret; error: wolfSSL_ASN1_item_free(ret, template); return NULL; } void wolfSSL_ASN1_item_free(void *val, const WOLFSSL_ASN1_ITEM *template) { const WOLFSSL_ASN1_TEMPLATE *member = NULL; size_t i; WOLFSSL_ENTER("wolfSSL_ASN1_item_free"); if (val) { for (member = template->members, i = 0; i < template->mcount; member++, i++) { switch (member->type) { case WOLFSSL_X509_ALGOR_ASN1: { WOLFSSL_X509_ALGOR* algor = *(WOLFSSL_X509_ALGOR**) (((byte*)val) + member->offset); if (algor) { wolfSSL_X509_ALGOR_free(algor); } break; } case WOLFSSL_ASN1_BIT_STRING_ASN1: { WOLFSSL_ASN1_BIT_STRING* bit_str = *(WOLFSSL_ASN1_BIT_STRING**) (((byte*)val) + member->offset); if (bit_str) { wolfSSL_ASN1_BIT_STRING_free(bit_str); } break; } default: WOLFSSL_MSG("Type not supported in wolfSSL_ASN1_item_free"); } } XFREE(val, NULL, DYNAMIC_TYPE_OPENSSL); } } #define bufLenOrNull(buf, len) (buf ? buf + len : NULL) static int i2dProcessMembers(const void *src, byte *buf, const WOLFSSL_ASN1_TEMPLATE *members, size_t mcount) { const WOLFSSL_ASN1_TEMPLATE *member = NULL; int len = 0, ret; size_t i; WOLFSSL_ENTER("processMembers"); for (member = members, i = 0; i < mcount; member++, i++) { switch (member->type) { case WOLFSSL_X509_ALGOR_ASN1: { word32 oid = 0; word32 idx = 0; const WOLFSSL_X509_ALGOR* algor = *(const WOLFSSL_X509_ALGOR**) (((byte*)src) + member->offset); if (!algor->algorithm) { WOLFSSL_LEAVE("processMembers", WOLFSSL_FAILURE); return WOLFSSL_FAILURE; } if (GetObjectId(algor->algorithm->obj, &idx, &oid, algor->algorithm->grp, algor->algorithm->objSz) < 0) { WOLFSSL_MSG("Issue getting OID of object"); return -1; } ret = SetAlgoID(oid, bufLenOrNull(buf, len), algor->algorithm->grp, 0); if (!ret) { return WOLFSSL_FAILURE; } len += ret; break; } case WOLFSSL_ASN1_BIT_STRING_ASN1: { const WOLFSSL_ASN1_BIT_STRING* bit_str; bit_str = *(const WOLFSSL_ASN1_BIT_STRING**) (((byte*)src) + member->offset); len += SetBitString(bit_str->length, 0, bufLenOrNull(buf, len)); if (buf && bit_str->data) { XMEMCPY(buf + len, bit_str->data, bit_str->length); } len += bit_str->length; break; } default: WOLFSSL_MSG("Type not support in processMembers"); WOLFSSL_LEAVE("processMembers", WOLFSSL_FAILURE); return WOLFSSL_FAILURE; } } WOLFSSL_LEAVE("processMembers", len); return len; } int wolfSSL_ASN1_item_i2d(const void *src, byte **dest, const WOLFSSL_ASN1_ITEM *template) { int len = 0; byte *buf = NULL; WOLFSSL_ENTER("wolfSSL_ASN1_item_i2d"); if (!src || !template) { WOLFSSL_LEAVE("wolfSSL_ASN1_item_i2d", WOLFSSL_FAILURE); return WOLFSSL_FAILURE; } if (dest && !*dest) { len = wolfSSL_ASN1_item_i2d(src, NULL, template); if (!len) { goto error; } buf = (byte*)XMALLOC(len, NULL, DYNAMIC_TYPE_ASN1); if (!buf) { goto error; } len = 0; } switch (template->type) { case ASN_SEQUENCE: { int seq_len = i2dProcessMembers(src, NULL, template->members, template->mcount); if (!seq_len) { goto error; } len += SetSequence(seq_len, bufLenOrNull(buf, len)); if (buf && i2dProcessMembers(src, bufLenOrNull(buf, len), template->members, template->mcount) != seq_len) { WOLFSSL_MSG("Inconsistent sequence length"); goto error; } len += seq_len; break; } default: WOLFSSL_MSG("Type not supported in wolfSSL_ASN1_item_i2d"); goto error; } if (dest && !*dest) { *dest = buf; } else if (dest && *dest && buf) { /* *dest length is not checked because the user is responsible * for providing a long enough buffer */ XMEMCPY(*dest, buf, len); } WOLFSSL_LEAVE("wolfSSL_ASN1_item_i2d", len); return len; error: if (buf) { XFREE(buf, NULL, DYNAMIC_TYPE_ASN1); } WOLFSSL_LEAVE("wolfSSL_ASN1_item_i2d", WOLFSSL_FAILURE); return WOLFSSL_FAILURE; } #endif /* OPENSSL_ALL */ #ifndef NO_DH static void InitwolfSSL_DH(WOLFSSL_DH* dh) { if (dh) { XMEMSET(dh, 0, sizeof(WOLFSSL_DH)); } } WOLFSSL_DH* wolfSSL_DH_new(void) { WOLFSSL_DH* external; DhKey* key; WOLFSSL_MSG("wolfSSL_DH_new"); key = (DhKey*) XMALLOC(sizeof(DhKey), NULL, DYNAMIC_TYPE_DH); if (key == NULL) { WOLFSSL_MSG("wolfSSL_DH_new malloc DhKey failure"); return NULL; } external = (WOLFSSL_DH*) XMALLOC(sizeof(WOLFSSL_DH), NULL, DYNAMIC_TYPE_DH); if (external == NULL) { WOLFSSL_MSG("wolfSSL_DH_new malloc WOLFSSL_DH failure"); XFREE(key, NULL, DYNAMIC_TYPE_DH); return NULL; } InitwolfSSL_DH(external); if (wc_InitDhKey(key) != 0) { WOLFSSL_MSG("wolfSSL_DH_new InitDhKey failure"); XFREE(key, NULL, DYNAMIC_TYPE_DH); XFREE(external, NULL, DYNAMIC_TYPE_DH); return NULL; } external->internal = key; return external; } void wolfSSL_DH_free(WOLFSSL_DH* dh) { WOLFSSL_MSG("wolfSSL_DH_free"); if (dh) { if (dh->internal) { wc_FreeDhKey((DhKey*)dh->internal); XFREE(dh->internal, NULL, DYNAMIC_TYPE_DH); dh->internal = NULL; } wolfSSL_BN_free(dh->priv_key); wolfSSL_BN_free(dh->pub_key); wolfSSL_BN_free(dh->g); wolfSSL_BN_free(dh->p); wolfSSL_BN_free(dh->q); InitwolfSSL_DH(dh); /* set back to NULLs for safety */ XFREE(dh, NULL, DYNAMIC_TYPE_DH); } } int SetDhInternal(WOLFSSL_DH* dh) { int ret = WOLFSSL_FATAL_ERROR; int pSz = 1024; int gSz = 1024; #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) int privSz = 256; /* Up to 2048-bit */ int pubSz = 256; #endif #ifdef WOLFSSL_SMALL_STACK unsigned char* p = NULL; unsigned char* g = NULL; #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) unsigned char* priv_key = NULL; unsigned char* pub_key = NULL; #endif #else unsigned char p[1024]; unsigned char g[1024]; #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) unsigned char priv_key[256]; unsigned char pub_key[256]; #endif #endif WOLFSSL_ENTER("SetDhInternal"); if (dh == NULL || dh->p == NULL || dh->g == NULL) WOLFSSL_MSG("Bad function arguments"); else if (wolfSSL_BN_bn2bin(dh->p, NULL) > pSz) WOLFSSL_MSG("Bad p internal size"); else if (wolfSSL_BN_bn2bin(dh->g, NULL) > gSz) WOLFSSL_MSG("Bad g internal size"); #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) else if (wolfSSL_BN_bn2bin(dh->priv_key, NULL) > privSz) WOLFSSL_MSG("Bad private key internal size"); else if (wolfSSL_BN_bn2bin(dh->pub_key, NULL) > privSz) WOLFSSL_MSG("Bad public key internal size"); #endif else { #ifdef WOLFSSL_SMALL_STACK p = (unsigned char*)XMALLOC(pSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); g = (unsigned char*)XMALLOC(gSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) priv_key = (unsigned char*)XMALLOC(privSz,NULL,DYNAMIC_TYPE_PRIVATE_KEY); pub_key = (unsigned char*)XMALLOC(pubSz,NULL,DYNAMIC_TYPE_PUBLIC_KEY); #endif if (p == NULL || g == NULL) { XFREE(p, NULL, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(g, NULL, DYNAMIC_TYPE_PUBLIC_KEY); return ret; } #endif /* WOLFSSL_SMALL_STACK */ #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) privSz = wolfSSL_BN_bn2bin(dh->priv_key, priv_key); pubSz = wolfSSL_BN_bn2bin(dh->pub_key, pub_key); if (privSz <= 0) { WOLFSSL_MSG("No private key size."); } if (pubSz <= 0) { WOLFSSL_MSG("No public key size."); } if (privSz > 0 || pubSz > 0) { ret = wc_DhSetFullKeys((DhKey*)dh->internal,priv_key,privSz, pub_key,pubSz); if (ret == WOLFSSL_FAILURE) { WOLFSSL_MSG("Failed setting private or public key."); } } #endif /* WOLFSSL_QT || OPENSSL_ALL */ pSz = wolfSSL_BN_bn2bin(dh->p, p); gSz = wolfSSL_BN_bn2bin(dh->g, g); if (pSz <= 0 || gSz <= 0) WOLFSSL_MSG("Bad BN2bin set"); else if (wc_DhSetKey((DhKey*)dh->internal, p, pSz, g, gSz) < 0) WOLFSSL_MSG("Bad DH SetKey"); else { dh->inSet = 1; ret = WOLFSSL_SUCCESS; } #ifdef WOLFSSL_SMALL_STACK XFREE(p, NULL, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(g, NULL, DYNAMIC_TYPE_PUBLIC_KEY); #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) XFREE(priv_key, NULL, DYNAMIC_TYPE_PRIVATE_KEY); XFREE(pub_key, NULL, DYNAMIC_TYPE_PUBLIC_KEY); #endif #endif } return ret; } #if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL) || defined(WOLFSSL_OPENSSH)) /* Set the members of DhKey into WOLFSSL_DH * DhKey was populated from wc_DhKeyDecode */ int SetDhExternal(WOLFSSL_DH *dh) { DhKey *key; WOLFSSL_MSG("Entering SetDhExternal"); if (dh == NULL || dh->internal == NULL) { WOLFSSL_MSG("dh key NULL error"); } key = (DhKey*)dh->internal; if (SetIndividualExternal(&dh->p, &key->p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dh param p error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&dh->g, &key->g) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dh param g error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&dh->priv_key, &key->priv) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("No DH Private Key"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&dh->pub_key, &key->pub) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("No DH Public Key"); return WOLFSSL_FATAL_ERROR; } dh->exSet = 1; return WOLFSSL_SUCCESS; } #endif /* !NO_DH && (WOLFSSL_QT || OPENSSL_ALL) */ /* return code compliant with OpenSSL : * DH prime size in bytes if success, 0 if error */ int wolfSSL_DH_size(WOLFSSL_DH* dh) { WOLFSSL_MSG("wolfSSL_DH_size"); if (dh == NULL) return WOLFSSL_FATAL_ERROR; return wolfSSL_BN_num_bytes(dh->p); } /* This sets a big number with the 768-bit prime from RFC 2409. * * bn if not NULL then the big number structure is used. If NULL then a new * big number structure is created. * * Returns a WOLFSSL_BIGNUM structure on success and NULL with failure. */ WOLFSSL_BIGNUM* wolfSSL_DH_768_prime(WOLFSSL_BIGNUM* bn) { const char prm[] = { "FFFFFFFFFFFFFFFFC90FDAA22168C234" "C4C6628B80DC1CD129024E088A67CC74" "020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F1437" "4FE1356D6D51C245E485B576625E7EC6" "F44C42E9A63A3620FFFFFFFFFFFFFFFF" }; WOLFSSL_ENTER("wolfSSL_DH_768_prime"); if (wolfSSL_BN_hex2bn(&bn, prm) != SSL_SUCCESS) { WOLFSSL_MSG("Error converting DH 768 prime to big number"); return NULL; } return bn; } /* This sets a big number with the 1024-bit prime from RFC 2409. * * bn if not NULL then the big number structure is used. If NULL then a new * big number structure is created. * * Returns a WOLFSSL_BIGNUM structure on success and NULL with failure. */ WOLFSSL_BIGNUM* wolfSSL_DH_1024_prime(WOLFSSL_BIGNUM* bn) { const char prm[] = { "FFFFFFFFFFFFFFFFC90FDAA22168C234" "C4C6628B80DC1CD129024E088A67CC74" "020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F1437" "4FE1356D6D51C245E485B576625E7EC6" "F44C42E9A637ED6B0BFF5CB6F406B7ED" "EE386BFB5A899FA5AE9F24117C4B1FE6" "49286651ECE65381FFFFFFFFFFFFFFFF" }; WOLFSSL_ENTER("wolfSSL_DH_1024_prime"); if (wolfSSL_BN_hex2bn(&bn, prm) != SSL_SUCCESS) { WOLFSSL_MSG("Error converting DH 1024 prime to big number"); return NULL; } return bn; } /* This sets a big number with the 1536-bit prime from RFC 3526. * * bn if not NULL then the big number structure is used. If NULL then a new * big number structure is created. * * Returns a WOLFSSL_BIGNUM structure on success and NULL with failure. */ WOLFSSL_BIGNUM* wolfSSL_DH_1536_prime(WOLFSSL_BIGNUM* bn) { const char prm[] = { "FFFFFFFFFFFFFFFFC90FDAA22168C234" "C4C6628B80DC1CD129024E088A67CC74" "020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F1437" "4FE1356D6D51C245E485B576625E7EC6" "F44C42E9A637ED6B0BFF5CB6F406B7ED" "EE386BFB5A899FA5AE9F24117C4B1FE6" "49286651ECE45B3DC2007CB8A163BF05" "98DA48361C55D39A69163FA8FD24CF5F" "83655D23DCA3AD961C62F356208552BB" "9ED529077096966D670C354E4ABC9804" "F1746C08CA237327FFFFFFFFFFFFFFFF" }; WOLFSSL_ENTER("wolfSSL_DH_1536_prime"); if (wolfSSL_BN_hex2bn(&bn, prm) != SSL_SUCCESS) { WOLFSSL_MSG("Error converting DH 1536 prime to big number"); return NULL; } return bn; } /* This sets a big number with the 2048-bit prime from RFC 3526. * * bn if not NULL then the big number structure is used. If NULL then a new * big number structure is created. * * Returns a WOLFSSL_BIGNUM structure on success and NULL with failure. */ WOLFSSL_BIGNUM* wolfSSL_DH_2048_prime(WOLFSSL_BIGNUM* bn) { const char prm[] = { "FFFFFFFFFFFFFFFFC90FDAA22168C234" "C4C6628B80DC1CD129024E088A67CC74" "020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F1437" "4FE1356D6D51C245E485B576625E7EC6" "F44C42E9A637ED6B0BFF5CB6F406B7ED" "EE386BFB5A899FA5AE9F24117C4B1FE6" "49286651ECE45B3DC2007CB8A163BF05" "98DA48361C55D39A69163FA8FD24CF5F" "83655D23DCA3AD961C62F356208552BB" "9ED529077096966D670C354E4ABC9804" "F1746C08CA18217C32905E462E36CE3B" "E39E772C180E86039B2783A2EC07A28F" "B5C55DF06F4C52C9DE2BCBF695581718" "3995497CEA956AE515D2261898FA0510" "15728E5A8AACAA68FFFFFFFFFFFFFFFF" }; WOLFSSL_ENTER("wolfSSL_DH_2048_prime"); if (wolfSSL_BN_hex2bn(&bn, prm) != SSL_SUCCESS) { WOLFSSL_MSG("Error converting DH 2048 prime to big number"); return NULL; } return bn; } /* This sets a big number with the 3072-bit prime from RFC 3526. * * bn if not NULL then the big number structure is used. If NULL then a new * big number structure is created. * * Returns a WOLFSSL_BIGNUM structure on success and NULL with failure. */ WOLFSSL_BIGNUM* wolfSSL_DH_3072_prime(WOLFSSL_BIGNUM* bn) { const char prm[] = { "FFFFFFFFFFFFFFFFC90FDAA22168C234" "C4C6628B80DC1CD129024E088A67CC74" "020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F1437" "4FE1356D6D51C245E485B576625E7EC6" "F44C42E9A637ED6B0BFF5CB6F406B7ED" "EE386BFB5A899FA5AE9F24117C4B1FE6" "49286651ECE45B3DC2007CB8A163BF05" "98DA48361C55D39A69163FA8FD24CF5F" "83655D23DCA3AD961C62F356208552BB" "9ED529077096966D670C354E4ABC9804" "F1746C08CA18217C32905E462E36CE3B" "E39E772C180E86039B2783A2EC07A28F" "B5C55DF06F4C52C9DE2BCBF695581718" "3995497CEA956AE515D2261898FA0510" "15728E5A8AAAC42DAD33170D04507A33" "A85521ABDF1CBA64ECFB850458DBEF0A" "8AEA71575D060C7DB3970F85A6E1E4C7" "ABF5AE8CDB0933D71E8C94E04A25619D" "CEE3D2261AD2EE6BF12FFA06D98A0864" "D87602733EC86A64521F2B18177B200C" "BBE117577A615D6C770988C0BAD946E2" "08E24FA074E5AB3143DB5BFCE0FD108E" "4B82D120A93AD2CAFFFFFFFFFFFFFFFF" }; WOLFSSL_ENTER("wolfSSL_DH_3072_prime"); if (wolfSSL_BN_hex2bn(&bn, prm) != SSL_SUCCESS) { WOLFSSL_MSG("Error converting DH 3072 prime to big number"); return NULL; } return bn; } /* This sets a big number with the 4096-bit prime from RFC 3526. * * bn if not NULL then the big number structure is used. If NULL then a new * big number structure is created. * * Returns a WOLFSSL_BIGNUM structure on success and NULL with failure. */ WOLFSSL_BIGNUM* wolfSSL_DH_4096_prime(WOLFSSL_BIGNUM* bn) { const char prm[] = { "FFFFFFFFFFFFFFFFC90FDAA22168C234" "C4C6628B80DC1CD129024E088A67CC74" "020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F1437" "4FE1356D6D51C245E485B576625E7EC6" "F44C42E9A637ED6B0BFF5CB6F406B7ED" "EE386BFB5A899FA5AE9F24117C4B1FE6" "49286651ECE45B3DC2007CB8A163BF05" "98DA48361C55D39A69163FA8FD24CF5F" "83655D23DCA3AD961C62F356208552BB" "9ED529077096966D670C354E4ABC9804" "F1746C08CA18217C32905E462E36CE3B" "E39E772C180E86039B2783A2EC07A28F" "B5C55DF06F4C52C9DE2BCBF695581718" "3995497CEA956AE515D2261898FA0510" "15728E5A8AAAC42DAD33170D04507A33" "A85521ABDF1CBA64ECFB850458DBEF0A" "8AEA71575D060C7DB3970F85A6E1E4C7" "ABF5AE8CDB0933D71E8C94E04A25619D" "CEE3D2261AD2EE6BF12FFA06D98A0864" "D87602733EC86A64521F2B18177B200C" "BBE117577A615D6C770988C0BAD946E2" "08E24FA074E5AB3143DB5BFCE0FD108E" "4B82D120A92108011A723C12A787E6D7" "88719A10BDBA5B2699C327186AF4E23C" "1A946834B6150BDA2583E9CA2AD44CE8" "DBBBC2DB04DE8EF92E8EFC141FBECAA6" "287C59474E6BC05D99B2964FA090C3A2" "233BA186515BE7ED1F612970CEE2D7AF" "B81BDD762170481CD0069127D5B05AA9" "93B4EA988D8FDDC186FFB7DC90A6C08F" "4DF435C934063199FFFFFFFFFFFFFFFF" }; WOLFSSL_ENTER("wolfSSL_DH_4096_prime"); if (wolfSSL_BN_hex2bn(&bn, prm) != SSL_SUCCESS) { WOLFSSL_MSG("Error converting DH 4096 prime to big number"); return NULL; } return bn; } /* This sets a big number with the 6144-bit prime from RFC 3526. * * bn if not NULL then the big number structure is used. If NULL then a new * big number structure is created. * * Returns a WOLFSSL_BIGNUM structure on success and NULL with failure. */ WOLFSSL_BIGNUM* wolfSSL_DH_6144_prime(WOLFSSL_BIGNUM* bn) { const char prm[] = { "FFFFFFFFFFFFFFFFC90FDAA22168C234" "C4C6628B80DC1CD129024E088A67CC74" "020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F1437" "4FE1356D6D51C245E485B576625E7EC6" "F44C42E9A637ED6B0BFF5CB6F406B7ED" "EE386BFB5A899FA5AE9F24117C4B1FE6" "49286651ECE45B3DC2007CB8A163BF05" "98DA48361C55D39A69163FA8FD24CF5F" "83655D23DCA3AD961C62F356208552BB" "9ED529077096966D670C354E4ABC9804" "F1746C08CA18217C32905E462E36CE3B" "E39E772C180E86039B2783A2EC07A28F" "B5C55DF06F4C52C9DE2BCBF695581718" "3995497CEA956AE515D2261898FA0510" "15728E5A8AAAC42DAD33170D04507A33" "A85521ABDF1CBA64ECFB850458DBEF0A" "8AEA71575D060C7DB3970F85A6E1E4C7" "ABF5AE8CDB0933D71E8C94E04A25619D" "CEE3D2261AD2EE6BF12FFA06D98A0864" "D87602733EC86A64521F2B18177B200C" "BBE117577A615D6C770988C0BAD946E2" "08E24FA074E5AB3143DB5BFCE0FD108E" "4B82D120A92108011A723C12A787E6D7" "88719A10BDBA5B2699C327186AF4E23C" "1A946834B6150BDA2583E9CA2AD44CE8" "DBBBC2DB04DE8EF92E8EFC141FBECAA6" "287C59474E6BC05D99B2964FA090C3A2" "233BA186515BE7ED1F612970CEE2D7AF" "B81BDD762170481CD0069127D5B05AA9" "93B4EA988D8FDDC186FFB7DC90A6C08F" "4DF435C93402849236C3FAB4D27C7026" "C1D4DCB2602646DEC9751E763DBA37BD" "F8FF9406AD9E530EE5DB382F413001AE" "B06A53ED9027D831179727B0865A8918" "DA3EDBEBCF9B14ED44CE6CBACED4BB1B" "DB7F1447E6CC254B332051512BD7AF42" "6FB8F401378CD2BF5983CA01C64B92EC" "F032EA15D1721D03F482D7CE6E74FEF6" "D55E702F46980C82B5A84031900B1C9E" "59E7C97FBEC7E8F323A97A7E36CC88BE" "0F1D45B7FF585AC54BD407B22B4154AA" "CC8F6D7EBF48E1D814CC5ED20F8037E0" "A79715EEF29BE32806A1D58BB7C5DA76" "F550AA3D8A1FBFF0EB19CCB1A313D55C" "DA56C9EC2EF29632387FE8D76E3C0468" "043E8F663F4860EE12BF2D5B0B7474D6" "E694F91E6DCC4024FFFFFFFFFFFFFFFF" }; WOLFSSL_ENTER("wolfSSL_DH_6144_prime"); if (wolfSSL_BN_hex2bn(&bn, prm) != SSL_SUCCESS) { WOLFSSL_MSG("Error converting DH 6144 prime to big number"); return NULL; } return bn; } /* This sets a big number with the 8192-bit prime from RFC 3526. * * bn if not NULL then the big number structure is used. If NULL then a new * big number structure is created. * * Returns a WOLFSSL_BIGNUM structure on success and NULL with failure. */ WOLFSSL_BIGNUM* wolfSSL_DH_8192_prime(WOLFSSL_BIGNUM* bn) { const char prm[] = { "FFFFFFFFFFFFFFFFC90FDAA22168C234" "C4C6628B80DC1CD129024E088A67CC74" "020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F1437" "4FE1356D6D51C245E485B576625E7EC6" "F44C42E9A637ED6B0BFF5CB6F406B7ED" "EE386BFB5A899FA5AE9F24117C4B1FE6" "49286651ECE45B3DC2007CB8A163BF05" "98DA48361C55D39A69163FA8FD24CF5F" "83655D23DCA3AD961C62F356208552BB" "9ED529077096966D670C354E4ABC9804" "F1746C08CA18217C32905E462E36CE3B" "E39E772C180E86039B2783A2EC07A28F" "B5C55DF06F4C52C9DE2BCBF695581718" "3995497CEA956AE515D2261898FA0510" "15728E5A8AAAC42DAD33170D04507A33" "A85521ABDF1CBA64ECFB850458DBEF0A" "8AEA71575D060C7DB3970F85A6E1E4C7" "ABF5AE8CDB0933D71E8C94E04A25619D" "CEE3D2261AD2EE6BF12FFA06D98A0864" "D87602733EC86A64521F2B18177B200C" "BBE117577A615D6C770988C0BAD946E2" "08E24FA074E5AB3143DB5BFCE0FD108E" "4B82D120A92108011A723C12A787E6D7" "88719A10BDBA5B2699C327186AF4E23C" "1A946834B6150BDA2583E9CA2AD44CE8" "DBBBC2DB04DE8EF92E8EFC141FBECAA6" "287C59474E6BC05D99B2964FA090C3A2" "233BA186515BE7ED1F612970CEE2D7AF" "B81BDD762170481CD0069127D5B05AA9" "93B4EA988D8FDDC186FFB7DC90A6C08F" "4DF435C93402849236C3FAB4D27C7026" "C1D4DCB2602646DEC9751E763DBA37BD" "F8FF9406AD9E530EE5DB382F413001AE" "B06A53ED9027D831179727B0865A8918" "DA3EDBEBCF9B14ED44CE6CBACED4BB1B" "DB7F1447E6CC254B332051512BD7AF42" "6FB8F401378CD2BF5983CA01C64B92EC" "F032EA15D1721D03F482D7CE6E74FEF6" "D55E702F46980C82B5A84031900B1C9E" "59E7C97FBEC7E8F323A97A7E36CC88BE" "0F1D45B7FF585AC54BD407B22B4154AA" "CC8F6D7EBF48E1D814CC5ED20F8037E0" "A79715EEF29BE32806A1D58BB7C5DA76" "F550AA3D8A1FBFF0EB19CCB1A313D55C" "DA56C9EC2EF29632387FE8D76E3C0468" "043E8F663F4860EE12BF2D5B0B7474D6" "E694F91E6DBE115974A3926F12FEE5E4" "38777CB6A932DF8CD8BEC4D073B931BA" "3BC832B68D9DD300741FA7BF8AFC47ED" "2576F6936BA424663AAB639C5AE4F568" "3423B4742BF1C978238F16CBE39D652D" "E3FDB8BEFC848AD922222E04A4037C07" "13EB57A81A23F0C73473FC646CEA306B" "4BCBC8862F8385DDFA9D4B7FA2C087E8" "79683303ED5BDD3A062B3CF5B3A278A6" "6D2A13F83F44F82DDF310EE074AB6A36" "4597E899A0255DC164F31CC50846851D" "F9AB48195DED7EA1B1D510BD7EE74D73" "FAF36BC31ECFA268359046F4EB879F92" "4009438B481C6CD7889A002ED5EE382B" "C9190DA6FC026E479558E4475677E9AA" "9E3050E2765694DFC81F56E880B96E71" "60C980DD98EDD3DFFFFFFFFFFFFFFFFF" }; WOLFSSL_ENTER("wolfSSL_DH_8192_prime"); if (wolfSSL_BN_hex2bn(&bn, prm) != SSL_SUCCESS) { WOLFSSL_MSG("Error converting DH 8192 prime to big number"); return NULL; } return bn; } /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_DH_generate_key(WOLFSSL_DH* dh) { int ret = WOLFSSL_FAILURE; word32 pubSz = 0; word32 privSz = 0; int initTmpRng = 0; WC_RNG* rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG; #else WC_RNG tmpRNG[1]; #endif unsigned char* pub = NULL; unsigned char* priv = NULL; WOLFSSL_MSG("wolfSSL_DH_generate_key"); #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) { XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); return ret; } #endif if (dh == NULL || dh->p == NULL || dh->g == NULL) WOLFSSL_MSG("Bad function arguments"); else if (dh->inSet == 0 && SetDhInternal(dh) != WOLFSSL_SUCCESS) WOLFSSL_MSG("Bad DH set internal"); else if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng) { pubSz = wolfSSL_BN_num_bytes(dh->p); if (dh->length) { privSz = dh->length/8; /* to bytes */ } else { privSz = pubSz; } pub = (unsigned char*)XMALLOC(pubSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); priv = (unsigned char*)XMALLOC(privSz, NULL, DYNAMIC_TYPE_PRIVATE_KEY); if (pub == NULL || priv == NULL) { WOLFSSL_MSG("Unable to malloc memory"); } else if (wc_DhGenerateKeyPair((DhKey*)dh->internal, rng, priv, &privSz, pub, &pubSz) < 0) WOLFSSL_MSG("Bad wc_DhGenerateKeyPair"); else { if (dh->pub_key) wolfSSL_BN_free(dh->pub_key); dh->pub_key = wolfSSL_BN_new(); if (dh->pub_key == NULL) { WOLFSSL_MSG("Bad DH new pub"); } if (dh->priv_key) wolfSSL_BN_free(dh->priv_key); dh->priv_key = wolfSSL_BN_new(); if (dh->priv_key == NULL) { WOLFSSL_MSG("Bad DH new priv"); } if (dh->pub_key && dh->priv_key) { if (wolfSSL_BN_bin2bn(pub, pubSz, dh->pub_key) == NULL) WOLFSSL_MSG("Bad DH bn2bin error pub"); else if (wolfSSL_BN_bin2bn(priv, privSz, dh->priv_key) == NULL) WOLFSSL_MSG("Bad DH bn2bin error priv"); else ret = WOLFSSL_SUCCESS; } } } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif XFREE(pub, NULL, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(priv, NULL, DYNAMIC_TYPE_PRIVATE_KEY); return ret; } /* return code compliant with OpenSSL : * size of shared secret if success, -1 if error */ int wolfSSL_DH_compute_key(unsigned char* key, WOLFSSL_BIGNUM* otherPub, WOLFSSL_DH* dh) { int ret = WOLFSSL_FATAL_ERROR; word32 keySz = 0; int pubSz = 1024; int privSz = 1024; #ifdef WOLFSSL_SMALL_STACK unsigned char* pub; unsigned char* priv = NULL; #else unsigned char pub [1024]; unsigned char priv[1024]; #endif WOLFSSL_MSG("wolfSSL_DH_compute_key"); #ifdef WOLFSSL_SMALL_STACK pub = (unsigned char*)XMALLOC(pubSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); if (pub == NULL) return ret; priv = (unsigned char*)XMALLOC(privSz, NULL, DYNAMIC_TYPE_PRIVATE_KEY); if (priv == NULL) { XFREE(pub, NULL, DYNAMIC_TYPE_PUBLIC_KEY); return ret; } #endif if (dh == NULL || dh->priv_key == NULL || otherPub == NULL) WOLFSSL_MSG("Bad function arguments"); else if ((keySz = (word32)DH_size(dh)) == 0) WOLFSSL_MSG("Bad DH_size"); else if (wolfSSL_BN_bn2bin(dh->priv_key, NULL) > (int)privSz) WOLFSSL_MSG("Bad priv internal size"); else if (wolfSSL_BN_bn2bin(otherPub, NULL) > (int)pubSz) WOLFSSL_MSG("Bad otherPub size"); else { privSz = wolfSSL_BN_bn2bin(dh->priv_key, priv); pubSz = wolfSSL_BN_bn2bin(otherPub, pub); if (dh->inSet == 0 && SetDhInternal(dh) != SSL_SUCCESS){ WOLFSSL_MSG("Bad DH set internal"); } if (privSz <= 0 || pubSz <= 0) WOLFSSL_MSG("Bad BN2bin set"); else if (wc_DhAgree((DhKey*)dh->internal, key, &keySz, priv, privSz, pub, pubSz) < 0) WOLFSSL_MSG("wc_DhAgree failed"); else ret = (int)keySz; } #ifdef WOLFSSL_SMALL_STACK XFREE(pub, NULL, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(priv, NULL, DYNAMIC_TYPE_PRIVATE_KEY); #endif return ret; } #if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L /* ownership of p,q,and g get taken over by "dh" on success and should be free'd * with a call to wolfSSL_DH_free -- not individually. * * returns WOLFSSL_SUCCESS on success */ int wolfSSL_DH_set0_pqg(WOLFSSL_DH *dh, WOLFSSL_BIGNUM *p, WOLFSSL_BIGNUM *q, WOLFSSL_BIGNUM *g) { int ret; WOLFSSL_ENTER("wolfSSL_DH_set0_pqg"); /* q can be NULL */ if (dh == NULL || p == NULL || g == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } /* free existing internal DH structure and recreate with new p / g */ if (dh->inSet) { ret = wc_FreeDhKey((DhKey*)dh->internal); if (ret != 0) { WOLFSSL_MSG("Unable to free internal DH key"); return WOLFSSL_FAILURE; } } wolfSSL_BN_free(dh->p); wolfSSL_BN_free(dh->q); wolfSSL_BN_free(dh->g); wolfSSL_BN_free(dh->pub_key); wolfSSL_BN_free(dh->priv_key); dh->p = p; dh->q = q; dh->g = g; ret = SetDhInternal(dh); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Unable to set internal DH key"); dh->p = NULL; dh->q = NULL; dh->g = NULL; dh->inSet = 0; return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #endif /* v1.1.0 or later */ #endif /* NO_DH */ #ifndef NO_DSA static void InitwolfSSL_DSA(WOLFSSL_DSA* dsa) { if (dsa) { dsa->p = NULL; dsa->q = NULL; dsa->g = NULL; dsa->pub_key = NULL; dsa->priv_key = NULL; dsa->internal = NULL; dsa->inSet = 0; dsa->exSet = 0; } } WOLFSSL_DSA* wolfSSL_DSA_new(void) { WOLFSSL_DSA* external; DsaKey* key; WOLFSSL_MSG("wolfSSL_DSA_new"); key = (DsaKey*) XMALLOC(sizeof(DsaKey), NULL, DYNAMIC_TYPE_DSA); if (key == NULL) { WOLFSSL_MSG("wolfSSL_DSA_new malloc DsaKey failure"); return NULL; } external = (WOLFSSL_DSA*) XMALLOC(sizeof(WOLFSSL_DSA), NULL, DYNAMIC_TYPE_DSA); if (external == NULL) { WOLFSSL_MSG("wolfSSL_DSA_new malloc WOLFSSL_DSA failure"); XFREE(key, NULL, DYNAMIC_TYPE_DSA); return NULL; } InitwolfSSL_DSA(external); if (wc_InitDsaKey(key) != 0) { WOLFSSL_MSG("wolfSSL_DSA_new InitDsaKey failure"); XFREE(key, NULL, DYNAMIC_TYPE_DSA); wolfSSL_DSA_free(external); return NULL; } external->internal = key; return external; } void wolfSSL_DSA_free(WOLFSSL_DSA* dsa) { WOLFSSL_MSG("wolfSSL_DSA_free"); if (dsa) { if (dsa->internal) { FreeDsaKey((DsaKey*)dsa->internal); XFREE(dsa->internal, NULL, DYNAMIC_TYPE_DSA); dsa->internal = NULL; } wolfSSL_BN_free(dsa->priv_key); wolfSSL_BN_free(dsa->pub_key); wolfSSL_BN_free(dsa->g); wolfSSL_BN_free(dsa->q); wolfSSL_BN_free(dsa->p); InitwolfSSL_DSA(dsa); /* set back to NULLs for safety */ XFREE(dsa, NULL, DYNAMIC_TYPE_DSA); /* dsa = NULL, don't try to access or double free it */ } } #endif /* NO_DSA */ #endif /* OPENSSL_EXTRA */ #ifdef OPENSSL_EXTRA #ifndef NO_DSA /* wolfSSL -> OpenSSL */ int SetDsaExternal(WOLFSSL_DSA* dsa) { DsaKey* key; WOLFSSL_MSG("Entering SetDsaExternal"); if (dsa == NULL || dsa->internal == NULL) { WOLFSSL_MSG("dsa key NULL error"); return WOLFSSL_FATAL_ERROR; } key = (DsaKey*)dsa->internal; if (SetIndividualExternal(&dsa->p, &key->p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa p key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&dsa->q, &key->q) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa q key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&dsa->g, &key->g) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa g key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&dsa->pub_key, &key->y) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa y key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&dsa->priv_key, &key->x) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa x key error"); return WOLFSSL_FATAL_ERROR; } dsa->exSet = 1; return WOLFSSL_SUCCESS; } /* Openssl -> WolfSSL */ int SetDsaInternal(WOLFSSL_DSA* dsa) { DsaKey* key; WOLFSSL_MSG("Entering SetDsaInternal"); if (dsa == NULL || dsa->internal == NULL) { WOLFSSL_MSG("dsa key NULL error"); return WOLFSSL_FATAL_ERROR; } key = (DsaKey*)dsa->internal; if (dsa->p != NULL && SetIndividualInternal(dsa->p, &key->p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa p key error"); return WOLFSSL_FATAL_ERROR; } if (dsa->q != NULL && SetIndividualInternal(dsa->q, &key->q) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa q key error"); return WOLFSSL_FATAL_ERROR; } if (dsa->g != NULL && SetIndividualInternal(dsa->g, &key->g) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa g key error"); return WOLFSSL_FATAL_ERROR; } if (dsa->pub_key != NULL) { if (SetIndividualInternal(dsa->pub_key, &key->y) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa pub_key error"); return WOLFSSL_FATAL_ERROR; } /* public key */ key->type = DSA_PUBLIC; } if (dsa->priv_key != NULL) { if (SetIndividualInternal(dsa->priv_key, &key->x) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa priv_key error"); return WOLFSSL_FATAL_ERROR; } /* private key */ key->type = DSA_PRIVATE; } dsa->inSet = 1; return WOLFSSL_SUCCESS; } #endif /* NO_DSA */ #endif /* OPENSSL_EXTRA */ #ifdef OPENSSL_EXTRA #if !defined(NO_RSA) /* Generates a RSA key of length len * * len length of RSA key i.e. 2048 * e e to use when generating RSA key * f callback function for generation details * data user callback argument * * Note: Because of wc_MakeRsaKey an RSA key size generated can be slightly * rounded down. For example generating a key of size 2999 with e = * 65537 will make a key of size 374 instead of 375. * Returns a new RSA key on success and NULL on failure */ WOLFSSL_RSA* wolfSSL_RSA_generate_key(int len, unsigned long e, void(*f)(int, int, void*), void* data) { WOLFSSL_RSA* rsa = NULL; WOLFSSL_BIGNUM* bn = NULL; WOLFSSL_ENTER("wolfSSL_RSA_generate_key"); (void)f; (void)data; if (len < 0) { WOLFSSL_MSG("Bad argument: length was less than 0"); return NULL; } bn = wolfSSL_BN_new(); if (bn == NULL) { WOLFSSL_MSG("Error creating big number"); return NULL; } if (wolfSSL_BN_set_word(bn, (WOLFSSL_BN_ULONG)e) != SSL_SUCCESS) { WOLFSSL_MSG("Error using e value"); wolfSSL_BN_free(bn); return NULL; } rsa = wolfSSL_RSA_new(); if (rsa == NULL) { WOLFSSL_MSG("memory error"); } else { if (wolfSSL_RSA_generate_key_ex(rsa, len, bn, NULL) != SSL_SUCCESS){ wolfSSL_RSA_free(rsa); rsa = NULL; } } wolfSSL_BN_free(bn); return rsa; } /* return compliant with OpenSSL * 1 if success, 0 if error */ int wolfSSL_RSA_generate_key_ex(WOLFSSL_RSA* rsa, int bits, WOLFSSL_BIGNUM* bn, void* cb) { int ret = WOLFSSL_FAILURE; (void)cb; (void)bn; (void)bits; WOLFSSL_ENTER("wolfSSL_RSA_generate_key_ex"); if (rsa == NULL || rsa->internal == NULL) { /* bit size checked during make key call */ WOLFSSL_MSG("bad arguments"); return WOLFSSL_FAILURE; } #ifdef WOLFSSL_KEY_GEN { #ifdef WOLFSSL_SMALL_STACK WC_RNG* rng; #else WC_RNG rng[1]; #endif #ifdef WOLFSSL_SMALL_STACK rng = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (rng == NULL) return WOLFSSL_FAILURE; #endif if (wc_InitRng(rng) < 0) WOLFSSL_MSG("RNG init failed"); else if (wc_MakeRsaKey((RsaKey*)rsa->internal, bits, wolfSSL_BN_get_word(bn), rng) != MP_OKAY) WOLFSSL_MSG("wc_MakeRsaKey failed"); else if (SetRsaExternal(rsa) != WOLFSSL_SUCCESS) WOLFSSL_MSG("SetRsaExternal failed"); else { rsa->inSet = 1; ret = WOLFSSL_SUCCESS; } wc_FreeRng(rng); #ifdef WOLFSSL_SMALL_STACK XFREE(rng, NULL, DYNAMIC_TYPE_RNG); #endif } #else WOLFSSL_MSG("No Key Gen built in"); #endif return ret; } #endif /* NO_RSA */ #ifndef NO_DSA /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_DSA_generate_key(WOLFSSL_DSA* dsa) { int ret = WOLFSSL_FAILURE; WOLFSSL_ENTER("wolfSSL_DSA_generate_key"); if (dsa == NULL || dsa->internal == NULL) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } if (dsa->inSet == 0) { WOLFSSL_MSG("No DSA internal set, do it"); if (SetDsaInternal(dsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetDsaInternal failed"); return ret; } } #ifdef WOLFSSL_KEY_GEN { int initTmpRng = 0; WC_RNG *rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG *tmpRNG; #else WC_RNG tmpRNG[1]; #endif #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return WOLFSSL_FATAL_ERROR; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng) { if (wc_MakeDsaKey(rng, (DsaKey*)dsa->internal) != MP_OKAY) WOLFSSL_MSG("wc_MakeDsaKey failed"); else if (SetDsaExternal(dsa) != WOLFSSL_SUCCESS) WOLFSSL_MSG("SetDsaExternal failed"); else ret = WOLFSSL_SUCCESS; } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif } #else /* WOLFSSL_KEY_GEN */ WOLFSSL_MSG("No Key Gen built in"); #endif return ret; } /* Returns a pointer to a new WOLFSSL_DSA structure on success and NULL on fail */ WOLFSSL_DSA* wolfSSL_DSA_generate_parameters(int bits, unsigned char* seed, int seedLen, int* counterRet, unsigned long* hRet, WOLFSSL_BN_CB cb, void* CBArg) { WOLFSSL_DSA* dsa; WOLFSSL_ENTER("wolfSSL_DSA_generate_parameters()"); (void)cb; (void)CBArg; dsa = wolfSSL_DSA_new(); if (dsa == NULL) { return NULL; } if (wolfSSL_DSA_generate_parameters_ex(dsa, bits, seed, seedLen, counterRet, hRet, NULL) != SSL_SUCCESS) { wolfSSL_DSA_free(dsa); return NULL; } return dsa; } /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_DSA_generate_parameters_ex(WOLFSSL_DSA* dsa, int bits, unsigned char* seed, int seedLen, int* counterRet, unsigned long* hRet, void* cb) { int ret = WOLFSSL_FAILURE; (void)bits; (void)seed; (void)seedLen; (void)counterRet; (void)hRet; (void)cb; WOLFSSL_ENTER("wolfSSL_DSA_generate_parameters_ex"); if (dsa == NULL || dsa->internal == NULL) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } #ifdef WOLFSSL_KEY_GEN { int initTmpRng = 0; WC_RNG *rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG *tmpRNG; #else WC_RNG tmpRNG[1]; #endif #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return WOLFSSL_FATAL_ERROR; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng) { if (wc_MakeDsaParameters(rng, bits, (DsaKey*)dsa->internal) != MP_OKAY) WOLFSSL_MSG("wc_MakeDsaParameters failed"); else if (SetDsaExternal(dsa) != WOLFSSL_SUCCESS) WOLFSSL_MSG("SetDsaExternal failed"); else ret = WOLFSSL_SUCCESS; } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif } #else /* WOLFSSL_KEY_GEN */ WOLFSSL_MSG("No Key Gen built in"); #endif return ret; } WOLFSSL_DSA_SIG* wolfSSL_DSA_SIG_new(void) { WOLFSSL_DSA_SIG* sig; WOLFSSL_ENTER("wolfSSL_DSA_SIG_new"); sig = (WOLFSSL_DSA_SIG*)XMALLOC(sizeof(WOLFSSL_DSA_SIG), NULL, DYNAMIC_TYPE_OPENSSL); if (sig) XMEMSET(sig, 0, sizeof(WOLFSSL_DSA_SIG)); return sig; } void wolfSSL_DSA_SIG_free(WOLFSSL_DSA_SIG *sig) { WOLFSSL_ENTER("wolfSSL_DSA_SIG_free"); if (sig) { if (sig->r) { wolfSSL_BN_free(sig->r); } if (sig->s) { wolfSSL_BN_free(sig->s); } XFREE(sig, NULL, DYNAMIC_TYPE_OPENSSL); } } /* return WOLFSSL_SUCCESS on success, < 0 otherwise */ int wolfSSL_DSA_do_sign(const unsigned char* d, unsigned char* sigRet, WOLFSSL_DSA* dsa) { int ret = WOLFSSL_FATAL_ERROR; int initTmpRng = 0; WC_RNG* rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; #else WC_RNG tmpRNG[1]; #endif WOLFSSL_ENTER("wolfSSL_DSA_do_sign"); if (d == NULL || sigRet == NULL || dsa == NULL) { WOLFSSL_MSG("Bad function arguments"); return ret; } if (dsa->inSet == 0) { WOLFSSL_MSG("No DSA internal set, do it"); if (SetDsaInternal(dsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetDsaInternal failed"); return ret; } } #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return WOLFSSL_FATAL_ERROR; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng) { if (DsaSign(d, sigRet, (DsaKey*)dsa->internal, rng) < 0) WOLFSSL_MSG("DsaSign failed"); else ret = WOLFSSL_SUCCESS; } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return ret; } #if !defined(HAVE_SELFTEST) && !defined(HAVE_FIPS) WOLFSSL_DSA_SIG* wolfSSL_DSA_do_sign_ex(const unsigned char* digest, int outLen, WOLFSSL_DSA* dsa) { WOLFSSL_DSA_SIG* sig = NULL; byte sigBin[DSA_SIG_SIZE]; WOLFSSL_ENTER("wolfSSL_DSA_do_sign_ex"); if (!digest || !dsa || outLen != WC_SHA_DIGEST_SIZE) { WOLFSSL_MSG("Bad function arguments"); return NULL; } if (wolfSSL_DSA_do_sign(digest, sigBin, dsa) != WOLFSSL_SUCCESS) { return NULL; } if (!(sig = wolfSSL_DSA_SIG_new())) { goto error; } if (!(sig->r = wolfSSL_BN_bin2bn(sigBin, DSA_HALF_SIZE, NULL))) { goto error; } if (!(sig->s = wolfSSL_BN_bin2bn(sigBin + DSA_HALF_SIZE, DSA_HALF_SIZE, NULL))) { goto error; } return sig; error: if (sig) { wolfSSL_DSA_SIG_free(sig); } return NULL; } #endif /* !HAVE_SELFTEST && !HAVE_FIPS */ int wolfSSL_DSA_do_verify(const unsigned char* d, unsigned char* sig, WOLFSSL_DSA* dsa, int *dsacheck) { int ret = WOLFSSL_FATAL_ERROR; WOLFSSL_ENTER("wolfSSL_DSA_do_verify"); if (d == NULL || sig == NULL || dsa == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FATAL_ERROR; } if (dsa->inSet == 0) { WOLFSSL_MSG("No DSA internal set, do it"); if (SetDsaInternal(dsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetDsaInternal failed"); return WOLFSSL_FATAL_ERROR; } } ret = DsaVerify(d, sig, (DsaKey*)dsa->internal, dsacheck); if (ret != 0 || *dsacheck != 1) { WOLFSSL_MSG("DsaVerify failed"); return ret; } return WOLFSSL_SUCCESS; } #if !defined(HAVE_SELFTEST) && !defined(HAVE_FIPS) int wolfSSL_DSA_do_verify_ex(const unsigned char* digest, int digest_len, WOLFSSL_DSA_SIG* sig, WOLFSSL_DSA* dsa) { int dsacheck, sz; byte sigBin[DSA_SIG_SIZE]; byte* sigBinPtr = sigBin; WOLFSSL_ENTER("wolfSSL_DSA_do_verify_ex"); if (!digest || !sig || !dsa || digest_len != WC_SHA_DIGEST_SIZE) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } if (!sig->r || !sig->s) { WOLFSSL_MSG("No signature found in DSA_SIG"); return WOLFSSL_FAILURE; } /* front pad with zeros */ if (!(sz = wolfSSL_BN_num_bytes(sig->r))) { return WOLFSSL_FAILURE; } while (sz++ < DSA_HALF_SIZE) { *sigBinPtr++ = 0; } if (wolfSSL_BN_bn2bin(sig->r, sigBinPtr) == WOLFSSL_FATAL_ERROR) { return WOLFSSL_FAILURE; } /* Move to s */ sigBinPtr = sigBin + DSA_HALF_SIZE; /* front pad with zeros */ if (!(sz = wolfSSL_BN_num_bytes(sig->s))) { return WOLFSSL_FAILURE; } while (sz++ < DSA_HALF_SIZE) { *sigBinPtr++ = 0; } if (wolfSSL_BN_bn2bin(sig->s, sigBinPtr) == WOLFSSL_FATAL_ERROR) { return WOLFSSL_FAILURE; } if (wolfSSL_DSA_do_verify(digest, sigBin, dsa, &dsacheck) != WOLFSSL_SUCCESS || dsacheck != 1) { return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #endif /* !HAVE_SELFTEST && !HAVE_FIPS */ #endif /* NO_DSA */ #if !defined(NO_RSA) && !defined(HAVE_USER_RSA) #ifdef DEBUG_SIGN static void show(const char *title, const unsigned char *out, unsigned int outlen) { const unsigned char *pt; printf("%s[%d] = \n", title, (int)outlen); outlen = outlen>100?100:outlen; for (pt = out; pt < out + outlen; printf("%c", ((*pt)&0x6f)>='A'?((*pt)&0x6f):'.'), pt++); printf("\n"); } #else #define show(a,b,c) #endif /* return SSL_SUCCESS on ok, 0 otherwise */ int wolfSSL_RSA_sign(int type, const unsigned char* m, unsigned int mLen, unsigned char* sigRet, unsigned int* sigLen, WOLFSSL_RSA* rsa) { return wolfSSL_RSA_sign_ex(type, m, mLen, sigRet, sigLen, rsa, 1); } int wolfSSL_RSA_sign_ex(int type, const unsigned char* m, unsigned int mLen, unsigned char* sigRet, unsigned int* sigLen, WOLFSSL_RSA* rsa, int flag) { word32 outLen; word32 signSz; int initTmpRng = 0; WC_RNG* rng = NULL; int ret = 0; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; byte* encodedSig = NULL; #else WC_RNG tmpRNG[1]; byte encodedSig[MAX_ENCODED_SIG_SZ]; #endif WOLFSSL_ENTER("wolfSSL_RSA_sign"); if (m == NULL || sigRet == NULL || sigLen == NULL || rsa == NULL) { WOLFSSL_MSG("Bad function arguments"); return 0; } show("Message to Sign", m, mLen); switch (type) { #ifdef WOLFSSL_MD2 case NID_md2: type = MD2h; break; #endif #ifndef NO_MD5 case NID_md5: type = MD5h; break; #endif #ifndef NO_SHA case NID_sha1: type = SHAh; break; #endif #ifndef NO_SHA256 case NID_sha256: type = SHA256h; break; #endif #ifdef WOLFSSL_SHA384 case NID_sha384: type = SHA384h; break; #endif #ifdef WOLFSSL_SHA512 case NID_sha512: type = SHA512h; break; #endif #ifndef WOLFSSL_NOSHA3_224 case NID_sha3_224: type = SHA3_224h; break; #endif #ifndef WOLFSSL_NOSHA3_256 case NID_sha3_256: type = SHA3_256h; break; #endif #ifndef WOLFSSL_NOSHA3_384 case NID_sha3_384: type = SHA3_384h; break; #endif #ifndef WOLFSSL_NOSHA3_512 case NID_sha3_512: type = SHA3_512h; break; #endif default: WOLFSSL_MSG("This NID (md type) not configured or not implemented"); return 0; } if (rsa->inSet == 0) { WOLFSSL_MSG("No RSA internal set, do it"); if (SetRsaInternal(rsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetRsaInternal failed"); return 0; } } outLen = (word32)wolfSSL_BN_num_bytes(rsa->n); #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return 0; encodedSig = (byte*)XMALLOC(MAX_ENCODED_SIG_SZ, NULL, DYNAMIC_TYPE_SIGNATURE); if (encodedSig == NULL) { XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); return 0; } #endif if (outLen == 0) WOLFSSL_MSG("Bad RSA size"); else if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng) { signSz = wc_EncodeSignature(encodedSig, m, mLen, type); if (signSz == 0) { WOLFSSL_MSG("Bad Encode Signature"); } else { show("Encoded Message", encodedSig, signSz); if (flag != 0) { ret = wc_RsaSSL_Sign(encodedSig, signSz, sigRet, outLen, (RsaKey*)rsa->internal, rng); if (ret <= 0) { WOLFSSL_MSG("Bad Rsa Sign"); ret = 0; } else { *sigLen = (unsigned int)ret; ret = SSL_SUCCESS; show("Signature", sigRet, *sigLen); } } else { ret = SSL_SUCCESS; XMEMCPY(sigRet, encodedSig, signSz); *sigLen = signSz; } } } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); XFREE(encodedSig, NULL, DYNAMIC_TYPE_SIGNATURE); #endif if (ret == WOLFSSL_SUCCESS) WOLFSSL_MSG("wolfSSL_RSA_sign success"); else { WOLFSSL_MSG("wolfSSL_RSA_sign failed"); } return ret; } /* returns WOLFSSL_SUCCESS on successful verify and WOLFSSL_FAILURE on fail */ int wolfSSL_RSA_verify(int type, const unsigned char* m, unsigned int mLen, const unsigned char* sig, unsigned int sigLen, WOLFSSL_RSA* rsa) { int ret; unsigned char *sigRet ; unsigned char *sigDec ; unsigned int len; WOLFSSL_ENTER("wolfSSL_RSA_verify"); if ((m == NULL) || (sig == NULL)) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } sigRet = (unsigned char *)XMALLOC(sigLen, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (sigRet == NULL) { WOLFSSL_MSG("Memory failure"); return WOLFSSL_FAILURE; } sigDec = (unsigned char *)XMALLOC(sigLen, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (sigDec == NULL) { WOLFSSL_MSG("Memory failure"); XFREE(sigRet, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } /* get non-encrypted signature to be compared with decrypted signature */ ret = wolfSSL_RSA_sign_ex(type, m, mLen, sigRet, &len, rsa, 0); if (ret <= 0) { WOLFSSL_MSG("Message Digest Error"); XFREE(sigRet, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(sigDec, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } show("Encoded Message", sigRet, len); /* decrypt signature */ ret = wc_RsaSSL_Verify(sig, sigLen, (unsigned char *)sigDec, sigLen, (RsaKey*)rsa->internal); if (ret <= 0) { WOLFSSL_MSG("RSA Decrypt error"); XFREE(sigRet, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(sigDec, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } show("Decrypted Signature", sigDec, ret); if ((int)len == ret && XMEMCMP(sigRet, sigDec, ret) == 0) { WOLFSSL_MSG("wolfSSL_RSA_verify success"); XFREE(sigRet, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(sigDec, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_SUCCESS; } else { WOLFSSL_MSG("wolfSSL_RSA_verify failed"); XFREE(sigRet, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(sigDec, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } } void wolfSSL_RSA_get0_key(const WOLFSSL_RSA *r, const WOLFSSL_BIGNUM **n, const WOLFSSL_BIGNUM **e, const WOLFSSL_BIGNUM **d) { WOLFSSL_ENTER("wolfSSL_RSA_get0_key"); if (r != NULL) { if (n != NULL) *n = r->n; if (e != NULL) *e = r->e; if (d != NULL) *d = r->d; } else { if (n != NULL) *n = NULL; if (e != NULL) *e = NULL; if (d != NULL) *d = NULL; } } /* generate p-1 and q-1, WOLFSSL_SUCCESS on ok */ int wolfSSL_RSA_GenAdd(WOLFSSL_RSA* rsa) { int err; mp_int tmp; WOLFSSL_MSG("wolfSSL_RsaGenAdd"); if (rsa == NULL || rsa->p == NULL || rsa->q == NULL || rsa->d == NULL || rsa->dmp1 == NULL || rsa->dmq1 == NULL) { WOLFSSL_MSG("rsa no init error"); return WOLFSSL_FATAL_ERROR; } if (mp_init(&tmp) != MP_OKAY) { WOLFSSL_MSG("mp_init error"); return WOLFSSL_FATAL_ERROR; } err = mp_sub_d((mp_int*)rsa->p->internal, 1, &tmp); if (err != MP_OKAY) { WOLFSSL_MSG("mp_sub_d error"); } else err = mp_mod((mp_int*)rsa->d->internal, &tmp, (mp_int*)rsa->dmp1->internal); if (err != MP_OKAY) { WOLFSSL_MSG("mp_mod error"); } else err = mp_sub_d((mp_int*)rsa->q->internal, 1, &tmp); if (err != MP_OKAY) { WOLFSSL_MSG("mp_sub_d error"); } else err = mp_mod((mp_int*)rsa->d->internal, &tmp, (mp_int*)rsa->dmq1->internal); mp_clear(&tmp); if (err == MP_OKAY) return WOLFSSL_SUCCESS; else return WOLFSSL_FATAL_ERROR; } #endif /* !NO_RSA && !HAVE_USER_RSA */ WOLFSSL_HMAC_CTX* wolfSSL_HMAC_CTX_new(void) { return (WOLFSSL_HMAC_CTX*)XMALLOC(sizeof(WOLFSSL_HMAC_CTX), NULL, DYNAMIC_TYPE_OPENSSL); } int wolfSSL_HMAC_CTX_Init(WOLFSSL_HMAC_CTX* ctx) { WOLFSSL_MSG("wolfSSL_HMAC_CTX_Init"); if (ctx != NULL) { /* wc_HmacSetKey sets up ctx->hmac */ XMEMSET(ctx, 0, sizeof(WOLFSSL_HMAC_CTX)); } return WOLFSSL_SUCCESS; } int wolfSSL_HMAC_Init_ex(WOLFSSL_HMAC_CTX* ctx, const void* key, int keylen, const EVP_MD* type, WOLFSSL_ENGINE* e) { WOLFSSL_ENTER("wolfSSL_HMAC_Init_ex"); /* WOLFSSL_ENGINE not used, call wolfSSL_HMAC_Init */ (void)e; return wolfSSL_HMAC_Init(ctx, key, keylen, type); } /* helper function for Deep copy of internal wolfSSL hmac structure * returns WOLFSSL_SUCCESS on success */ int wolfSSL_HmacCopy(Hmac* des, Hmac* src) { void* heap; #ifndef HAVE_FIPS heap = src->heap; #else heap = NULL; #endif if (wc_HmacInit(des, heap, 0) != 0) { return WOLFSSL_FAILURE; } /* requires that hash structures have no dynamic parts to them */ switch (src->macType) { #ifndef NO_MD5 case WC_MD5: wc_Md5Copy(&src->hash.md5, &des->hash.md5); break; #endif /* !NO_MD5 */ #ifndef NO_SHA case WC_SHA: wc_ShaCopy(&src->hash.sha, &des->hash.sha); break; #endif /* !NO_SHA */ #ifdef WOLFSSL_SHA224 case WC_SHA224: wc_Sha224Copy(&src->hash.sha224, &des->hash.sha224); break; #endif /* WOLFSSL_SHA224 */ #ifndef NO_SHA256 case WC_SHA256: wc_Sha256Copy(&src->hash.sha256, &des->hash.sha256); break; #endif /* !NO_SHA256 */ #ifdef WOLFSSL_SHA384 case WC_SHA384: wc_Sha384Copy(&src->hash.sha384, &des->hash.sha384); break; #endif /* WOLFSSL_SHA384 */ #ifdef WOLFSSL_SHA512 case WC_SHA512: wc_Sha512Copy(&src->hash.sha512, &des->hash.sha512); break; #endif /* WOLFSSL_SHA512 */ default: return WOLFSSL_FAILURE; } XMEMCPY((byte*)des->ipad, (byte*)src->ipad, WC_HMAC_BLOCK_SIZE); XMEMCPY((byte*)des->opad, (byte*)src->opad, WC_HMAC_BLOCK_SIZE); XMEMCPY((byte*)des->innerHash, (byte*)src->innerHash, WC_MAX_DIGEST_SIZE); #ifndef HAVE_FIPS des->heap = heap; #endif des->macType = src->macType; des->innerHashKeyed = src->innerHashKeyed; #ifdef WOLFSSL_ASYNC_CRYPT XMEMCPY(&des->asyncDev, &src->asyncDev, sizeof(WC_ASYNC_DEV)); des->keyLen = src->keyLen; #ifdef HAVE_CAVIUM des->data = (byte*)XMALLOC(src->dataLen, des->heap, DYNAMIC_TYPE_HMAC); if (des->data == NULL) { return BUFFER_E; } XMEMCPY(des->data, src->data, src->dataLen); des->dataLen = src->dataLen; #endif /* HAVE_CAVIUM */ #endif /* WOLFSSL_ASYNC_CRYPT */ return WOLFSSL_SUCCESS; } /* Deep copy of information from src to des structure * * des destination to copy information to * src structure to get information from * * Returns WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on error */ int wolfSSL_HMAC_CTX_copy(WOLFSSL_HMAC_CTX* des, WOLFSSL_HMAC_CTX* src) { WOLFSSL_ENTER("wolfSSL_HMAC_CTX_copy"); if (des == NULL || src == NULL) { return WOLFSSL_FAILURE; } des->type = src->type; XMEMCPY((byte *)&des->save_ipad, (byte *)&src->hmac.ipad, WC_HMAC_BLOCK_SIZE); XMEMCPY((byte *)&des->save_opad, (byte *)&src->hmac.opad, WC_HMAC_BLOCK_SIZE); return wolfSSL_HmacCopy(&des->hmac, &src->hmac); } #if defined(HAVE_FIPS) && \ (!defined(HAVE_FIPS_VERSION) || (HAVE_FIPS_VERSION < 2)) static int _HMAC_Init(Hmac* hmac, int type, void* heap) { int ret = 0; switch (type) { #ifndef NO_MD5 case WC_MD5: ret = wc_InitMd5(&hmac->hash.md5); break; #endif /* !NO_MD5 */ #ifndef NO_SHA case WC_SHA: ret = wc_InitSha(&hmac->hash.sha); break; #endif /* !NO_SHA */ #ifdef WOLFSSL_SHA224 case WC_SHA224: ret = wc_InitSha224(&hmac->hash.sha224); break; #endif /* WOLFSSL_SHA224 */ #ifndef NO_SHA256 case WC_SHA256: ret = wc_InitSha256(&hmac->hash.sha256); break; #endif /* !NO_SHA256 */ #ifdef WOLFSSL_SHA384 case WC_SHA384: ret = wc_InitSha384(&hmac->hash.sha384); break; #endif /* WOLFSSL_SHA384 */ #ifdef WOLFSSL_SHA512 case WC_SHA512: ret = wc_InitSha512(&hmac->hash.sha512); break; #endif /* WOLFSSL_SHA512 */ #ifdef WOLFSSL_SHA3 case WC_SHA3_224: ret = wc_InitSha3_224(&hmac->hash.sha3, heap, INVALID_DEVID); break; case WC_SHA3_256: ret = wc_InitSha3_256(&hmac->hash.sha3, heap, INVALID_DEVID); break; case WC_SHA3_384: ret = wc_InitSha3_384(&hmac->hash.sha3, heap, INVALID_DEVID); break; case WC_SHA3_512: ret = wc_InitSha3_512(&hmac->hash.sha3, heap, INVALID_DEVID); break; #endif default: ret = BAD_FUNC_ARG; break; } (void)heap; return ret; } #else #define _HMAC_Init _InitHmac #endif int wolfSSL_HMAC_Init(WOLFSSL_HMAC_CTX* ctx, const void* key, int keylen, const EVP_MD* type) { int hmac_error = 0; void* heap = NULL; WOLFSSL_MSG("wolfSSL_HMAC_Init"); if (ctx == NULL) { WOLFSSL_MSG("no ctx on init"); return WOLFSSL_FAILURE; } #ifndef HAVE_FIPS heap = ctx->hmac.heap; #endif if (type) { WOLFSSL_MSG("init has type"); #ifndef NO_MD5 if (XSTRNCMP(type, "MD5", 3) == 0) { WOLFSSL_MSG("md5 hmac"); ctx->type = WC_MD5; } else #endif #ifdef WOLFSSL_SHA224 if (XSTRNCMP(type, "SHA224", 6) == 0) { WOLFSSL_MSG("sha224 hmac"); ctx->type = WC_SHA224; } else #endif #ifndef NO_SHA256 if (XSTRNCMP(type, "SHA256", 6) == 0) { WOLFSSL_MSG("sha256 hmac"); ctx->type = WC_SHA256; } else #endif #ifdef WOLFSSL_SHA384 if (XSTRNCMP(type, "SHA384", 6) == 0) { WOLFSSL_MSG("sha384 hmac"); ctx->type = WC_SHA384; } else #endif #ifdef WOLFSSL_SHA512 if (XSTRNCMP(type, "SHA512", 6) == 0) { WOLFSSL_MSG("sha512 hmac"); ctx->type = WC_SHA512; } else #endif #ifndef NO_SHA /* has to be last since would pick or 256, 384, or 512 too */ if (XSTRNCMP(type, "SHA", 3) == 0) { WOLFSSL_MSG("sha hmac"); ctx->type = WC_SHA; } else #endif { WOLFSSL_MSG("bad init type"); return WOLFSSL_FAILURE; } } if (key && keylen) { WOLFSSL_MSG("keying hmac"); if (wc_HmacInit(&ctx->hmac, NULL, INVALID_DEVID) == 0) { hmac_error = wc_HmacSetKey(&ctx->hmac, ctx->type, (const byte*)key, (word32)keylen); if (hmac_error < 0){ wc_HmacFree(&ctx->hmac); return WOLFSSL_FAILURE; } XMEMCPY((byte *)&ctx->save_ipad, (byte *)&ctx->hmac.ipad, WC_HMAC_BLOCK_SIZE); XMEMCPY((byte *)&ctx->save_opad, (byte *)&ctx->hmac.opad, WC_HMAC_BLOCK_SIZE); } /* OpenSSL compat, no error */ } else if(ctx->type >= 0) { /* MD5 == 0 */ WOLFSSL_MSG("recover hmac"); wc_HmacFree(&ctx->hmac); if (wc_HmacInit(&ctx->hmac, NULL, INVALID_DEVID) == 0) { ctx->hmac.macType = (byte)ctx->type; ctx->hmac.innerHashKeyed = 0; XMEMCPY((byte *)&ctx->hmac.ipad, (byte *)&ctx->save_ipad, WC_HMAC_BLOCK_SIZE); XMEMCPY((byte *)&ctx->hmac.opad, (byte *)&ctx->save_opad, WC_HMAC_BLOCK_SIZE); if ((hmac_error = _HMAC_Init(&ctx->hmac, ctx->hmac.macType, heap)) !=0) { return hmac_error; } } } (void)hmac_error; return WOLFSSL_SUCCESS; } int wolfSSL_HMAC_Update(WOLFSSL_HMAC_CTX* ctx, const unsigned char* data, int len) { int hmac_error = 0; WOLFSSL_MSG("wolfSSL_HMAC_Update"); if (ctx == NULL) { WOLFSSL_MSG("no ctx"); return WOLFSSL_FAILURE; } if (data) { WOLFSSL_MSG("updating hmac"); hmac_error = wc_HmacUpdate(&ctx->hmac, data, (word32)len); if (hmac_error < 0){ WOLFSSL_MSG("hmac update error"); return WOLFSSL_FAILURE; } } return WOLFSSL_SUCCESS; } int wolfSSL_HMAC_Final(WOLFSSL_HMAC_CTX* ctx, unsigned char* hash, unsigned int* len) { int hmac_error; WOLFSSL_MSG("wolfSSL_HMAC_Final"); /* "len" parameter is optional. */ if (ctx == NULL || hash == NULL) { WOLFSSL_MSG("invalid parameter"); return WOLFSSL_FAILURE; } WOLFSSL_MSG("final hmac"); hmac_error = wc_HmacFinal(&ctx->hmac, hash); if (hmac_error < 0){ WOLFSSL_MSG("final hmac error"); return WOLFSSL_FAILURE; } if (len) { WOLFSSL_MSG("setting output len"); switch (ctx->type) { #ifndef NO_MD5 case WC_MD5: *len = WC_MD5_DIGEST_SIZE; break; #endif #ifndef NO_SHA case WC_SHA: *len = WC_SHA_DIGEST_SIZE; break; #endif #ifdef WOLFSSL_SHA224 case WC_SHA224: *len = WC_SHA224_DIGEST_SIZE; break; #endif #ifndef NO_SHA256 case WC_SHA256: *len = WC_SHA256_DIGEST_SIZE; break; #endif #ifdef WOLFSSL_SHA384 case WC_SHA384: *len = WC_SHA384_DIGEST_SIZE; break; #endif #ifdef WOLFSSL_SHA512 case WC_SHA512: *len = WC_SHA512_DIGEST_SIZE; break; #endif default: WOLFSSL_MSG("bad hmac type"); return WOLFSSL_FAILURE; } } return WOLFSSL_SUCCESS; } int wolfSSL_HMAC_cleanup(WOLFSSL_HMAC_CTX* ctx) { WOLFSSL_MSG("wolfSSL_HMAC_cleanup"); if (ctx) wc_HmacFree(&ctx->hmac); return SSL_SUCCESS; } void wolfSSL_HMAC_CTX_free(WOLFSSL_HMAC_CTX* ctx) { if (!ctx) { return; } wolfSSL_HMAC_cleanup(ctx); XFREE(ctx, NULL, DYNAMIC_TYPE_OPENSSL); } size_t wolfSSL_HMAC_size(const WOLFSSL_HMAC_CTX *ctx) { if (!ctx) { return 0; } return (size_t)wc_HashGetDigestSize((enum wc_HashType)ctx->hmac.macType); } #ifndef NO_DES3 void wolfSSL_3des_iv(WOLFSSL_EVP_CIPHER_CTX* ctx, int doset, unsigned char* iv, int len) { (void)len; WOLFSSL_MSG("wolfSSL_3des_iv"); if (ctx == NULL || iv == NULL) { WOLFSSL_MSG("Bad function argument"); return; } if (doset) wc_Des3_SetIV(&ctx->cipher.des3, iv); /* OpenSSL compat, no ret */ else XMEMCPY(iv, &ctx->cipher.des3.reg, DES_BLOCK_SIZE); } #endif /* NO_DES3 */ #ifndef NO_AES void wolfSSL_aes_ctr_iv(WOLFSSL_EVP_CIPHER_CTX* ctx, int doset, unsigned char* iv, int len) { (void)len; WOLFSSL_MSG("wolfSSL_aes_ctr_iv"); if (ctx == NULL || iv == NULL) { WOLFSSL_MSG("Bad function argument"); return; } if (doset) (void)wc_AesSetIV(&ctx->cipher.aes, iv); /* OpenSSL compat, no ret */ else XMEMCPY(iv, &ctx->cipher.aes.reg, AES_BLOCK_SIZE); } #endif /* NO_AES */ /* Free the dynamically allocated data. * * p Pointer to dynamically allocated memory. */ void wolfSSL_OPENSSL_free(void* p) { WOLFSSL_MSG("wolfSSL_OPENSSL_free"); XFREE(p, NULL, DYNAMIC_TYPE_OPENSSL); } void *wolfSSL_OPENSSL_malloc(size_t a) { return XMALLOC(a, NULL, DYNAMIC_TYPE_OPENSSL); } #if defined(WOLFSSL_KEY_GEN) && defined(WOLFSSL_PEM_TO_DER) static int EncryptDerKey(byte *der, int *derSz, const EVP_CIPHER* cipher, unsigned char* passwd, int passwdSz, byte **cipherInfo) { int ret, paddingSz; word32 idx, cipherInfoSz; #ifdef WOLFSSL_SMALL_STACK EncryptedInfo* info = NULL; #else EncryptedInfo info[1]; #endif WOLFSSL_ENTER("EncryptDerKey"); if (der == NULL || derSz == NULL || cipher == NULL || passwd == NULL || cipherInfo == NULL) return BAD_FUNC_ARG; #ifdef WOLFSSL_SMALL_STACK info = (EncryptedInfo*)XMALLOC(sizeof(EncryptedInfo), NULL, DYNAMIC_TYPE_ENCRYPTEDINFO); if (info == NULL) { WOLFSSL_MSG("malloc failed"); return WOLFSSL_FAILURE; } #endif XMEMSET(info, 0, sizeof(EncryptedInfo)); /* set the cipher name on info */ XSTRNCPY(info->name, cipher, NAME_SZ-1); info->name[NAME_SZ-1] = '\0'; /* null term */ ret = wc_EncryptedInfoGet(info, info->name); if (ret != 0) { WOLFSSL_MSG("unsupported cipher"); #ifdef WOLFSSL_SMALL_STACK XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO); #endif return WOLFSSL_FAILURE; } /* Generate a random salt */ if (wolfSSL_RAND_bytes(info->iv, info->ivSz) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("generate iv failed"); #ifdef WOLFSSL_SMALL_STACK XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO); #endif return WOLFSSL_FAILURE; } /* add the padding before encryption */ paddingSz = ((*derSz)/info->ivSz + 1) * info->ivSz - (*derSz); if (paddingSz == 0) paddingSz = info->ivSz; XMEMSET(der+(*derSz), (byte)paddingSz, paddingSz); (*derSz) += paddingSz; /* encrypt buffer */ if (wc_BufferKeyEncrypt(info, der, *derSz, passwd, passwdSz, WC_MD5) != 0) { WOLFSSL_MSG("encrypt key failed"); #ifdef WOLFSSL_SMALL_STACK XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO); #endif return WOLFSSL_FAILURE; } /* create cipher info : 'cipher_name,Salt(hex)' */ cipherInfoSz = (word32)(2*info->ivSz + XSTRLEN(info->name) + 2); *cipherInfo = (byte*)XMALLOC(cipherInfoSz, NULL, DYNAMIC_TYPE_STRING); if (*cipherInfo == NULL) { WOLFSSL_MSG("malloc failed"); #ifdef WOLFSSL_SMALL_STACK XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO); #endif return WOLFSSL_FAILURE; } XSTRNCPY((char*)*cipherInfo, info->name, cipherInfoSz); XSTRNCAT((char*)*cipherInfo, ",", 2); idx = (word32)XSTRLEN((char*)*cipherInfo); cipherInfoSz -= idx; ret = Base16_Encode(info->iv, info->ivSz, *cipherInfo+idx, &cipherInfoSz); #ifdef WOLFSSL_SMALL_STACK XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO); #endif if (ret != 0) { WOLFSSL_MSG("Base16_Encode failed"); XFREE(*cipherInfo, NULL, DYNAMIC_TYPE_STRING); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_KEY_GEN || WOLFSSL_PEM_TO_DER */ #if defined(WOLFSSL_KEY_GEN) && !defined(NO_RSA) && !defined(HAVE_USER_RSA) static int wolfSSL_RSA_To_Der(WOLFSSL_RSA* rsa, byte** outBuf, int publicKey) { int derSz = 0; int ret; byte* derBuf; WOLFSSL_ENTER("wolfSSL_RSA_To_Der"); if (!rsa || (publicKey != 0 && publicKey != 1)) { WOLFSSL_LEAVE("wolfSSL_RSA_To_Der", BAD_FUNC_ARG); return BAD_FUNC_ARG; } if (rsa->inSet == 0) { if ((ret = SetRsaInternal(rsa)) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetRsaInternal() Failed"); WOLFSSL_LEAVE("wolfSSL_RSA_To_Der", ret); return ret; } } if (publicKey) { if ((derSz = wc_RsaPublicKeyDerSize((RsaKey *)rsa->internal, 1)) < 0) { WOLFSSL_MSG("wc_RsaPublicKeyDerSize failed"); WOLFSSL_LEAVE("wolfSSL_RSA_To_Der", derSz); return derSz; } } else { if ((derSz = wc_RsaKeyToDer((RsaKey*)rsa->internal, NULL, 0)) < 0) { WOLFSSL_MSG("wc_RsaKeyToDer failed"); WOLFSSL_LEAVE("wolfSSL_RSA_To_Der", derSz); return derSz; } } if (outBuf) { if (!(derBuf = (byte*)XMALLOC(derSz, NULL, DYNAMIC_TYPE_TMP_BUFFER))) { WOLFSSL_MSG("malloc failed"); WOLFSSL_LEAVE("wolfSSL_RSA_To_Der", MEMORY_ERROR); return MEMORY_ERROR; } /* Key to DER */ if (publicKey) { derSz = wc_RsaKeyToPublicDer((RsaKey*)rsa->internal, derBuf, derSz); } else { derSz = wc_RsaKeyToDer((RsaKey*)rsa->internal, derBuf, derSz); } if (derSz < 0) { WOLFSSL_MSG("wc_RsaKeyToPublicDer failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER); } else { if (*outBuf) { XMEMCPY(*outBuf, derBuf, derSz); XFREE(derBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER); } else { *outBuf = derBuf; } } } WOLFSSL_LEAVE("wolfSSL_RSA_To_Der", derSz); return derSz; } #endif #if defined(WOLFSSL_KEY_GEN) || defined(WOLFSSL_CERT_GEN) #if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA) /* Takes a WOLFSSL_RSA key and writes it out to a WOLFSSL_BIO * * bio the WOLFSSL_BIO to write to * key the WOLFSSL_RSA key to write out * cipher cipher used * passwd password string if used * len length of password string * cb password callback to use * arg null terminated string for passphrase */ int wolfSSL_PEM_write_bio_RSAPrivateKey(WOLFSSL_BIO* bio, WOLFSSL_RSA* key, const WOLFSSL_EVP_CIPHER* cipher, unsigned char* passwd, int len, pem_password_cb* cb, void* arg) { int ret; WOLFSSL_EVP_PKEY* pkey; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_RSAPrivateKey"); if (bio == NULL || key == NULL) { WOLFSSL_MSG("Bad Function Arguments"); return WOLFSSL_FAILURE; } pkey = wolfSSL_EVP_PKEY_new_ex(bio->heap); if (pkey == NULL) { WOLFSSL_MSG("wolfSSL_EVP_PKEY_new_ex failed"); return WOLFSSL_FAILURE; } pkey->type = EVP_PKEY_RSA; pkey->rsa = key; pkey->ownRsa = 0; #if defined(WOLFSSL_KEY_GEN) && !defined(NO_RSA) && !defined(HAVE_USER_RSA) /* similar to how wolfSSL_PEM_write_mem_RSAPrivateKey finds DER of key */ { int derSz; byte* derBuf = NULL; if ((derSz = wolfSSL_RSA_To_Der(key, &derBuf, 0)) < 0) { WOLFSSL_MSG("wolfSSL_RSA_To_Der failed"); return WOLFSSL_FAILURE; } pkey->pkey.ptr = (char*)XMALLOC(derSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (pkey->pkey.ptr == NULL) { WOLFSSL_MSG("key malloc failed"); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } pkey->pkey_sz = derSz; XMEMCPY(pkey->pkey.ptr, derBuf, derSz); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); } #endif ret = wolfSSL_PEM_write_bio_PrivateKey(bio, pkey, cipher, passwd, len, cb, arg); wolfSSL_EVP_PKEY_free(pkey); return ret; } #if defined(WOLFSSL_KEY_GEN) && !defined(NO_RSA) && !defined(HAVE_USER_RSA) /* Takes an RSA public key and writes it out to a WOLFSSL_BIO * Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE */ int wolfSSL_PEM_write_bio_RSA_PUBKEY(WOLFSSL_BIO* bio, WOLFSSL_RSA* rsa) { int ret = 0, derSz = 0; byte *derBuf = NULL; WOLFSSL_EVP_PKEY* pkey = NULL; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_RSA_PUBKEY"); if (bio == NULL || rsa == NULL) { WOLFSSL_MSG("Bad Function Arguments"); return WOLFSSL_FAILURE; } /* Initialize pkey structure */ pkey = wolfSSL_EVP_PKEY_new_ex(bio->heap); if (pkey == NULL) { WOLFSSL_MSG("wolfSSL_EVP_PKEY_new_ex failed"); return WOLFSSL_FAILURE; } pkey->type = EVP_PKEY_RSA; pkey->rsa = rsa; pkey->ownRsa = 0; if ((derSz = wolfSSL_RSA_To_Der(rsa, &derBuf, 1)) < 0) { WOLFSSL_MSG("wolfSSL_RSA_To_Der failed"); return WOLFSSL_FAILURE; } pkey->pkey.ptr = (char*)XMALLOC(derSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (pkey->pkey.ptr == NULL) { WOLFSSL_MSG("key malloc failed"); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } pkey->pkey_sz = derSz; XMEMCPY(pkey->pkey.ptr, derBuf, derSz); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); ret = wolfSSL_PEM_write_bio_PUBKEY(bio, pkey); wolfSSL_EVP_PKEY_free(pkey); return ret; } #endif /* Reads an RSA public key from a WOLFSSL_BIO into a WOLFSSL_RSA * Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE */ WOLFSSL_RSA *wolfSSL_PEM_read_bio_RSA_PUBKEY(WOLFSSL_BIO* bio,WOLFSSL_RSA** rsa, pem_password_cb* cb, void *pass) { WOLFSSL_EVP_PKEY* pkey; WOLFSSL_RSA* local; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_RSA_PUBKEY"); pkey = wolfSSL_PEM_read_bio_PUBKEY(bio, NULL, cb, pass); if (pkey == NULL) { return NULL; } /* Since the WOLFSSL_RSA structure is being taken from WOLFSSL_EVP_PKEY the * flag indicating that the WOLFSSL_RSA structure is owned should be FALSE * to avoid having it free'd */ pkey->ownRsa = 0; local = pkey->rsa; if (rsa != NULL){ *rsa = local; } wolfSSL_EVP_PKEY_free(pkey); return local; } #endif /* defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL) && !defined(NO_RSA) */ /* Takes a public key and writes it out to a WOLFSSL_BIO * Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE */ int wolfSSL_PEM_write_bio_PUBKEY(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key) { byte* keyDer; int pemSz; int ret; byte* tmp; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_PUBKEY"); if (bio == NULL || key == NULL) { return WOLFSSL_FAILURE; } keyDer = (byte*)key->pkey.ptr; pemSz = wc_DerToPem(keyDer, key->pkey_sz, NULL, 0, PUBLICKEY_TYPE); if (pemSz < 0) { WOLFSSL_LEAVE("wolfSSL_PEM_write_bio_PUBKEY", pemSz); return WOLFSSL_FAILURE; } tmp = (byte*)XMALLOC(pemSz, bio->heap, DYNAMIC_TYPE_OPENSSL); if (tmp == NULL) { return MEMORY_E; } ret = wc_DerToPemEx(keyDer, key->pkey_sz, tmp, pemSz, NULL, PUBLICKEY_TYPE); if (ret < 0) { WOLFSSL_LEAVE("wolfSSL_PEM_write_bio_PUBKEY", ret); XFREE(tmp, bio->heap, DYNAMIC_TYPE_OPENSSL); return WOLFSSL_FAILURE; } ret = wolfSSL_BIO_write(bio, tmp, pemSz); XFREE(tmp, bio->heap, DYNAMIC_TYPE_OPENSSL); if (ret != pemSz) { WOLFSSL_MSG("Unable to write full PEM to BIO"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* Takes a private key and writes it out to a WOLFSSL_BIO * Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE */ int wolfSSL_PEM_write_bio_PrivateKey(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key, const WOLFSSL_EVP_CIPHER* cipher, unsigned char* passwd, int len, pem_password_cb* cb, void* arg) { byte* keyDer; int pemSz; int type; int ret; byte* tmp; (void)cipher; (void)passwd; (void)len; (void)cb; (void)arg; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_PrivateKey"); if (bio == NULL || key == NULL) { WOLFSSL_MSG("Bad Function Arguments"); return WOLFSSL_FAILURE; } keyDer = (byte*)key->pkey.ptr; switch (key->type) { #ifndef NO_RSA case EVP_PKEY_RSA: type = PRIVATEKEY_TYPE; break; #endif #ifndef NO_DSA case EVP_PKEY_DSA: type = DSA_PRIVATEKEY_TYPE; break; #endif #ifdef HAVE_ECC case EVP_PKEY_EC: type = ECC_PRIVATEKEY_TYPE; break; #endif #if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL)) case EVP_PKEY_DH: type = DH_PRIVATEKEY_TYPE; break; #endif default: WOLFSSL_MSG("Unknown Key type!"); type = PRIVATEKEY_TYPE; } pemSz = wc_DerToPem(keyDer, key->pkey_sz, NULL, 0, type); if (pemSz < 0) { WOLFSSL_LEAVE("wolfSSL_PEM_write_bio_PrivateKey", pemSz); return WOLFSSL_FAILURE; } tmp = (byte*)XMALLOC(pemSz, bio->heap, DYNAMIC_TYPE_OPENSSL); if (tmp == NULL) { return MEMORY_E; } ret = wc_DerToPemEx(keyDer, key->pkey_sz, tmp, pemSz, NULL, type); if (ret < 0) { WOLFSSL_LEAVE("wolfSSL_PEM_write_bio_PrivateKey", ret); XFREE(tmp, bio->heap, DYNAMIC_TYPE_OPENSSL); return WOLFSSL_FAILURE; } ret = wolfSSL_BIO_write(bio, tmp, pemSz); XFREE(tmp, bio->heap, DYNAMIC_TYPE_OPENSSL); if (ret != pemSz) { WOLFSSL_MSG("Unable to write full PEM to BIO"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #endif /* defined(WOLFSSL_KEY_GEN) || defined(WOLFSSL_CERT_GEN) */ #if (defined(WOLFSSL_KEY_GEN) && !defined(NO_RSA) && !defined(HAVE_USER_RSA)) && \ (defined(WOLFSSL_PEM_TO_DER) || defined(WOLFSSL_DER_TO_PEM)) /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_PEM_write_mem_RSAPrivateKey(RSA* rsa, const EVP_CIPHER* cipher, unsigned char* passwd, int passwdSz, unsigned char **pem, int *plen) { byte *derBuf = NULL, *tmp, *cipherInfo = NULL; int derSz = 0; const int type = PRIVATEKEY_TYPE; const char* header = NULL; const char* footer = NULL; WOLFSSL_ENTER("wolfSSL_PEM_write_mem_RSAPrivateKey"); if (pem == NULL || plen == NULL || rsa == NULL || rsa->internal == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } if (wc_PemGetHeaderFooter(type, &header, &footer) != 0) return WOLFSSL_FAILURE; if (rsa->inSet == 0) { WOLFSSL_MSG("No RSA internal set, do it"); if (SetRsaInternal(rsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetRsaInternal failed"); return WOLFSSL_FAILURE; } } if ((derSz = wolfSSL_RSA_To_Der(rsa, &derBuf, 0)) < 0) { WOLFSSL_MSG("wolfSSL_RSA_To_Der failed"); return WOLFSSL_FAILURE; } /* encrypt DER buffer if required */ if (passwd != NULL && passwdSz > 0 && cipher != NULL) { int ret; ret = EncryptDerKey(derBuf, &derSz, cipher, passwd, passwdSz, &cipherInfo); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("EncryptDerKey failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); return ret; } /* tmp buffer with a max size */ *plen = (derSz * 2) + (int)XSTRLEN(header) + 1 + (int)XSTRLEN(footer) + 1 + HEADER_ENCRYPTED_KEY_SIZE; } else { /* tmp buffer with a max size */ *plen = (derSz * 2) + (int)XSTRLEN(header) + 1 + (int)XSTRLEN(footer) + 1; } tmp = (byte*)XMALLOC(*plen, NULL, DYNAMIC_TYPE_PEM); if (tmp == NULL) { WOLFSSL_MSG("malloc failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); if (cipherInfo != NULL) XFREE(cipherInfo, NULL, DYNAMIC_TYPE_STRING); return WOLFSSL_FAILURE; } /* DER to PEM */ *plen = wc_DerToPemEx(derBuf, derSz, tmp, *plen, cipherInfo, type); if (*plen <= 0) { WOLFSSL_MSG("wc_DerToPemEx failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); if (cipherInfo != NULL) XFREE(cipherInfo, NULL, DYNAMIC_TYPE_STRING); return WOLFSSL_FAILURE; } XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); if (cipherInfo != NULL) XFREE(cipherInfo, NULL, DYNAMIC_TYPE_STRING); *pem = (byte*)XMALLOC((*plen)+1, NULL, DYNAMIC_TYPE_KEY); if (*pem == NULL) { WOLFSSL_MSG("malloc failed"); XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); return WOLFSSL_FAILURE; } XMEMSET(*pem, 0, (*plen)+1); if (XMEMCPY(*pem, tmp, *plen) == NULL) { WOLFSSL_MSG("XMEMCPY failed"); XFREE(pem, NULL, DYNAMIC_TYPE_KEY); XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); return WOLFSSL_FAILURE; } XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); return WOLFSSL_SUCCESS; } #ifndef NO_FILESYSTEM /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_PEM_write_RSAPrivateKey(XFILE fp, WOLFSSL_RSA *rsa, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u) { byte *pem; int plen, ret; (void)cb; (void)u; WOLFSSL_MSG("wolfSSL_PEM_write_RSAPrivateKey"); if (fp == XBADFILE || rsa == NULL || rsa->internal == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } ret = wolfSSL_PEM_write_mem_RSAPrivateKey(rsa, enc, kstr, klen, &pem, &plen); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("wolfSSL_PEM_write_mem_RSAPrivateKey failed"); return WOLFSSL_FAILURE; } ret = (int)XFWRITE(pem, plen, 1, fp); if (ret != 1) { WOLFSSL_MSG("RSA private key file write failed"); return WOLFSSL_FAILURE; } XFREE(pem, NULL, DYNAMIC_TYPE_KEY); return WOLFSSL_SUCCESS; } #endif /* NO_FILESYSTEM */ #endif /* WOLFSSL_KEY_GEN && !NO_RSA && !HAVE_USER_RSA && WOLFSSL_PEM_TO_DER */ #ifdef HAVE_ECC #ifdef ALT_ECC_SIZE static int SetIndividualInternalEcc(WOLFSSL_BIGNUM* bn, mp_int* mpi) { WOLFSSL_MSG("Entering SetIndividualInternal"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FATAL_ERROR; } if (mpi == NULL) { WOLFSSL_MSG("mpi NULL error"); return WOLFSSL_FATAL_ERROR; } if (mp_copy((mp_int*)bn->internal, mpi) != MP_OKAY) { WOLFSSL_MSG("mp_copy error"); return WOLFSSL_FATAL_ERROR; } return WOLFSSL_SUCCESS; } #endif /* ALT_ECC_SIZE */ /* EC_POINT Openssl -> WolfSSL */ static int SetECPointInternal(WOLFSSL_EC_POINT *p) { ecc_point* point; WOLFSSL_ENTER("SetECPointInternal"); if (p == NULL || p->internal == NULL) { WOLFSSL_MSG("ECPoint NULL error"); return WOLFSSL_FATAL_ERROR; } point = (ecc_point*)p->internal; #ifndef ALT_ECC_SIZE if (p->X != NULL && SetIndividualInternal(p->X, point->x) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ecc point X error"); return WOLFSSL_FATAL_ERROR; } if (p->Y != NULL && SetIndividualInternal(p->Y, point->y) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ecc point Y error"); return WOLFSSL_FATAL_ERROR; } if (p->Z != NULL && SetIndividualInternal(p->Z, point->z) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ecc point Z error"); return WOLFSSL_FATAL_ERROR; } #else if (p->X != NULL && SetIndividualInternalEcc(p->X, point->x) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ecc point X error"); return WOLFSSL_FATAL_ERROR; } if (p->Y != NULL && SetIndividualInternalEcc(p->Y, point->y) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ecc point Y error"); return WOLFSSL_FATAL_ERROR; } if (p->Z != NULL && SetIndividualInternalEcc(p->Z, point->z) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ecc point Z error"); return WOLFSSL_FATAL_ERROR; } #endif p->inSet = 1; return WOLFSSL_SUCCESS; } /* EC_POINT WolfSSL -> OpenSSL */ static int SetECPointExternal(WOLFSSL_EC_POINT *p) { ecc_point* point; WOLFSSL_ENTER("SetECPointExternal"); if (p == NULL || p->internal == NULL) { WOLFSSL_MSG("ECPoint NULL error"); return WOLFSSL_FATAL_ERROR; } point = (ecc_point*)p->internal; if (SetIndividualExternal(&p->X, point->x) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ecc point X error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&p->Y, point->y) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ecc point Y error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&p->Z, point->z) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ecc point Z error"); return WOLFSSL_FATAL_ERROR; } p->exSet = 1; return WOLFSSL_SUCCESS; } /* EC_KEY wolfSSL -> OpenSSL */ int SetECKeyExternal(WOLFSSL_EC_KEY* eckey) { ecc_key* key; WOLFSSL_ENTER("SetECKeyExternal"); if (eckey == NULL || eckey->internal == NULL) { WOLFSSL_MSG("ec key NULL error"); return WOLFSSL_FATAL_ERROR; } key = (ecc_key*)eckey->internal; /* set group (OID, nid and idx) */ eckey->group->curve_oid = ecc_sets[key->idx].oidSum; eckey->group->curve_nid = ecc_sets[key->idx].id; eckey->group->curve_idx = key->idx; if (eckey->pub_key->internal != NULL) { /* set the internal public key */ if (wc_ecc_copy_point(&key->pubkey, (ecc_point*)eckey->pub_key->internal) != MP_OKAY) { WOLFSSL_MSG("SetECKeyExternal ecc_copy_point failed"); return WOLFSSL_FATAL_ERROR; } /* set the external pubkey (point) */ if (SetECPointExternal(eckey->pub_key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECKeyExternal SetECPointExternal failed"); return WOLFSSL_FATAL_ERROR; } } /* set the external privkey */ if (key->type == ECC_PRIVATEKEY) { if (SetIndividualExternal(&eckey->priv_key, &key->k) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ec priv key error"); return WOLFSSL_FATAL_ERROR; } } eckey->exSet = 1; return WOLFSSL_SUCCESS; } /* EC_KEY Openssl -> WolfSSL */ int SetECKeyInternal(WOLFSSL_EC_KEY* eckey) { ecc_key* key; WOLFSSL_ENTER("SetECKeyInternal"); if (eckey == NULL || eckey->internal == NULL || eckey->group == NULL) { WOLFSSL_MSG("ec key NULL error"); return WOLFSSL_FATAL_ERROR; } key = (ecc_key*)eckey->internal; /* validate group */ if ((eckey->group->curve_idx < 0) || (wc_ecc_is_valid_idx(eckey->group->curve_idx) == 0)) { WOLFSSL_MSG("invalid curve idx"); return WOLFSSL_FATAL_ERROR; } /* set group (idx of curve and corresponding domain parameters) */ key->idx = eckey->group->curve_idx; key->dp = &ecc_sets[key->idx]; /* set pubkey (point) */ if (eckey->pub_key != NULL) { if (SetECPointInternal(eckey->pub_key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ec key pub error"); return WOLFSSL_FATAL_ERROR; } /* copy over the public point to key */ if (wc_ecc_copy_point((ecc_point*)eckey->pub_key->internal, &key->pubkey) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_copy_point error"); return WOLFSSL_FATAL_ERROR; } /* public key */ key->type = ECC_PUBLICKEY; } /* set privkey */ if (eckey->priv_key != NULL) { if (SetIndividualInternal(eckey->priv_key, &key->k) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("ec key priv error"); return WOLFSSL_FATAL_ERROR; } /* private key */ key->type = ECC_PRIVATEKEY; } eckey->inSet = 1; return WOLFSSL_SUCCESS; } WOLFSSL_EC_POINT *wolfSSL_EC_KEY_get0_public_key(const WOLFSSL_EC_KEY *key) { WOLFSSL_ENTER("wolfSSL_EC_KEY_get0_public_key"); if (key == NULL) { WOLFSSL_MSG("wolfSSL_EC_KEY_get0_public_key Bad arguments"); return NULL; } return key->pub_key; } const WOLFSSL_EC_GROUP *wolfSSL_EC_KEY_get0_group(const WOLFSSL_EC_KEY *key) { WOLFSSL_ENTER("wolfSSL_EC_KEY_get0_group"); if (key == NULL) { WOLFSSL_MSG("wolfSSL_EC_KEY_get0_group Bad arguments"); return NULL; } return key->group; } /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_EC_KEY_set_private_key(WOLFSSL_EC_KEY *key, const WOLFSSL_BIGNUM *priv_key) { WOLFSSL_ENTER("wolfSSL_EC_KEY_set_private_key"); if (key == NULL || priv_key == NULL) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } /* free key if previously set */ if (key->priv_key != NULL) wolfSSL_BN_free(key->priv_key); key->priv_key = wolfSSL_BN_dup(priv_key); if (key->priv_key == NULL) { WOLFSSL_MSG("key ecc priv key NULL"); return WOLFSSL_FAILURE; } if (SetECKeyInternal(key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECKeyInternal failed"); wolfSSL_BN_free(key->priv_key); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } WOLFSSL_BIGNUM *wolfSSL_EC_KEY_get0_private_key(const WOLFSSL_EC_KEY *key) { WOLFSSL_ENTER("wolfSSL_EC_KEY_get0_private_key"); if (key == NULL) { WOLFSSL_MSG("wolfSSL_EC_KEY_get0_private_key Bad arguments"); return NULL; } if (wolfSSL_BN_is_zero(key->priv_key)) { /* return NULL if not set */ return NULL; } return key->priv_key; } WOLFSSL_EC_KEY *wolfSSL_EC_KEY_new_by_curve_name(int nid) { WOLFSSL_EC_KEY *key; int x; int eccEnum; WOLFSSL_ENTER("wolfSSL_EC_KEY_new_by_curve_name"); /* If NID passed in is OpenSSL type, convert it to ecc_curve_id enum */ eccEnum = NIDToEccEnum(nid); if (eccEnum == -1) eccEnum = nid; key = wolfSSL_EC_KEY_new(); if (key == NULL) { WOLFSSL_MSG("wolfSSL_EC_KEY_new failure"); return NULL; } /* set the nid of the curve */ key->group->curve_nid = eccEnum; /* search and set the corresponding internal curve idx */ for (x = 0; ecc_sets[x].size != 0; x++) if (ecc_sets[x].id == key->group->curve_nid) { key->group->curve_idx = x; key->group->curve_oid = ecc_sets[x].oidSum; break; } return key; } const char* wolfSSL_EC_curve_nid2nist(int nid) { const WOLF_EC_NIST_NAME* nist_name; for (nist_name = kNistCurves; nist_name->name != NULL; nist_name++) { if (nist_name->nid == nid) { return kNistCurves->name; } } return NULL; } #ifdef WOLFSSL_TLS13 static int populate_groups(int* groups, int max_count, char *list) { char *end; int len; int count = 0; const WOLF_EC_NIST_NAME* nist_name; if (!groups || !list) { return -1; } for (end = list; ; list = ++end) { if (count > max_count) { WOLFSSL_MSG("Too many curves in list"); return -1; } while (*end != ':' && *end != '\0') end++; len = (int)(end - list); /* end points to char after end * of curve name so no need for -1 */ if ((len < kNistCurves_MIN_NAME_LEN) || (len > kNistCurves_MAX_NAME_LEN)) { WOLFSSL_MSG("Unrecognized curve name in list"); return -1; } for (nist_name = kNistCurves; nist_name->name != NULL; nist_name++) { if (len == nist_name->name_len && XSTRNCMP(list, nist_name->name, nist_name->name_len) == 0) { break; } } if (!nist_name->name) { WOLFSSL_MSG("Unrecognized curve name in list"); return -1; } groups[count++] = nist_name->nid; if (*end == '\0') break; } return count; } int wolfSSL_CTX_set1_groups_list(WOLFSSL_CTX *ctx, char *list) { int groups[WOLFSSL_MAX_GROUP_COUNT]; int count; if (!ctx || !list) { return WOLFSSL_FAILURE; } if ((count = populate_groups(groups, WOLFSSL_MAX_GROUP_COUNT, list)) == -1) { return WOLFSSL_FAILURE; } return wolfSSL_CTX_set_groups(ctx, groups, count) == WOLFSSL_SUCCESS ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE; } int wolfSSL_set1_groups_list(WOLFSSL *ssl, char *list) { int groups[WOLFSSL_MAX_GROUP_COUNT]; int count; if (!ssl || !list) { return WOLFSSL_FAILURE; } if ((count = populate_groups(groups, WOLFSSL_MAX_GROUP_COUNT, list)) == -1) { return WOLFSSL_FAILURE; } return wolfSSL_set_groups(ssl, groups, count) == WOLFSSL_SUCCESS ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE; } #endif /* WOLFSSL_TLS13 */ static void InitwolfSSL_ECKey(WOLFSSL_EC_KEY* key) { if (key) { key->group = NULL; key->pub_key = NULL; key->priv_key = NULL; key->internal = NULL; key->inSet = 0; key->exSet = 0; } } WOLFSSL_EC_KEY *wolfSSL_EC_KEY_new(void) { WOLFSSL_EC_KEY *external; WOLFSSL_ENTER("wolfSSL_EC_KEY_new"); external = (WOLFSSL_EC_KEY*)XMALLOC(sizeof(WOLFSSL_EC_KEY), NULL, DYNAMIC_TYPE_ECC); if (external == NULL) { WOLFSSL_MSG("wolfSSL_EC_KEY_new malloc WOLFSSL_EC_KEY failure"); return NULL; } XMEMSET(external, 0, sizeof(WOLFSSL_EC_KEY)); InitwolfSSL_ECKey(external); external->internal = (ecc_key*)XMALLOC(sizeof(ecc_key), NULL, DYNAMIC_TYPE_ECC); if (external->internal == NULL) { WOLFSSL_MSG("wolfSSL_EC_KEY_new malloc ecc key failure"); goto error; } XMEMSET(external->internal, 0, sizeof(ecc_key)); if (wc_ecc_init((ecc_key*)external->internal) != 0) { WOLFSSL_MSG("wolfSSL_EC_KEY_new init ecc key failure"); goto error; } /* curve group */ external->group = wolfSSL_EC_GROUP_new_by_curve_name(ECC_CURVE_DEF); if (external->group == NULL) { WOLFSSL_MSG("wolfSSL_EC_KEY_new malloc WOLFSSL_EC_GROUP failure"); goto error; } /* public key */ external->pub_key = wolfSSL_EC_POINT_new(external->group); if (external->pub_key == NULL) { WOLFSSL_MSG("wolfSSL_EC_POINT_new failure"); goto error; } /* private key */ external->priv_key = wolfSSL_BN_new(); if (external->priv_key == NULL) { WOLFSSL_MSG("wolfSSL_BN_new failure"); goto error; } return external; error: wolfSSL_EC_KEY_free(external); return NULL; } void wolfSSL_EC_KEY_free(WOLFSSL_EC_KEY *key) { WOLFSSL_ENTER("wolfSSL_EC_KEY_free"); if (key != NULL) { if (key->internal != NULL) { wc_ecc_free((ecc_key*)key->internal); XFREE(key->internal, NULL, DYNAMIC_TYPE_ECC); } wolfSSL_BN_free(key->priv_key); wolfSSL_EC_POINT_free(key->pub_key); wolfSSL_EC_GROUP_free(key->group); InitwolfSSL_ECKey(key); /* set back to NULLs for safety */ XFREE(key, NULL, DYNAMIC_TYPE_ECC); /* key = NULL, don't try to access or double free it */ } } #ifndef NO_WOLFSSL_STUB int wolfSSL_EC_KEY_set_group(WOLFSSL_EC_KEY *key, WOLFSSL_EC_GROUP *group) { (void)key; (void)group; WOLFSSL_ENTER("wolfSSL_EC_KEY_set_group"); WOLFSSL_STUB("EC_KEY_set_group"); return -1; } #endif int wolfSSL_EC_KEY_generate_key(WOLFSSL_EC_KEY *key) { int initTmpRng = 0; WC_RNG* rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; #else WC_RNG tmpRNG[1]; #endif WOLFSSL_ENTER("wolfSSL_EC_KEY_generate_key"); if (key == NULL || key->internal == NULL || key->group == NULL || key->group->curve_idx < 0) { WOLFSSL_MSG("wolfSSL_EC_KEY_generate_key Bad arguments"); return 0; } #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return 0; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng == NULL) { WOLFSSL_MSG("wolfSSL_EC_KEY_generate_key failed to set RNG"); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return 0; } if (wc_ecc_make_key_ex(rng, 0, (ecc_key*)key->internal, key->group->curve_nid) != MP_OKAY) { WOLFSSL_MSG("wolfSSL_EC_KEY_generate_key wc_ecc_make_key failed"); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return 0; } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif if (SetECKeyExternal(key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("wolfSSL_EC_KEY_generate_key SetECKeyExternal failed"); return 0; } return 1; } #ifndef NO_WOLFSSL_STUB void wolfSSL_EC_KEY_set_asn1_flag(WOLFSSL_EC_KEY *key, int asn1_flag) { (void)key; (void)asn1_flag; WOLFSSL_ENTER("wolfSSL_EC_KEY_set_asn1_flag"); WOLFSSL_STUB("EC_KEY_set_asn1_flag"); } #endif static int setupPoint(const WOLFSSL_EC_POINT *p) { if (!p) { return WOLFSSL_FAILURE; } if (p->inSet == 0) { WOLFSSL_MSG("No ECPoint internal set, do it"); if (SetECPointInternal((WOLFSSL_EC_POINT *)p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECPointInternal SetECPointInternal failed"); return WOLFSSL_FAILURE; } } return WOLFSSL_SUCCESS; } /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_EC_KEY_set_public_key(WOLFSSL_EC_KEY *key, const WOLFSSL_EC_POINT *pub) { ecc_point *pub_p, *key_p; WOLFSSL_ENTER("wolfSSL_EC_KEY_set_public_key"); if (key == NULL || key->internal == NULL || pub == NULL || pub->internal == NULL) { WOLFSSL_MSG("wolfSSL_EC_GROUP_get_order Bad arguments"); return WOLFSSL_FAILURE; } if (key->inSet == 0) { if (SetECKeyInternal(key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECKeyInternal failed"); return WOLFSSL_FAILURE; } } if (setupPoint(pub) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } pub_p = (ecc_point*)pub->internal; key_p = (ecc_point*)key->pub_key->internal; /* create new point if required */ if (key_p == NULL) key_p = wc_ecc_new_point(); if (key_p == NULL) { WOLFSSL_MSG("key ecc point NULL"); return WOLFSSL_FAILURE; } if (wc_ecc_copy_point(pub_p, key_p) != MP_OKAY) { WOLFSSL_MSG("ecc_copy_point failure"); return WOLFSSL_FAILURE; } if (SetECPointExternal(key->pub_key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECKeyInternal failed"); return WOLFSSL_FAILURE; } if (SetECKeyInternal(key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECKeyInternal failed"); return WOLFSSL_FAILURE; } wolfSSL_EC_POINT_dump("pub", pub); wolfSSL_EC_POINT_dump("key->pub_key", key->pub_key); return WOLFSSL_SUCCESS; } /* End EC_KEY */ int wolfSSL_ECDSA_size(const WOLFSSL_EC_KEY *key) { const EC_GROUP *group; int bits, bytes; word32 headerSz = 4; /* 2*ASN_TAG + 2*LEN(ENUM) */ if (!key) { return WOLFSSL_FAILURE; } if (!(group = wolfSSL_EC_KEY_get0_group(key))) { return WOLFSSL_FAILURE; } if ((bits = wolfSSL_EC_GROUP_order_bits(group)) == 0) { return WOLFSSL_FAILURE; } bytes = (bits + 7) / 8; /* bytes needed to hold bits */ return headerSz + 2 + /* possible leading zeroes in r and s */ bytes + bytes + /* r and s */ 2; } int wolfSSL_ECDSA_sign(int type, const unsigned char *digest, int digestSz, unsigned char *sig, unsigned int *sigSz, WOLFSSL_EC_KEY *key) { int ret = WOLFSSL_SUCCESS; WC_RNG* rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; #else WC_RNG tmpRNG[1]; #endif int initTmpRng = 0; WOLFSSL_ENTER("wolfSSL_ECDSA_sign"); if (!key) { return WOLFSSL_FAILURE; } #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return WOLFSSL_FAILURE; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) { WOLFSSL_MSG("Global RNG no Init"); } else { rng = &globalRNG; } } if (rng) { if (wc_ecc_sign_hash(digest, digestSz, sig, sigSz, rng, (ecc_key*)key->internal) != MP_OKAY) { ret = WOLFSSL_FAILURE; } if (initTmpRng) { wc_FreeRng(tmpRNG); } } else { ret = WOLFSSL_FAILURE; } #ifdef WOLFSSL_SMALL_STACK if (tmpRNG) XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif (void)type; return ret; } #ifndef HAVE_SELFTEST /* ECC point compression types were not included in selftest ecc.h */ char* wolfSSL_EC_POINT_point2hex(const WOLFSSL_EC_GROUP* group, const WOLFSSL_EC_POINT* point, int form, WOLFSSL_BN_CTX* ctx) { static const char* hexDigit = "0123456789ABCDEF"; char* hex = NULL; int id; int i, sz, len; (void)ctx; if (group == NULL || point == NULL) return NULL; id = wc_ecc_get_curve_id(group->curve_idx); if ((sz = wc_ecc_get_curve_size_from_id(id)) < 0) return NULL; len = sz + 1; if (form == POINT_CONVERSION_UNCOMPRESSED) len += sz; hex = (char*)XMALLOC(2 * len + 1, NULL, DYNAMIC_TYPE_ECC); if (hex == NULL) return NULL; XMEMSET(hex, 0, 2 * len + 1); /* Put in x-ordinate after format byte. */ i = sz - mp_unsigned_bin_size((mp_int*)point->X->internal) + 1; if (mp_to_unsigned_bin((mp_int*)point->X->internal, (byte*)(hex + i)) < 0) { XFREE(hex, NULL, DYNAMIC_TYPE_ECC); return NULL; } if (form == POINT_CONVERSION_COMPRESSED) { hex[0] = mp_isodd((mp_int*)point->Y->internal) ? ECC_POINT_COMP_ODD : ECC_POINT_COMP_EVEN; } else { hex[0] = ECC_POINT_UNCOMP; /* Put in y-ordinate after x-ordinate */ i = 1 + 2 * sz - mp_unsigned_bin_size((mp_int*)point->Y->internal); if (mp_to_unsigned_bin((mp_int*)point->Y->internal, (byte*)(hex + i)) < 0) { XFREE(hex, NULL, DYNAMIC_TYPE_ECC); return NULL; } } for (i = len-1; i >= 0; i--) { byte b = hex[i]; hex[i * 2 + 1] = hexDigit[b & 0xf]; hex[i * 2 ] = hexDigit[b >> 4]; } return hex; } #endif /* HAVE_SELFTEST */ void wolfSSL_EC_POINT_dump(const char *msg, const WOLFSSL_EC_POINT *p) { #if defined(DEBUG_WOLFSSL) char *num; WOLFSSL_ENTER("wolfSSL_EC_POINT_dump"); if (!WOLFSSL_IS_DEBUG_ON() || wolfSSL_GetLoggingCb()) { return; } if (p == NULL) { printf("%s = NULL", msg); return; } printf("%s:\n\tinSet=%d, exSet=%d\n", msg, p->inSet, p->exSet); num = wolfSSL_BN_bn2hex(p->X); printf("\tX = %s\n", num); XFREE(num, NULL, DYNAMIC_TYPE_ECC); num = wolfSSL_BN_bn2hex(p->Y); printf("\tY = %s\n", num); XFREE(num, NULL, DYNAMIC_TYPE_ECC); num = wolfSSL_BN_bn2hex(p->Z); printf("\tZ = %s\n", num); XFREE(num, NULL, DYNAMIC_TYPE_ECC); #else (void)msg; (void)p; #endif } /* Start EC_GROUP */ /* return code compliant with OpenSSL : * 0 if equal, 1 if not and -1 in case of error */ int wolfSSL_EC_GROUP_cmp(const WOLFSSL_EC_GROUP *a, const WOLFSSL_EC_GROUP *b, WOLFSSL_BN_CTX *ctx) { (void)ctx; WOLFSSL_ENTER("wolfSSL_EC_GROUP_cmp"); if (a == NULL || b == NULL) { WOLFSSL_MSG("wolfSSL_EC_GROUP_cmp Bad arguments"); return WOLFSSL_FATAL_ERROR; } /* ok */ if ((a->curve_idx == b->curve_idx) && (a->curve_nid == b->curve_nid)) return 0; /* ko */ return 1; } #endif /* HAVE_ECC */ #endif /* OPENSSL_EXTRA */ #if defined(HAVE_ECC) && (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) const WOLFSSL_EC_METHOD* wolfSSL_EC_GROUP_method_of( const WOLFSSL_EC_GROUP *group) { return group; } int wolfSSL_EC_METHOD_get_field_type(const WOLFSSL_EC_METHOD *meth) { if (meth) { return NID_X9_62_prime_field; } return WOLFSSL_FAILURE; } void wolfSSL_EC_GROUP_free(WOLFSSL_EC_GROUP *group) { WOLFSSL_ENTER("wolfSSL_EC_GROUP_free"); XFREE(group, NULL, DYNAMIC_TYPE_ECC); /* group = NULL, don't try to access or double free it */ } #endif #ifdef OPENSSL_EXTRA #ifdef HAVE_ECC #ifndef NO_WOLFSSL_STUB void wolfSSL_EC_GROUP_set_asn1_flag(WOLFSSL_EC_GROUP *group, int flag) { (void)group; (void)flag; WOLFSSL_ENTER("wolfSSL_EC_GROUP_set_asn1_flag"); WOLFSSL_STUB("EC_GROUP_set_asn1_flag"); } #endif WOLFSSL_EC_GROUP *wolfSSL_EC_GROUP_new_by_curve_name(int nid) { WOLFSSL_EC_GROUP *g; int x; int eccEnum; WOLFSSL_ENTER("wolfSSL_EC_GROUP_new_by_curve_name"); /* If NID passed in is OpenSSL type, convert it to ecc_curve_id enum */ eccEnum = NIDToEccEnum(nid); if (eccEnum == -1) eccEnum = nid; /* curve group */ g = (WOLFSSL_EC_GROUP*) XMALLOC(sizeof(WOLFSSL_EC_GROUP), NULL, DYNAMIC_TYPE_ECC); if (g == NULL) { WOLFSSL_MSG("wolfSSL_EC_GROUP_new_by_curve_name malloc failure"); return NULL; } XMEMSET(g, 0, sizeof(WOLFSSL_EC_GROUP)); /* set the nid of the curve */ g->curve_nid = eccEnum; if (eccEnum > ECC_CURVE_DEF) { /* search and set the corresponding internal curve idx */ for (x = 0; ecc_sets[x].size != 0; x++) if (ecc_sets[x].id == g->curve_nid) { g->curve_idx = x; g->curve_oid = ecc_sets[x].oidSum; break; } } return g; } /* return code compliant with OpenSSL : * the curve nid if success, 0 if error */ int wolfSSL_EC_GROUP_get_curve_name(const WOLFSSL_EC_GROUP *group) { int nid; WOLFSSL_ENTER("wolfSSL_EC_GROUP_get_curve_name"); if (group == NULL) { WOLFSSL_MSG("wolfSSL_EC_GROUP_get_curve_name Bad arguments"); return WOLFSSL_FAILURE; } /* If curve_nid is ECC Enum type, return corresponding OpenSSL nid */ if ((nid = EccEnumToNID(group->curve_nid)) != -1) return nid; return group->curve_nid; } /* return code compliant with OpenSSL : * the degree of the curve if success, 0 if error */ int wolfSSL_EC_GROUP_get_degree(const WOLFSSL_EC_GROUP *group) { int nid; int tmp; WOLFSSL_ENTER("wolfSSL_EC_GROUP_get_degree"); if (group == NULL || group->curve_idx < 0) { WOLFSSL_MSG("wolfSSL_EC_GROUP_get_degree Bad arguments"); return WOLFSSL_FAILURE; } /* If curve_nid passed in is an ecc_curve_id enum, convert it to the corresponding OpenSSL NID */ tmp = EccEnumToNID(group->curve_nid); if (tmp != -1){ nid = tmp; } else{ nid = group->curve_nid; } switch(nid) { case NID_secp112r1: case NID_secp112r2: return 112; case NID_secp128r1: case NID_secp128r2: return 128; case NID_secp160k1: case NID_secp160r1: case NID_secp160r2: case NID_brainpoolP160r1: return 160; case NID_secp192k1: case NID_brainpoolP192r1: case NID_X9_62_prime192v1: return 192; case NID_secp224k1: case NID_secp224r1: case NID_brainpoolP224r1: return 224; case NID_secp256k1: case NID_brainpoolP256r1: case NID_X9_62_prime256v1: return 256; case NID_brainpoolP320r1: return 320; case NID_secp384r1: case NID_brainpoolP384r1: return 384; case NID_secp521r1: return 521; case NID_brainpoolP512r1: return 512; default: return WOLFSSL_FAILURE; } } /* Converts OpenSSL NID value of ECC curves to the associated enum values in ecc_curve_id, used by ecc_sets[].*/ int NIDToEccEnum(int n) { WOLFSSL_ENTER("NIDToEccEnum()"); switch(n) { case NID_X9_62_prime192v1: return ECC_SECP192R1; case NID_X9_62_prime192v2: return ECC_PRIME192V2; case NID_X9_62_prime192v3: return ECC_PRIME192V3; case NID_X9_62_prime239v1: return ECC_PRIME239V1; case NID_X9_62_prime239v2: return ECC_PRIME239V2; case NID_X9_62_prime239v3: return ECC_PRIME239V3; case NID_X9_62_prime256v1: return ECC_SECP256R1; case NID_secp112r1: return ECC_SECP112R1; case NID_secp112r2: return ECC_SECP112R2; case NID_secp128r1: return ECC_SECP128R1; case NID_secp128r2: return ECC_SECP128R2; case NID_secp160r1: return ECC_SECP160R1; case NID_secp160r2: return ECC_SECP160R2; case NID_secp224r1: return ECC_SECP224R1; case NID_secp384r1: return ECC_SECP384R1; case NID_secp521r1: return ECC_SECP521R1; case NID_secp160k1: return ECC_SECP160K1; case NID_secp192k1: return ECC_SECP192K1; case NID_secp224k1: return ECC_SECP224K1; case NID_secp256k1: return ECC_SECP256K1; case NID_brainpoolP160r1: return ECC_BRAINPOOLP160R1; case NID_brainpoolP192r1: return ECC_BRAINPOOLP192R1; case NID_brainpoolP224r1: return ECC_BRAINPOOLP224R1; case NID_brainpoolP256r1: return ECC_BRAINPOOLP256R1; case NID_brainpoolP320r1: return ECC_BRAINPOOLP320R1; case NID_brainpoolP384r1: return ECC_BRAINPOOLP384R1; case NID_brainpoolP512r1: return ECC_BRAINPOOLP512R1; default: WOLFSSL_MSG("NID not found"); return -1; } } /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_EC_GROUP_get_order(const WOLFSSL_EC_GROUP *group, WOLFSSL_BIGNUM *order, WOLFSSL_BN_CTX *ctx) { (void)ctx; if (group == NULL || order == NULL || order->internal == NULL) { WOLFSSL_MSG("wolfSSL_EC_GROUP_get_order NULL error"); return WOLFSSL_FAILURE; } if (mp_init((mp_int*)order->internal) != MP_OKAY) { WOLFSSL_MSG("wolfSSL_EC_GROUP_get_order mp_init failure"); return WOLFSSL_FAILURE; } if (mp_read_radix((mp_int*)order->internal, ecc_sets[group->curve_idx].order, MP_RADIX_HEX) != MP_OKAY) { WOLFSSL_MSG("wolfSSL_EC_GROUP_get_order mp_read order failure"); mp_clear((mp_int*)order->internal); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } int wolfSSL_EC_GROUP_order_bits(const WOLFSSL_EC_GROUP *group) { int ret; mp_int order; if (group == NULL || group->curve_idx < 0) { WOLFSSL_MSG("wolfSSL_EC_GROUP_order_bits NULL error"); return 0; } ret = mp_init(&order); if (ret == 0) { ret = mp_read_radix(&order, ecc_sets[group->curve_idx].order, MP_RADIX_HEX); if (ret == 0) ret = mp_count_bits(&order); mp_clear(&order); } return ret; } /* End EC_GROUP */ /* Start EC_POINT */ /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_ECPoint_i2d(const WOLFSSL_EC_GROUP *group, const WOLFSSL_EC_POINT *p, unsigned char *out, unsigned int *len) { int err; WOLFSSL_ENTER("wolfSSL_ECPoint_i2d"); if (group == NULL || p == NULL || len == NULL) { WOLFSSL_MSG("wolfSSL_ECPoint_i2d NULL error"); return WOLFSSL_FAILURE; } if (setupPoint(p) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } if (out != NULL) { wolfSSL_EC_POINT_dump("i2d p", p); } err = wc_ecc_export_point_der(group->curve_idx, (ecc_point*)p->internal, out, len); if (err != MP_OKAY && !(out == NULL && err == LENGTH_ONLY_E)) { WOLFSSL_MSG("wolfSSL_ECPoint_i2d wc_ecc_export_point_der failed"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_ECPoint_d2i(unsigned char *in, unsigned int len, const WOLFSSL_EC_GROUP *group, WOLFSSL_EC_POINT *p) { WOLFSSL_ENTER("wolfSSL_ECPoint_d2i"); if (group == NULL || p == NULL || p->internal == NULL || in == NULL) { WOLFSSL_MSG("wolfSSL_ECPoint_d2i NULL error"); return WOLFSSL_FAILURE; } #ifndef HAVE_SELFTEST if (wc_ecc_import_point_der_ex(in, len, group->curve_idx, (ecc_point*)p->internal, 0) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_import_point_der_ex failed"); return WOLFSSL_FAILURE; } #else /* ECC_POINT_UNCOMP is not defined CAVP self test so use magic number */ if (in[0] == 0x04) { if (wc_ecc_import_point_der(in, len, group->curve_idx, (ecc_point*)p->internal) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_import_point_der failed"); return WOLFSSL_FAILURE; } } else { WOLFSSL_MSG("Only uncompressed points supported with HAVE_SELFTEST"); return WOLFSSL_FAILURE; } #endif /* Set new external point */ if (SetECPointExternal(p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECPointExternal failed"); return WOLFSSL_FAILURE; } wolfSSL_EC_POINT_dump("d2i p", p); return WOLFSSL_SUCCESS; } size_t wolfSSL_EC_POINT_point2oct(const WOLFSSL_EC_GROUP *group, const WOLFSSL_EC_POINT *p, char form, byte *buf, size_t len, WOLFSSL_BN_CTX *ctx) { word32 min_len = (word32)len; #ifndef HAVE_SELFTEST int compressed = form == POINT_CONVERSION_COMPRESSED ? 1 : 0; #endif /* !HAVE_SELFTEST */ WOLFSSL_ENTER("EC_POINT_point2oct"); if (!group || !p) { return WOLFSSL_FAILURE; } if (setupPoint(p) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } if (wolfSSL_EC_POINT_is_at_infinity(group, p)) { /* encodes to a single 0 octet */ if (buf != NULL) { if (len < 1) { ECerr(EC_F_EC_GFP_SIMPLE_POINT2OCT, EC_R_BUFFER_TOO_SMALL); return WOLFSSL_FAILURE; } buf[0] = 0; } return 1; } if (form != POINT_CONVERSION_UNCOMPRESSED #ifndef HAVE_SELFTEST && form != POINT_CONVERSION_COMPRESSED #endif /* !HAVE_SELFTEST */ ) { WOLFSSL_MSG("Unsupported curve form"); return WOLFSSL_FAILURE; } #ifndef HAVE_SELFTEST if (wc_ecc_export_point_der_ex(group->curve_idx, (ecc_point*)p->internal, buf, &min_len, compressed) != (buf ? MP_OKAY : LENGTH_ONLY_E)) { return WOLFSSL_FAILURE; } #else if (wc_ecc_export_point_der(group->curve_idx, (ecc_point*)p->internal, buf, &min_len) != (buf ? MP_OKAY : LENGTH_ONLY_E)) { return WOLFSSL_FAILURE; } #endif /* !HAVE_SELFTEST */ (void)ctx; return (size_t)min_len; } int wolfSSL_EC_POINT_oct2point(const WOLFSSL_EC_GROUP *group, WOLFSSL_EC_POINT *p, const unsigned char *buf, size_t len, WOLFSSL_BN_CTX *ctx) { WOLFSSL_ENTER("wolfSSL_EC_POINT_oct2point"); if (!group || !p) { return WOLFSSL_FAILURE; } (void)ctx; return wolfSSL_ECPoint_d2i((unsigned char*)buf, (unsigned int)len, group, p); } int wolfSSL_i2o_ECPublicKey(const WOLFSSL_EC_KEY *in, unsigned char **out) { size_t len; unsigned char *tmp = NULL; char form; WOLFSSL_ENTER("wolfSSL_i2o_ECPublicKey"); if (!in) { WOLFSSL_MSG("wolfSSL_i2o_ECPublicKey Bad arguments"); return WOLFSSL_FAILURE; } /* Default to compressed form if not set */ form = in->form == POINT_CONVERSION_UNCOMPRESSED ? POINT_CONVERSION_UNCOMPRESSED: POINT_CONVERSION_COMPRESSED; len = wolfSSL_EC_POINT_point2oct(in->group, in->pub_key, form, NULL, 0, NULL); if (len != WOLFSSL_FAILURE && out) { if (!*out) { if (!(tmp = (unsigned char*)XMALLOC(len, NULL, DYNAMIC_TYPE_OPENSSL))) { WOLFSSL_MSG("malloc failed"); return WOLFSSL_FAILURE; } *out = tmp; } if (wolfSSL_EC_POINT_point2oct(in->group, in->pub_key, form, *out, len, NULL) == WOLFSSL_FAILURE) { if (tmp) { XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL); *out = NULL; } return WOLFSSL_FAILURE; } if (!tmp) { /* Move buffer forward if it was not alloced in this function */ *out += len; } } return (int)len; } void wolfSSL_EC_KEY_set_conv_form(WOLFSSL_EC_KEY *eckey, char form) { if (eckey && (form == POINT_CONVERSION_COMPRESSED || form == POINT_CONVERSION_UNCOMPRESSED)) { eckey->form = form; } } /* wolfSSL_EC_POINT_point2bn should return "in" if not null */ WOLFSSL_BIGNUM *wolfSSL_EC_POINT_point2bn(const WOLFSSL_EC_GROUP *group, const WOLFSSL_EC_POINT *p, char form, WOLFSSL_BIGNUM *in, WOLFSSL_BN_CTX *ctx) { size_t len; byte *buf; WOLFSSL_BIGNUM *ret = NULL; WOLFSSL_ENTER("wolfSSL_EC_POINT_oct2point"); if (!group || !p) { return NULL; } if ((len = wolfSSL_EC_POINT_point2oct(group, p, form, NULL, 0, ctx)) == WOLFSSL_FAILURE) { return NULL; } if (!(buf = (byte*)XMALLOC(len, NULL, DYNAMIC_TYPE_TMP_BUFFER))) { WOLFSSL_MSG("malloc failed"); return NULL; } if (wolfSSL_EC_POINT_point2oct(group, p, form, buf, len, ctx) == len) { ret = wolfSSL_BN_bin2bn(buf, (int)len, in); } XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return ret; } WOLFSSL_EC_POINT *wolfSSL_EC_POINT_new(const WOLFSSL_EC_GROUP *group) { WOLFSSL_EC_POINT *p; WOLFSSL_ENTER("wolfSSL_EC_POINT_new"); if (group == NULL) { WOLFSSL_MSG("wolfSSL_EC_POINT_new NULL error"); return NULL; } p = (WOLFSSL_EC_POINT *)XMALLOC(sizeof(WOLFSSL_EC_POINT), NULL, DYNAMIC_TYPE_ECC); if (p == NULL) { WOLFSSL_MSG("wolfSSL_EC_POINT_new malloc ecc point failure"); return NULL; } XMEMSET(p, 0, sizeof(WOLFSSL_EC_POINT)); p->internal = wc_ecc_new_point(); if (p->internal == NULL) { WOLFSSL_MSG("ecc_new_point failure"); XFREE(p, NULL, DYNAMIC_TYPE_ECC); return NULL; } return p; } /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_EC_POINT_get_affine_coordinates_GFp(const WOLFSSL_EC_GROUP *group, const WOLFSSL_EC_POINT *point, WOLFSSL_BIGNUM *x, WOLFSSL_BIGNUM *y, WOLFSSL_BN_CTX *ctx) { mp_digit mp; mp_int modulus; (void)ctx; WOLFSSL_ENTER("wolfSSL_EC_POINT_get_affine_coordinates_GFp"); if (group == NULL || point == NULL || point->internal == NULL || x == NULL || y == NULL || wolfSSL_EC_POINT_is_at_infinity(group, point)) { WOLFSSL_MSG("wolfSSL_EC_POINT_get_affine_coordinates_GFp NULL error"); return WOLFSSL_FAILURE; } if (setupPoint(point) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } if (!wolfSSL_BN_is_one(point->Z)) { if (mp_init(&modulus) != MP_OKAY) { WOLFSSL_MSG("mp_init failed"); return WOLFSSL_FAILURE; } /* Map the Jacobian point back to affine space */ if (mp_read_radix(&modulus, ecc_sets[group->curve_idx].prime, MP_RADIX_HEX) != MP_OKAY) { WOLFSSL_MSG("mp_read_radix failed"); mp_clear(&modulus); return WOLFSSL_FAILURE; } if (mp_montgomery_setup(&modulus, &mp) != MP_OKAY) { WOLFSSL_MSG("mp_montgomery_setup failed"); mp_clear(&modulus); return WOLFSSL_FAILURE; } if (ecc_map((ecc_point*)point->internal, &modulus, mp) != MP_OKAY) { WOLFSSL_MSG("ecc_map failed"); mp_clear(&modulus); return WOLFSSL_FAILURE; } if (SetECPointExternal((WOLFSSL_EC_POINT *)point) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECPointExternal failed"); mp_clear(&modulus); return WOLFSSL_FAILURE; } } BN_copy(x, point->X); BN_copy(y, point->Y); mp_clear(&modulus); return WOLFSSL_SUCCESS; } int wolfSSL_EC_POINT_set_affine_coordinates_GFp(const WOLFSSL_EC_GROUP *group, WOLFSSL_EC_POINT *point, const WOLFSSL_BIGNUM *x, const WOLFSSL_BIGNUM *y, WOLFSSL_BN_CTX *ctx) { (void)ctx; WOLFSSL_ENTER("wolfSSL_EC_POINT_set_affine_coordinates_GFp"); if (group == NULL || point == NULL || point->internal == NULL || x == NULL || y == NULL) { WOLFSSL_MSG("wolfSSL_EC_POINT_set_affine_coordinates_GFp NULL error"); return WOLFSSL_FAILURE; } if (!point->X) { point->X = wolfSSL_BN_new(); } if (!point->Y) { point->Y = wolfSSL_BN_new(); } if (!point->Z) { point->Z = wolfSSL_BN_new(); } if (!point->X || !point->Y || !point->Z) { WOLFSSL_MSG("wolfSSL_BN_new failed"); return WOLFSSL_FAILURE; } BN_copy(point->X, x); BN_copy(point->Y, y); BN_copy(point->Z, wolfSSL_BN_value_one()); if (SetECPointInternal((WOLFSSL_EC_POINT *)point) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECPointInternal failed"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #if !defined(WOLFSSL_ATECC508A) && !defined(HAVE_SELFTEST) /* Calculate the value: generator * n + q * m * return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_EC_POINT_mul(const WOLFSSL_EC_GROUP *group, WOLFSSL_EC_POINT *r, const WOLFSSL_BIGNUM *n, const WOLFSSL_EC_POINT *q, const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx) { mp_int a, prime; int ret = WOLFSSL_FAILURE; ecc_point* result = NULL; ecc_point* tmp = NULL; (void)ctx; WOLFSSL_ENTER("wolfSSL_EC_POINT_mul"); if (!group || !r) { WOLFSSL_MSG("wolfSSL_EC_POINT_mul NULL error"); return WOLFSSL_FAILURE; } if (!(result = wc_ecc_new_point())) { WOLFSSL_MSG("wolfSSL_EC_POINT_new error"); return WOLFSSL_FAILURE; } /* read the curve prime and a */ if (mp_init_multi(&prime, &a, NULL, NULL, NULL, NULL) != MP_OKAY) { WOLFSSL_MSG("mp_init_multi error"); goto cleanup; } if (q && setupPoint(q) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("setupPoint error"); goto cleanup; } if (mp_read_radix(&prime, ecc_sets[group->curve_idx].prime, MP_RADIX_HEX) != MP_OKAY) { WOLFSSL_MSG("mp_read_radix prime error"); goto cleanup; } if (mp_read_radix(&a, ecc_sets[group->curve_idx].Af, MP_RADIX_HEX) != MP_OKAY) { WOLFSSL_MSG("mp_read_radix a error"); goto cleanup; } if (n) { /* load generator */ if (wc_ecc_get_generator(result, group->curve_idx) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_get_generator error"); goto cleanup; } } if (n && q && m) { /* r = generator * n + q * m */ #ifdef ECC_SHAMIR if (ecc_mul2add(result, (mp_int*)n->internal, (ecc_point*)q->internal, (mp_int*)m->internal, result, &a, &prime, NULL) != MP_OKAY) { WOLFSSL_MSG("ecc_mul2add error"); goto cleanup; } #else mp_digit mp = 0; if (mp_montgomery_setup(&prime, &mp) != MP_OKAY) { WOLFSSL_MSG("mp_montgomery_setup nqm error"); goto cleanup; } if (!(tmp = wc_ecc_new_point())) { WOLFSSL_MSG("wolfSSL_EC_POINT_new nqm error"); goto cleanup; } /* r = generator * n */ if (wc_ecc_mulmod((mp_int*)n->internal, result, result, &a, &prime, 1) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_mulmod nqm error"); goto cleanup; } /* tmp = q * m */ if (wc_ecc_mulmod((mp_int*)m->internal, (ecc_point*)q->internal, tmp, &a, &prime, 1) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_mulmod nqm error"); goto cleanup; } /* result = result + tmp */ if (ecc_projective_add_point(tmp, result, result, &a, &prime, mp) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_mulmod nqm error"); goto cleanup; } if (ecc_map(result, &prime, mp) != MP_OKAY) { WOLFSSL_MSG("ecc_map nqm error"); goto cleanup; } #endif } else if (n) { /* r = generator * n */ if (wc_ecc_mulmod((mp_int*)n->internal, result, result, &a, &prime, 1) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_mulmod gn error"); goto cleanup; } } else if (q && m) { /* r = q * m */ if (wc_ecc_mulmod((mp_int*)m->internal, (ecc_point*)q->internal, result, &a, &prime, 1) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_mulmod qm error"); goto cleanup; } } /* copy to destination */ if (wc_ecc_copy_point(result, (ecc_point*)r->internal)) { WOLFSSL_MSG("wc_ecc_copy_point error"); goto cleanup; } r->inSet = 1; if (SetECPointExternal(r) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECPointExternal error"); goto cleanup; } ret = WOLFSSL_SUCCESS; cleanup: mp_clear(&a); mp_clear(&prime); wc_ecc_del_point(result); wc_ecc_del_point(tmp); return ret; } #endif /* !defined(WOLFSSL_ATECC508A) && defined(ECC_SHAMIR) && * !defined(HAVE_SELFTEST) */ void wolfSSL_EC_POINT_clear_free(WOLFSSL_EC_POINT *p) { WOLFSSL_ENTER("wolfSSL_EC_POINT_clear_free"); wolfSSL_EC_POINT_free(p); } /* return code compliant with OpenSSL : * 0 if equal, 1 if not and -1 in case of error */ int wolfSSL_EC_POINT_cmp(const WOLFSSL_EC_GROUP *group, const WOLFSSL_EC_POINT *a, const WOLFSSL_EC_POINT *b, WOLFSSL_BN_CTX *ctx) { int ret; (void)ctx; WOLFSSL_ENTER("wolfSSL_EC_POINT_cmp"); if (group == NULL || a == NULL || a->internal == NULL || b == NULL || b->internal == NULL) { WOLFSSL_MSG("wolfSSL_EC_POINT_cmp Bad arguments"); return WOLFSSL_FATAL_ERROR; } ret = wc_ecc_cmp_point((ecc_point*)a->internal, (ecc_point*)b->internal); if (ret == MP_EQ) return 0; else if (ret == MP_LT || ret == MP_GT) return 1; return WOLFSSL_FATAL_ERROR; } int wolfSSL_EC_POINT_copy(WOLFSSL_EC_POINT *dest, const WOLFSSL_EC_POINT *src) { WOLFSSL_ENTER("wolfSSL_EC_POINT_copy"); if (!dest || !src) { return WOLFSSL_FAILURE; } if (setupPoint(src) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } if (wc_ecc_copy_point((ecc_point*) dest->internal, (ecc_point*) src->internal) != MP_OKAY) { return WOLFSSL_FAILURE; } dest->inSet = 1; if (SetECPointExternal(dest) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #endif /* HAVE_ECC */ #endif /* OPENSSL_EXTRA */ #if defined(HAVE_ECC) && (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) void wolfSSL_EC_POINT_free(WOLFSSL_EC_POINT *p) { WOLFSSL_ENTER("wolfSSL_EC_POINT_free"); if (p != NULL) { if (p->internal != NULL) { wc_ecc_del_point((ecc_point*)p->internal); p->internal = NULL; } wolfSSL_BN_free(p->X); wolfSSL_BN_free(p->Y); wolfSSL_BN_free(p->Z); p->X = NULL; p->Y = NULL; p->Z = NULL; p->inSet = p->exSet = 0; XFREE(p, NULL, DYNAMIC_TYPE_ECC); /* p = NULL, don't try to access or double free it */ } } #endif #ifdef OPENSSL_EXTRA #ifdef HAVE_ECC /* return code compliant with OpenSSL : * 1 if point at infinity, 0 else */ int wolfSSL_EC_POINT_is_at_infinity(const WOLFSSL_EC_GROUP *group, const WOLFSSL_EC_POINT *point) { int ret; WOLFSSL_ENTER("wolfSSL_EC_POINT_is_at_infinity"); if (group == NULL || point == NULL || point->internal == NULL) { WOLFSSL_MSG("wolfSSL_EC_POINT_is_at_infinity NULL error"); return WOLFSSL_FAILURE; } if (setupPoint(point) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } ret = wc_ecc_point_is_at_infinity((ecc_point*)point->internal); if (ret < 0) { WOLFSSL_MSG("ecc_point_is_at_infinity failure"); return WOLFSSL_FAILURE; } return ret; } /* End EC_POINT */ size_t wolfSSL_EC_get_builtin_curves(WOLFSSL_EC_BUILTIN_CURVE *r, size_t nitems) { size_t i, min_nitems; #ifdef HAVE_SELFTEST size_t ecc_sets_count; for (i = 0; ecc_sets[i].size != 0 && ecc_sets[i].name != NULL; i++); ecc_sets_count = i; #endif if (r == NULL || nitems == 0) return ecc_sets_count; min_nitems = nitems < ecc_sets_count ? nitems : ecc_sets_count; for (i = 0; i < min_nitems; i++) { r[i].nid = EccEnumToNID(ecc_sets[i].id); r[i].comment = wolfSSL_OBJ_nid2sn(r[i].nid); } return ecc_sets_count; } /* Start ECDSA_SIG */ void wolfSSL_ECDSA_SIG_free(WOLFSSL_ECDSA_SIG *sig) { WOLFSSL_ENTER("wolfSSL_ECDSA_SIG_free"); if (sig) { wolfSSL_BN_free(sig->r); wolfSSL_BN_free(sig->s); XFREE(sig, NULL, DYNAMIC_TYPE_ECC); } } WOLFSSL_ECDSA_SIG *wolfSSL_ECDSA_SIG_new(void) { WOLFSSL_ECDSA_SIG *sig; WOLFSSL_ENTER("wolfSSL_ECDSA_SIG_new"); sig = (WOLFSSL_ECDSA_SIG*) XMALLOC(sizeof(WOLFSSL_ECDSA_SIG), NULL, DYNAMIC_TYPE_ECC); if (sig == NULL) { WOLFSSL_MSG("wolfSSL_ECDSA_SIG_new malloc ECDSA signature failure"); return NULL; } sig->s = NULL; sig->r = wolfSSL_BN_new(); if (sig->r == NULL) { WOLFSSL_MSG("wolfSSL_ECDSA_SIG_new malloc ECDSA r failure"); wolfSSL_ECDSA_SIG_free(sig); return NULL; } sig->s = wolfSSL_BN_new(); if (sig->s == NULL) { WOLFSSL_MSG("wolfSSL_ECDSA_SIG_new malloc ECDSA s failure"); wolfSSL_ECDSA_SIG_free(sig); return NULL; } return sig; } /* return signature structure on success, NULL otherwise */ WOLFSSL_ECDSA_SIG *wolfSSL_ECDSA_do_sign(const unsigned char *d, int dlen, WOLFSSL_EC_KEY *key) { WOLFSSL_ECDSA_SIG *sig = NULL; int initTmpRng = 0; WC_RNG* rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; #else WC_RNG tmpRNG[1]; #endif WOLFSSL_ENTER("wolfSSL_ECDSA_do_sign"); if (d == NULL || key == NULL || key->internal == NULL) { WOLFSSL_MSG("wolfSSL_ECDSA_do_sign Bad arguments"); return NULL; } /* set internal key if not done */ if (key->inSet == 0) { WOLFSSL_MSG("wolfSSL_ECDSA_do_sign No EC key internal set, do it"); if (SetECKeyInternal(key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("wolfSSL_ECDSA_do_sign SetECKeyInternal failed"); return NULL; } } #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return NULL; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("wolfSSL_ECDSA_do_sign Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("wolfSSL_ECDSA_do_sign Global RNG no Init"); else rng = &globalRNG; } if (rng) { mp_int sig_r, sig_s; if (mp_init_multi(&sig_r, &sig_s, NULL, NULL, NULL, NULL) == MP_OKAY) { if (wc_ecc_sign_hash_ex(d, dlen, rng, (ecc_key*)key->internal, &sig_r, &sig_s) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_sign_hash_ex failed"); } else { /* put signature blob in ECDSA structure */ sig = wolfSSL_ECDSA_SIG_new(); if (sig == NULL) WOLFSSL_MSG("wolfSSL_ECDSA_SIG_new failed"); else if (SetIndividualExternal(&(sig->r), &sig_r)!=WOLFSSL_SUCCESS){ WOLFSSL_MSG("ecdsa r key error"); wolfSSL_ECDSA_SIG_free(sig); sig = NULL; } else if (SetIndividualExternal(&(sig->s), &sig_s)!=WOLFSSL_SUCCESS){ WOLFSSL_MSG("ecdsa s key error"); wolfSSL_ECDSA_SIG_free(sig); sig = NULL; } } mp_free(&sig_r); mp_free(&sig_s); } } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return sig; } /* return code compliant with OpenSSL : * 1 for a valid signature, 0 for an invalid signature and -1 on error */ int wolfSSL_ECDSA_do_verify(const unsigned char *d, int dlen, const WOLFSSL_ECDSA_SIG *sig, WOLFSSL_EC_KEY *key) { int check_sign = 0; WOLFSSL_ENTER("wolfSSL_ECDSA_do_verify"); if (d == NULL || sig == NULL || key == NULL || key->internal == NULL) { WOLFSSL_MSG("wolfSSL_ECDSA_do_verify Bad arguments"); return WOLFSSL_FATAL_ERROR; } /* set internal key if not done */ if (key->inSet == 0) { WOLFSSL_MSG("No EC key internal set, do it"); if (SetECKeyInternal(key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECKeyInternal failed"); return WOLFSSL_FATAL_ERROR; } } if (wc_ecc_verify_hash_ex((mp_int*)sig->r->internal, (mp_int*)sig->s->internal, d, dlen, &check_sign, (ecc_key *)key->internal) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_verify_hash failed"); return WOLFSSL_FATAL_ERROR; } else if (check_sign == 0) { WOLFSSL_MSG("wc_ecc_verify_hash incorrect signature detected"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } WOLFSSL_ECDSA_SIG *wolfSSL_d2i_ECDSA_SIG(WOLFSSL_ECDSA_SIG **sig, const unsigned char **pp, long len) { WOLFSSL_ECDSA_SIG *s = NULL; if (pp == NULL) return NULL; if (sig != NULL) s = *sig; if (s == NULL) { s = wolfSSL_ECDSA_SIG_new(); if (s == NULL) return NULL; } /* DecodeECC_DSA_Sig calls mp_init, so free these */ mp_free((mp_int*)s->r->internal); mp_free((mp_int*)s->s->internal); if (DecodeECC_DSA_Sig(*pp, (word32)len, (mp_int*)s->r->internal, (mp_int*)s->s->internal) != MP_OKAY) { if (sig == NULL || *sig == NULL) wolfSSL_ECDSA_SIG_free(s); return NULL; } *pp += len; if (sig != NULL) *sig = s; return s; } int wolfSSL_i2d_ECDSA_SIG(const WOLFSSL_ECDSA_SIG *sig, unsigned char **pp) { word32 len; if (sig == NULL) return 0; /* ASN.1: SEQ + INT + INT * ASN.1 Integer must be a positive value - prepend zero if number has * top bit set. */ len = 2 + mp_leading_bit((mp_int*)sig->r->internal) + mp_unsigned_bin_size((mp_int*)sig->r->internal) + 2 + mp_leading_bit((mp_int*)sig->s->internal) + mp_unsigned_bin_size((mp_int*)sig->s->internal); /* Two bytes required for length if ASN.1 SEQ data greater than 127 bytes * and less than 256 bytes. */ len = 1 + ((len > 127) ? 2 : 1) + len; if (pp != NULL && *pp != NULL) { if (StoreECC_DSA_Sig(*pp, &len, (mp_int*)sig->r->internal, (mp_int*)sig->s->internal) != MP_OKAY) { len = 0; } else *pp += len; } return (int)len; } /* End ECDSA_SIG */ /* Start ECDH */ /* return code compliant with OpenSSL : * length of computed key if success, -1 if error */ int wolfSSL_ECDH_compute_key(void *out, size_t outlen, const WOLFSSL_EC_POINT *pub_key, WOLFSSL_EC_KEY *ecdh, void *(*KDF) (const void *in, size_t inlen, void *out, size_t *outlen)) { word32 len; (void)KDF; (void)KDF; WOLFSSL_ENTER("wolfSSL_ECDH_compute_key"); if (out == NULL || pub_key == NULL || pub_key->internal == NULL || ecdh == NULL || ecdh->internal == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FATAL_ERROR; } /* set internal key if not done */ if (ecdh->inSet == 0) { WOLFSSL_MSG("No EC key internal set, do it"); if (SetECKeyInternal(ecdh) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECKeyInternal failed"); return WOLFSSL_FATAL_ERROR; } } len = (word32)outlen; if (wc_ecc_shared_secret_ssh((ecc_key*)ecdh->internal, (ecc_point*)pub_key->internal, (byte *)out, &len) != MP_OKAY) { WOLFSSL_MSG("wc_ecc_shared_secret failed"); return WOLFSSL_FATAL_ERROR; } return len; } /* End ECDH */ #if !defined(NO_FILESYSTEM) /* return code compliant with OpenSSL : * 1 if success, 0 if error */ #ifndef NO_WOLFSSL_STUB int wolfSSL_PEM_write_EC_PUBKEY(XFILE fp, WOLFSSL_EC_KEY *x) { (void)fp; (void)x; WOLFSSL_STUB("PEM_write_EC_PUBKEY"); WOLFSSL_MSG("wolfSSL_PEM_write_EC_PUBKEY not implemented"); return WOLFSSL_FAILURE; } #endif /* Uses the same format of input as wolfSSL_PEM_read_bio_PrivateKey but expects * the results to be an EC key. * * bio structure to read EC private key from * ec if not null is then set to the result * cb password callback for reading PEM * pass password string * * returns a pointer to a new WOLFSSL_EC_KEY struct on success and NULL on fail */ WOLFSSL_EC_KEY* wolfSSL_PEM_read_bio_EC_PUBKEY(WOLFSSL_BIO* bio, WOLFSSL_EC_KEY** ec, pem_password_cb* cb, void *pass) { WOLFSSL_EVP_PKEY* pkey; WOLFSSL_EC_KEY* local; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_EC_PUBKEY"); pkey = wolfSSL_PEM_read_bio_PUBKEY(bio, NULL, cb, pass); if (pkey == NULL) { return NULL; } /* Since the WOLFSSL_EC_KEY structure is being taken from WOLFSSL_EVP_PKEY the * flag indicating that the WOLFSSL_EC_KEY structure is owned should be FALSE * to avoid having it free'd */ pkey->ownEcc = 0; local = pkey->ecc; if (ec != NULL) { *ec = local; } wolfSSL_EVP_PKEY_free(pkey); return local; } /* Reads a private EC key from a WOLFSSL_BIO into a WOLFSSL_EC_KEY. * Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE */ WOLFSSL_EC_KEY* wolfSSL_PEM_read_bio_ECPrivateKey(WOLFSSL_BIO* bio, WOLFSSL_EC_KEY** ec, pem_password_cb* cb, void *pass) { WOLFSSL_EVP_PKEY* pkey; WOLFSSL_EC_KEY* local; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_ECPrivateKey"); pkey = wolfSSL_PEM_read_bio_PrivateKey(bio, NULL, cb, pass); if (pkey == NULL) { return NULL; } /* Since the WOLFSSL_EC_KEY structure is being taken from WOLFSSL_EVP_PKEY the * flag indicating that the WOLFSSL_EC_KEY structure is owned should be FALSE * to avoid having it free'd */ pkey->ownEcc = 0; local = pkey->ecc; if (ec != NULL) { *ec = local; } wolfSSL_EVP_PKEY_free(pkey); return local; } #endif /* NO_FILESYSTEM */ #if defined(WOLFSSL_KEY_GEN) /* Takes a public WOLFSSL_EC_KEY and writes it out to WOLFSSL_BIO * Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE */ int wolfSSL_PEM_write_bio_EC_PUBKEY(WOLFSSL_BIO* bio, WOLFSSL_EC_KEY* ec) { int ret = 0, der_max_len = 0, derSz = 0; byte *derBuf; WOLFSSL_EVP_PKEY* pkey; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_EC_PUBKEY"); if (bio == NULL || ec == NULL) { WOLFSSL_MSG("Bad Function Arguments"); return WOLFSSL_FAILURE; } /* Initialize pkey structure */ pkey = wolfSSL_EVP_PKEY_new_ex(bio->heap); if (pkey == NULL) { WOLFSSL_MSG("wolfSSL_EVP_PKEY_new_ex failed"); return WOLFSSL_FAILURE; } /* Set pkey info */ pkey->ecc = ec; pkey->ownEcc = 0; /* pkey does not own ECC */ pkey->type = EVP_PKEY_EC; /* 4 > size of pub, priv + ASN.1 additional information */ der_max_len = 4 * wc_ecc_size((ecc_key*)ec->internal) + AES_BLOCK_SIZE; derBuf = (byte*)XMALLOC(der_max_len, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (derBuf == NULL) { WOLFSSL_MSG("Malloc failed"); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } /* convert key to der format */ derSz = wc_EccPublicKeyToDer((ecc_key*)ec->internal, derBuf, der_max_len, 1); if (derSz < 0) { WOLFSSL_MSG("wc_EccPublicKeyToDer failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } pkey->pkey.ptr = (char*)XMALLOC(derSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (pkey->pkey.ptr == NULL) { WOLFSSL_MSG("key malloc failed"); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } /* add der info to the evp key */ pkey->pkey_sz = derSz; XMEMCPY(pkey->pkey.ptr, derBuf, derSz); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if((ret = wolfSSL_PEM_write_bio_PUBKEY(bio, pkey)) != WOLFSSL_SUCCESS){ WOLFSSL_MSG("wolfSSL_PEM_write_bio_PUBKEY failed"); } wolfSSL_EVP_PKEY_free(pkey); return ret; } /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_PEM_write_bio_ECPrivateKey(WOLFSSL_BIO* bio, WOLFSSL_EC_KEY* ec, const EVP_CIPHER* cipher, unsigned char* passwd, int len, pem_password_cb* cb, void* arg) { int ret = 0, der_max_len = 0, derSz = 0; byte *derBuf; WOLFSSL_EVP_PKEY* pkey; WOLFSSL_ENTER("WOLFSSL_PEM_write_bio_ECPrivateKey"); if (bio == NULL || ec == NULL) { WOLFSSL_MSG("Bad Function Arguments"); return WOLFSSL_FAILURE; } /* Initialize pkey structure */ pkey = wolfSSL_EVP_PKEY_new_ex(bio->heap); if (pkey == NULL) { WOLFSSL_MSG("wolfSSL_EVP_PKEY_new_ex failed"); return WOLFSSL_FAILURE; } /* Set pkey info */ pkey->ecc = ec; pkey->ownEcc = 0; /* pkey does not own ECC */ pkey->type = EVP_PKEY_EC; /* 4 > size of pub, priv + ASN.1 additional informations */ der_max_len = 4 * wc_ecc_size((ecc_key*)ec->internal) + AES_BLOCK_SIZE; derBuf = (byte*)XMALLOC(der_max_len, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (derBuf == NULL) { WOLFSSL_MSG("Malloc failed"); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } /* convert key to der format */ derSz = wc_EccKeyToDer((ecc_key*)ec->internal, derBuf, der_max_len); if (derSz < 0) { WOLFSSL_MSG("wc_EccKeyToDer failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } pkey->pkey.ptr = (char*)XMALLOC(derSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (pkey->pkey.ptr == NULL) { WOLFSSL_MSG("key malloc failed"); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } /* add der info to the evp key */ pkey->pkey_sz = derSz; XMEMCPY(pkey->pkey.ptr, derBuf, derSz); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); ret = wolfSSL_PEM_write_bio_PrivateKey(bio, pkey, cipher, passwd, len, cb, arg); wolfSSL_EVP_PKEY_free(pkey); return ret; } /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_PEM_write_mem_ECPrivateKey(WOLFSSL_EC_KEY* ecc, const EVP_CIPHER* cipher, unsigned char* passwd, int passwdSz, unsigned char **pem, int *plen) { #if defined(WOLFSSL_PEM_TO_DER) || defined(WOLFSSL_DER_TO_PEM) byte *derBuf, *tmp, *cipherInfo = NULL; int der_max_len = 0, derSz = 0; const int type = ECC_PRIVATEKEY_TYPE; const char* header = NULL; const char* footer = NULL; WOLFSSL_MSG("wolfSSL_PEM_write_mem_ECPrivateKey"); if (pem == NULL || plen == NULL || ecc == NULL || ecc->internal == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } if (wc_PemGetHeaderFooter(type, &header, &footer) != 0) return WOLFSSL_FAILURE; if (ecc->inSet == 0) { WOLFSSL_MSG("No ECC internal set, do it"); if (SetECKeyInternal(ecc) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECKeyInternal failed"); return WOLFSSL_FAILURE; } } /* 4 > size of pub, priv + ASN.1 additional information */ der_max_len = 4 * wc_ecc_size((ecc_key*)ecc->internal) + AES_BLOCK_SIZE; derBuf = (byte*)XMALLOC(der_max_len, NULL, DYNAMIC_TYPE_DER); if (derBuf == NULL) { WOLFSSL_MSG("malloc failed"); return WOLFSSL_FAILURE; } /* Key to DER */ derSz = wc_EccKeyToDer((ecc_key*)ecc->internal, derBuf, der_max_len); if (derSz < 0) { WOLFSSL_MSG("wc_EccKeyToDer failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); return WOLFSSL_FAILURE; } /* encrypt DER buffer if required */ if (passwd != NULL && passwdSz > 0 && cipher != NULL) { int ret; ret = EncryptDerKey(derBuf, &derSz, cipher, passwd, passwdSz, &cipherInfo); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("EncryptDerKey failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); return ret; } /* tmp buffer with a max size */ *plen = (derSz * 2) + (int)XSTRLEN(header) + 1 + (int)XSTRLEN(footer) + 1 + HEADER_ENCRYPTED_KEY_SIZE; } else { /* tmp buffer with a max size */ *plen = (derSz * 2) + (int)XSTRLEN(header) + 1 + (int)XSTRLEN(footer) + 1; } tmp = (byte*)XMALLOC(*plen, NULL, DYNAMIC_TYPE_PEM); if (tmp == NULL) { WOLFSSL_MSG("malloc failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); if (cipherInfo != NULL) XFREE(cipherInfo, NULL, DYNAMIC_TYPE_STRING); return WOLFSSL_FAILURE; } /* DER to PEM */ *plen = wc_DerToPemEx(derBuf, derSz, tmp, *plen, cipherInfo, type); if (*plen <= 0) { WOLFSSL_MSG("wc_DerToPemEx failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); if (cipherInfo != NULL) XFREE(cipherInfo, NULL, DYNAMIC_TYPE_STRING); return WOLFSSL_FAILURE; } XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); if (cipherInfo != NULL) XFREE(cipherInfo, NULL, DYNAMIC_TYPE_STRING); *pem = (byte*)XMALLOC((*plen)+1, NULL, DYNAMIC_TYPE_KEY); if (*pem == NULL) { WOLFSSL_MSG("malloc failed"); XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); return WOLFSSL_FAILURE; } XMEMSET(*pem, 0, (*plen)+1); if (XMEMCPY(*pem, tmp, *plen) == NULL) { WOLFSSL_MSG("XMEMCPY failed"); XFREE(pem, NULL, DYNAMIC_TYPE_KEY); XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); return WOLFSSL_FAILURE; } XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); return WOLFSSL_SUCCESS; #else (void)ecc; (void)cipher; (void)passwd; (void)passwdSz; (void)pem; (void)plen; return WOLFSSL_FAILURE; #endif /* WOLFSSL_PEM_TO_DER || WOLFSSL_DER_TO_PEM */ } #ifndef NO_FILESYSTEM /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_PEM_write_ECPrivateKey(XFILE fp, WOLFSSL_EC_KEY *ecc, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u) { byte *pem; int plen, ret; (void)cb; (void)u; WOLFSSL_MSG("wolfSSL_PEM_write_ECPrivateKey"); if (fp == XBADFILE || ecc == NULL || ecc->internal == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } ret = wolfSSL_PEM_write_mem_ECPrivateKey(ecc, enc, kstr, klen, &pem, &plen); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("wolfSSL_PEM_write_mem_ECPrivateKey failed"); return WOLFSSL_FAILURE; } ret = (int)XFWRITE(pem, plen, 1, fp); if (ret != 1) { WOLFSSL_MSG("ECC private key file write failed"); return WOLFSSL_FAILURE; } XFREE(pem, NULL, DYNAMIC_TYPE_KEY); return WOLFSSL_SUCCESS; } #endif /* NO_FILESYSTEM */ #endif /* defined(WOLFSSL_KEY_GEN) */ #endif /* HAVE_ECC */ #ifndef NO_DSA #if defined(WOLFSSL_KEY_GEN) /* Takes a DSA Privatekey and writes it out to a WOLFSSL_BIO * Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE */ int wolfSSL_PEM_write_bio_DSAPrivateKey(WOLFSSL_BIO* bio, WOLFSSL_DSA* dsa, const EVP_CIPHER* cipher, unsigned char* passwd, int len, pem_password_cb* cb, void* arg) { int ret = 0, der_max_len = 0, derSz = 0; byte *derBuf; WOLFSSL_EVP_PKEY* pkey; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_DSAPrivateKey"); if (bio == NULL || dsa == NULL) { WOLFSSL_MSG("Bad Function Arguments"); return WOLFSSL_FAILURE; } pkey = wolfSSL_EVP_PKEY_new_ex(bio->heap); if (pkey == NULL) { WOLFSSL_MSG("wolfSSL_EVP_PKEY_new_ex failed"); return WOLFSSL_FAILURE; } pkey->type = EVP_PKEY_DSA; pkey->dsa = dsa; pkey->ownDsa = 0; /* 4 > size of pub, priv, p, q, g + ASN.1 additional information */ der_max_len = 4 * wolfSSL_BN_num_bytes(dsa->g) + AES_BLOCK_SIZE; derBuf = (byte*)XMALLOC(der_max_len, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (derBuf == NULL) { WOLFSSL_MSG("Malloc failed"); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } /* convert key to der format */ derSz = wc_DsaKeyToDer((DsaKey*)dsa->internal, derBuf, der_max_len); if (derSz < 0) { WOLFSSL_MSG("wc_DsaKeyToDer failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } pkey->pkey.ptr = (char*)XMALLOC(derSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (pkey->pkey.ptr == NULL) { WOLFSSL_MSG("key malloc failed"); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } /* add der info to the evp key */ pkey->pkey_sz = derSz; XMEMCPY(pkey->pkey.ptr, derBuf, derSz); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); ret = wolfSSL_PEM_write_bio_PrivateKey(bio, pkey, cipher, passwd, len, cb, arg); wolfSSL_EVP_PKEY_free(pkey); return ret; } #ifndef HAVE_SELFTEST /* Takes a DSA public key and writes it out to a WOLFSSL_BIO * Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE */ int wolfSSL_PEM_write_bio_DSA_PUBKEY(WOLFSSL_BIO* bio, WOLFSSL_DSA* dsa) { int ret = 0, derMax = 0, derSz = 0; byte *derBuf; WOLFSSL_EVP_PKEY* pkey; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_DSA_PUBKEY"); if (bio == NULL || dsa == NULL) { WOLFSSL_MSG("Bad function arguements"); return WOLFSSL_FAILURE; } pkey = wolfSSL_EVP_PKEY_new_ex(bio->heap); if (pkey == NULL) { WOLFSSL_MSG("wolfSSL_EVP_PKEY_new_ex failed"); return WOLFSSL_FAILURE; } pkey->type = EVP_PKEY_DSA; pkey->dsa = dsa; pkey->ownDsa = 0; /* 4 > size of pub, priv, p, q, g + ASN.1 additional information */ derMax = 4 * wolfSSL_BN_num_bytes(dsa->g) + AES_BLOCK_SIZE; derBuf = (byte*)XMALLOC(derMax, bio->heap, DYNAMIC_TYPE_DER); if (derBuf == NULL) { WOLFSSL_MSG("malloc failed"); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } /* Key to DER */ derSz = wc_DsaKeyToPublicDer((DsaKey*)dsa->internal, derBuf, derMax); if (derSz < 0) { WOLFSSL_MSG("wc_DsaKeyToDer failed"); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_DER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } pkey->pkey.ptr = (char*)XMALLOC(derSz, bio->heap, DYNAMIC_TYPE_DER); if (pkey->pkey.ptr == NULL) { WOLFSSL_MSG("key malloc failed"); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_DER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } pkey->pkey_sz = derSz; XMEMSET(pkey->pkey.ptr, 0, derSz); if (XMEMCPY(pkey->pkey.ptr, derBuf, derSz) == NULL) { WOLFSSL_MSG("XMEMCPY failed"); XFREE(derBuf, bio->heap, DYNAMIC_TYPE_DER); XFREE(pkey->pkey.ptr, bio->heap, DYNAMIC_TYPE_DER); wolfSSL_EVP_PKEY_free(pkey); return WOLFSSL_FAILURE; } XFREE(derBuf, bio->heap, DYNAMIC_TYPE_DER); ret = wolfSSL_PEM_write_bio_PUBKEY(bio, pkey); wolfSSL_EVP_PKEY_free(pkey); return ret; } #endif /* HAVE_SELFTEST */ /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_PEM_write_mem_DSAPrivateKey(WOLFSSL_DSA* dsa, const EVP_CIPHER* cipher, unsigned char* passwd, int passwdSz, unsigned char **pem, int *plen) { #if defined(WOLFSSL_PEM_TO_DER) || defined(WOLFSSL_DER_TO_PEM) byte *derBuf, *tmp, *cipherInfo = NULL; int der_max_len = 0, derSz = 0; const int type = DSA_PRIVATEKEY_TYPE; const char* header = NULL; const char* footer = NULL; WOLFSSL_MSG("wolfSSL_PEM_write_mem_DSAPrivateKey"); if (pem == NULL || plen == NULL || dsa == NULL || dsa->internal == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } if (wc_PemGetHeaderFooter(type, &header, &footer) != 0) return WOLFSSL_FAILURE; if (dsa->inSet == 0) { WOLFSSL_MSG("No DSA internal set, do it"); if (SetDsaInternal(dsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetDsaInternal failed"); return WOLFSSL_FAILURE; } } /* 4 > size of pub, priv, p, q, g + ASN.1 additional information */ der_max_len = 4 * wolfSSL_BN_num_bytes(dsa->g) + AES_BLOCK_SIZE; derBuf = (byte*)XMALLOC(der_max_len, NULL, DYNAMIC_TYPE_DER); if (derBuf == NULL) { WOLFSSL_MSG("malloc failed"); return WOLFSSL_FAILURE; } /* Key to DER */ derSz = wc_DsaKeyToDer((DsaKey*)dsa->internal, derBuf, der_max_len); if (derSz < 0) { WOLFSSL_MSG("wc_DsaKeyToDer failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); return WOLFSSL_FAILURE; } /* encrypt DER buffer if required */ if (passwd != NULL && passwdSz > 0 && cipher != NULL) { int ret; ret = EncryptDerKey(derBuf, &derSz, cipher, passwd, passwdSz, &cipherInfo); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("EncryptDerKey failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); return ret; } /* tmp buffer with a max size */ *plen = (derSz * 2) + (int)XSTRLEN(header) + 1 + (int)XSTRLEN(footer) + 1 + HEADER_ENCRYPTED_KEY_SIZE; } else { /* tmp buffer with a max size */ *plen = (derSz * 2) + (int)XSTRLEN(header) + 1 + (int)XSTRLEN(footer) + 1; } tmp = (byte*)XMALLOC(*plen, NULL, DYNAMIC_TYPE_PEM); if (tmp == NULL) { WOLFSSL_MSG("malloc failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); if (cipherInfo != NULL) XFREE(cipherInfo, NULL, DYNAMIC_TYPE_STRING); return WOLFSSL_FAILURE; } /* DER to PEM */ *plen = wc_DerToPemEx(derBuf, derSz, tmp, *plen, cipherInfo, type); if (*plen <= 0) { WOLFSSL_MSG("wc_DerToPemEx failed"); XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); if (cipherInfo != NULL) XFREE(cipherInfo, NULL, DYNAMIC_TYPE_STRING); return WOLFSSL_FAILURE; } XFREE(derBuf, NULL, DYNAMIC_TYPE_DER); if (cipherInfo != NULL) XFREE(cipherInfo, NULL, DYNAMIC_TYPE_STRING); *pem = (byte*)XMALLOC((*plen)+1, NULL, DYNAMIC_TYPE_KEY); if (*pem == NULL) { WOLFSSL_MSG("malloc failed"); XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); return WOLFSSL_FAILURE; } XMEMSET(*pem, 0, (*plen)+1); if (XMEMCPY(*pem, tmp, *plen) == NULL) { WOLFSSL_MSG("XMEMCPY failed"); XFREE(pem, NULL, DYNAMIC_TYPE_KEY); XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); return WOLFSSL_FAILURE; } XFREE(tmp, NULL, DYNAMIC_TYPE_PEM); return WOLFSSL_SUCCESS; #else (void)dsa; (void)cipher; (void)passwd; (void)passwdSz; (void)pem; (void)plen; return WOLFSSL_FAILURE; #endif /* WOLFSSL_PEM_TO_DER || WOLFSSL_DER_TO_PEM */ } #ifndef NO_FILESYSTEM /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_PEM_write_DSAPrivateKey(XFILE fp, WOLFSSL_DSA *dsa, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u) { byte *pem; int plen, ret; (void)cb; (void)u; WOLFSSL_MSG("wolfSSL_PEM_write_DSAPrivateKey"); if (fp == XBADFILE || dsa == NULL || dsa->internal == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } ret = wolfSSL_PEM_write_mem_DSAPrivateKey(dsa, enc, kstr, klen, &pem, &plen); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("wolfSSL_PEM_write_mem_DSAPrivateKey failed"); return WOLFSSL_FAILURE; } ret = (int)XFWRITE(pem, plen, 1, fp); if (ret != 1) { WOLFSSL_MSG("DSA private key file write failed"); return WOLFSSL_FAILURE; } XFREE(pem, NULL, DYNAMIC_TYPE_KEY); return WOLFSSL_SUCCESS; } #endif /* NO_FILESYSTEM */ #endif /* defined(WOLFSSL_KEY_GEN) */ #ifndef NO_FILESYSTEM /* return code compliant with OpenSSL : * 1 if success, 0 if error */ #ifndef NO_WOLFSSL_STUB int wolfSSL_PEM_write_DSA_PUBKEY(XFILE fp, WOLFSSL_DSA *x) { (void)fp; (void)x; WOLFSSL_STUB("PEM_write_DSA_PUBKEY"); WOLFSSL_MSG("wolfSSL_PEM_write_DSA_PUBKEY not implemented"); return WOLFSSL_FAILURE; } #endif #endif /* NO_FILESYSTEM */ #endif /* #ifndef NO_DSA */ static int pem_read_bio_key(WOLFSSL_BIO* bio, pem_password_cb* cb, void* pass, int keyType, int* eccFlag, DerBuffer** der) { #ifdef WOLFSSL_SMALL_STACK EncryptedInfo* info = NULL; #else EncryptedInfo info[1]; #endif /* WOLFSSL_SMALL_STACK */ pem_password_cb* localCb = NULL; char* mem = NULL; int memSz = 0; int ret; if(cb) { localCb = cb; } else { if(pass) { localCb = wolfSSL_PEM_def_callback; } } if ((ret = wolfSSL_BIO_pending(bio)) > 0) { memSz = ret; mem = (char*)XMALLOC(memSz, bio->heap, DYNAMIC_TYPE_OPENSSL); if (mem == NULL) { WOLFSSL_MSG("Memory error"); ret = MEMORY_E; } if (ret >= 0) { if ((ret = wolfSSL_BIO_read(bio, mem, memSz)) <= 0) { XFREE(mem, bio->heap, DYNAMIC_TYPE_OPENSSL); mem = NULL; ret = MEMORY_E; } } } else if (bio->type == WOLFSSL_BIO_FILE) { int sz = 100; /* read from file by 100 byte chunks */ int idx = 0; char* tmp = (char*)XMALLOC(sz, bio->heap, DYNAMIC_TYPE_OPENSSL); memSz = 0; if (tmp == NULL) { WOLFSSL_MSG("Memory error"); ret = MEMORY_E; } while (ret >= 0 && (sz = wolfSSL_BIO_read(bio, tmp, sz)) > 0) { char* newMem; if (memSz + sz < 0) { /* sanity check */ break; } newMem = (char*)XREALLOC(mem, memSz + sz, bio->heap, DYNAMIC_TYPE_OPENSSL); if (newMem == NULL) { WOLFSSL_MSG("Memory error"); XFREE(mem, bio->heap, DYNAMIC_TYPE_OPENSSL); mem = NULL; XFREE(tmp, bio->heap, DYNAMIC_TYPE_OPENSSL); tmp = NULL; ret = MEMORY_E; break; } mem = newMem; XMEMCPY(mem + idx, tmp, sz); memSz += sz; idx += sz; sz = 100; /* read another 100 byte chunk from file */ } XFREE(tmp, bio->heap, DYNAMIC_TYPE_OPENSSL); tmp = NULL; if (memSz <= 0) { WOLFSSL_MSG("No data to read from bio"); if (mem != NULL) { XFREE(mem, bio->heap, DYNAMIC_TYPE_OPENSSL); mem = NULL; } ret = BUFFER_E; } } else { WOLFSSL_MSG("No data to read from bio"); ret = NOT_COMPILED_IN; } #ifdef WOLFSSL_SMALL_STACK if (ret >= 0) { info = (EncryptedInfo*)XMALLOC(sizeof(EncryptedInfo), NULL, DYNAMIC_TYPE_TMP_BUFFER); if (info == NULL) { WOLFSSL_MSG("Error getting memory for EncryptedInfo structure"); XFREE(mem, bio->heap, DYNAMIC_TYPE_OPENSSL); mem = NULL; ret = MEMORY_E; } } #endif if (ret >= 0) { XMEMSET(info, 0, sizeof(EncryptedInfo)); info->passwd_cb = localCb; info->passwd_userdata = pass; ret = PemToDer((const unsigned char*)mem, memSz, keyType, der, NULL, info, eccFlag); if (ret < 0) { WOLFSSL_MSG("Bad Pem To Der"); } else { /* write left over data back to bio */ if ((memSz - (int)info->consumed) > 0 && bio->type != WOLFSSL_BIO_FILE) { if (wolfSSL_BIO_write(bio, mem + (int)info->consumed, memSz - (int)info->consumed) <= 0) { WOLFSSL_MSG("Unable to advance bio read pointer"); } } } } #ifdef WOLFSSL_SMALL_STACK XFREE(info, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif XFREE(mem, bio->heap, DYNAMIC_TYPE_OPENSSL); return ret; } WOLFSSL_EVP_PKEY* wolfSSL_PEM_read_bio_PrivateKey(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY** key, pem_password_cb* cb, void* pass) { WOLFSSL_EVP_PKEY* pkey = NULL; DerBuffer* der = NULL; int keyFormat = 0; int type = -1; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_PrivateKey"); if (bio == NULL) return pkey; if (pem_read_bio_key(bio, cb, pass, PRIVATEKEY_TYPE, &keyFormat, &der) >= 0) { const unsigned char* ptr = der->buffer; if (keyFormat) { /* keyFormat is Key_Sum enum */ if (keyFormat == RSAk) type = EVP_PKEY_RSA; else if (keyFormat == ECDSAk) type = EVP_PKEY_EC; else if (keyFormat == DSAk) type = EVP_PKEY_DSA; else if (keyFormat == DHk) type = EVP_PKEY_DH; } else { /* Default to RSA if format is not set */ type = EVP_PKEY_RSA; } /* handle case where reuse is attempted */ if (key != NULL && *key != NULL) pkey = *key; wolfSSL_d2i_PrivateKey(type, &pkey, &ptr, der->length); if (pkey == NULL) { WOLFSSL_MSG("Error loading DER buffer into WOLFSSL_EVP_PKEY"); } } FreeDer(&der); if (key != NULL && pkey != NULL) *key = pkey; WOLFSSL_LEAVE("wolfSSL_PEM_read_bio_PrivateKey", 0); return pkey; } WOLFSSL_EVP_PKEY *wolfSSL_PEM_read_bio_PUBKEY(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY **key, pem_password_cb *cb, void *pass) { WOLFSSL_EVP_PKEY* pkey = NULL; DerBuffer* der = NULL; int keyFormat = 0; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_PUBKEY"); if (bio == NULL) return pkey; if (pem_read_bio_key(bio, cb, pass, PUBLICKEY_TYPE, &keyFormat, &der) >= 0) { const unsigned char* ptr = der->buffer; /* handle case where reuse is attempted */ if (key != NULL && *key != NULL) pkey = *key; wolfSSL_d2i_PUBKEY(&pkey, &ptr, der->length); if (pkey == NULL) { WOLFSSL_MSG("Error loading DER buffer into WOLFSSL_EVP_PKEY"); } } FreeDer(&der); if (key != NULL && pkey != NULL) *key = pkey; WOLFSSL_LEAVE("wolfSSL_PEM_read_bio_PUBKEY", 0); return pkey; } #if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA) /* Uses the same format of input as wolfSSL_PEM_read_bio_PrivateKey but expects * the results to be an RSA key. * * bio structure to read RSA private key from * rsa if not null is then set to the result * cb password callback for reading PEM * pass password string * * returns a pointer to a new WOLFSSL_RSA structure on success and NULL on fail */ WOLFSSL_RSA* wolfSSL_PEM_read_bio_RSAPrivateKey(WOLFSSL_BIO* bio, WOLFSSL_RSA** rsa, pem_password_cb* cb, void* pass) { WOLFSSL_EVP_PKEY* pkey; WOLFSSL_RSA* local; WOLFSSL_ENTER("PEM_read_bio_RSAPrivateKey"); pkey = wolfSSL_PEM_read_bio_PrivateKey(bio, NULL, cb, pass); if (pkey == NULL) { return NULL; } /* Since the WOLFSSL_RSA structure is being taken from WOLFSSL_EVP_PEKY the * flag indicating that the WOLFSSL_RSA structure is owned should be FALSE * to avoid having it free'd */ pkey->ownRsa = 0; local = pkey->rsa; if (rsa != NULL) { *rsa = local; } wolfSSL_EVP_PKEY_free(pkey); return local; } #endif /* OPENSSL_EXTRA || OPENSSL_ALL || !NO_RSA */ #if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && (!defined(NO_CERTS) && \ !defined(NO_FILESYSTEM) && !defined(NO_DSA) && defined(WOLFSSL_KEY_GEN)) /* Uses the same format of input as wolfSSL_PEM_read_bio_PrivateKey but expects * the results to be an DSA key. * * bio structure to read DSA private key from * dsa if not null is then set to the result * cb password callback for reading PEM * pass password string * * returns a pointer to a new WOLFSSL_DSA structure on success and NULL on fail */ WOLFSSL_DSA* wolfSSL_PEM_read_bio_DSAPrivateKey(WOLFSSL_BIO* bio, WOLFSSL_DSA** dsa, pem_password_cb* cb,void *pass) { WOLFSSL_EVP_PKEY* pkey = NULL; WOLFSSL_DSA* local; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_DSAPrivateKey"); pkey = wolfSSL_PEM_read_bio_PrivateKey(bio, NULL, cb, pass); if (pkey == NULL) { WOLFSSL_MSG("Error in PEM_read_bio_PrivateKey"); return NULL; } /* Since the WOLFSSL_DSA structure is being taken from WOLFSSL_EVP_PKEY the * flag indicating that the WOLFSSL_DSA structure is owned should be FALSE * to avoid having it free'd */ pkey->ownDsa = 0; local = pkey->dsa; if (dsa != NULL) { *dsa = local; } wolfSSL_EVP_PKEY_free(pkey); return local; } /* Reads an DSA public key from a WOLFSSL_BIO into a WOLFSSL_DSA. * Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE */ WOLFSSL_DSA *wolfSSL_PEM_read_bio_DSA_PUBKEY(WOLFSSL_BIO* bio,WOLFSSL_DSA** dsa, pem_password_cb* cb, void *pass) { WOLFSSL_EVP_PKEY* pkey; WOLFSSL_DSA* local; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_DSA_PUBKEY"); pkey = wolfSSL_PEM_read_bio_PUBKEY(bio, NULL, cb, pass); if (pkey == NULL) { WOLFSSL_MSG("wolfSSL_PEM_read_bio_PUBKEY failed"); return NULL; } /* Since the WOLFSSL_DSA structure is being taken from WOLFSSL_EVP_PKEY the * flag indicating that the WOLFSSL_DSA structure is owned should be FALSE * to avoid having it free'd */ pkey->ownDsa = 0; local = pkey->dsa; if (dsa != NULL) { *dsa = local; } wolfSSL_EVP_PKEY_free(pkey); return local; } #endif #ifdef HAVE_ECC /* returns a new WOLFSSL_EC_GROUP structure on success and NULL on fail */ WOLFSSL_EC_GROUP* wolfSSL_PEM_read_bio_ECPKParameters(WOLFSSL_BIO* bio, WOLFSSL_EC_GROUP** group, pem_password_cb* cb, void* pass) { WOLFSSL_EVP_PKEY* pkey; WOLFSSL_EC_GROUP* ret = NULL; /* check on if bio is null is done in wolfSSL_PEM_read_bio_PrivateKey */ pkey = wolfSSL_PEM_read_bio_PrivateKey(bio, NULL, cb, pass); if (pkey != NULL) { if (pkey->type != EVP_PKEY_EC) { WOLFSSL_MSG("Unexpected key type"); } else { ret = (WOLFSSL_EC_GROUP*)wolfSSL_EC_KEY_get0_group(pkey->ecc); /* set ecc group to null so it is not free'd when pkey is free'd */ pkey->ecc->group = NULL; } } (void)group; wolfSSL_EVP_PKEY_free(pkey); return ret; } #endif /* HAVE_ECC */ #if !defined(NO_FILESYSTEM) WOLFSSL_EVP_PKEY *wolfSSL_PEM_read_PUBKEY(XFILE fp, EVP_PKEY **x, pem_password_cb *cb, void *u) { (void)fp; (void)x; (void)cb; (void)u; WOLFSSL_MSG("wolfSSL_PEM_read_PUBKEY not implemented"); return NULL; } #endif /* NO_FILESYSTEM */ #ifndef NO_RSA #if defined(XSNPRINTF) && !defined(HAVE_FAST_RSA) /* snprintf() must be available */ /****************************************************************************** * wolfSSL_RSA_print - writes the human readable form of RSA to bio * * RETURNS: * returns WOLFSSL_SUCCESS on success, otherwise returns WOLFSSL_FAILURE */ int wolfSSL_RSA_print(WOLFSSL_BIO* bio, WOLFSSL_RSA* rsa, int offset) { char tmp[100] = {0}; word32 idx = 0; int sz = 0; byte lbit = 0; int rawLen = 0; byte* rawKey = NULL; RsaKey* iRsa = NULL; int i = 0; mp_int *rsaElem = NULL; char rsaStr[][20] = { "Modulus:", "PublicExponent:", "PrivateExponent:", "Prime1:", "Prime2:", "Exponent1:", "Exponent2:", "Coefficient:" }; WOLFSSL_ENTER("wolfSSL_RSA_print"); (void)offset; if (bio == NULL || rsa == NULL) { return WOLFSSL_FATAL_ERROR; } if ((sz = wolfSSL_RSA_size(rsa)) < 0) { WOLFSSL_MSG("Error getting RSA key size"); return WOLFSSL_FAILURE; } iRsa = (RsaKey*)rsa->internal; XSNPRINTF(tmp, sizeof(tmp) - 1, "\n%s: (%d bit)", "RSA Private-Key", 8 * sz); tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } for (i=0; in; break; case 1: rsaElem = &iRsa->e; break; case 2: rsaElem = &iRsa->d; break; case 3: rsaElem = &iRsa->p; break; case 4: rsaElem = &iRsa->q; break; case 5: rsaElem = &iRsa->dP; break; case 6: rsaElem = &iRsa->dQ; break; case 7: rsaElem = &iRsa->u; break; default: WOLFSSL_MSG("Bad index value"); } if (i == 1) { /* Print out exponent values */ rawLen = mp_unsigned_bin_size(rsaElem); if (rawLen < 0) { WOLFSSL_MSG("Error getting exponent size"); return WOLFSSL_FAILURE; } if ((word32)rawLen < sizeof(word32)) { rawLen = sizeof(word32); } rawKey = (byte*)XMALLOC(rawLen, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (rawKey == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } XMEMSET(rawKey, 0, rawLen); mp_to_unsigned_bin(rsaElem, rawKey); if ((word32)rawLen <= sizeof(word32)) { idx = *(word32*)rawKey; #ifdef BIG_ENDIAN_ORDER idx = ByteReverseWord32(idx); #endif } XSNPRINTF(tmp, sizeof(tmp) - 1, "\nExponent: %d (0x%x)", idx, idx); if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { XFREE(rawKey, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } XFREE(rawKey, NULL, DYNAMIC_TYPE_TMP_BUFFER); } else { XSNPRINTF(tmp, sizeof(tmp) - 1, "\n%s\n ", rsaStr[i]); tmp[sizeof(tmp) - 1] = '\0'; if (mp_leading_bit(rsaElem)) { lbit = 1; XSTRNCAT(tmp, "00", 3); } rawLen = mp_unsigned_bin_size(rsaElem); rawKey = (byte*)XMALLOC(rawLen, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (rawKey == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } mp_to_unsigned_bin(rsaElem, rawKey); for (idx = 0; idx < (word32)rawLen; idx++) { char val[5]; int valSz = 5; if ((idx == 0) && !lbit) { XSNPRINTF(val, valSz - 1, "%02x", rawKey[idx]); } else if ((idx != 0) && (((idx + lbit) % 15) == 0)) { tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { XFREE(rawKey, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } XSNPRINTF(tmp, sizeof(tmp) - 1, ":\n "); XSNPRINTF(val, valSz - 1, "%02x", rawKey[idx]); } else { XSNPRINTF(val, valSz - 1, ":%02x", rawKey[idx]); } XSTRNCAT(tmp, val, valSz); } XFREE(rawKey, NULL, DYNAMIC_TYPE_TMP_BUFFER); /* print out remaining values */ if ((idx > 0) && (((idx - 1 + lbit) % 15) != 0)) { tmp[sizeof(tmp) - 1] = '\0'; if (wolfSSL_BIO_write(bio, tmp, (int)XSTRLEN(tmp)) <= 0) { return WOLFSSL_FAILURE; } } lbit = 0; } } /* done with print out */ if (wolfSSL_BIO_write(bio, "\n\0", (int)XSTRLEN("\n\0")) <= 0) { return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #endif /* XSNPRINTF */ #if !defined(NO_FILESYSTEM) #ifndef NO_WOLFSSL_STUB WOLFSSL_RSA *wolfSSL_PEM_read_RSAPublicKey(XFILE fp, WOLFSSL_RSA **x, pem_password_cb *cb, void *u) { (void)fp; (void)x; (void)cb; (void)u; WOLFSSL_STUB("PEM_read_RSAPublicKey"); WOLFSSL_MSG("wolfSSL_PEM_read_RSAPublicKey not implemented"); return NULL; } #endif /* return code compliant with OpenSSL : * 1 if success, 0 if error */ #ifndef NO_WOLFSSL_STUB int wolfSSL_PEM_write_RSAPublicKey(XFILE fp, WOLFSSL_RSA *x) { (void)fp; (void)x; WOLFSSL_STUB("PEM_write_RSAPublicKey"); WOLFSSL_MSG("wolfSSL_PEM_write_RSAPublicKey not implemented"); return WOLFSSL_FAILURE; } #endif /* return code compliant with OpenSSL : * 1 if success, 0 if error */ #ifndef NO_WOLFSSL_STUB int wolfSSL_PEM_write_RSA_PUBKEY(XFILE fp, WOLFSSL_RSA *x) { (void)fp; (void)x; WOLFSSL_STUB("PEM_write_RSA_PUBKEY"); WOLFSSL_MSG("wolfSSL_PEM_write_RSA_PUBKEY not implemented"); return WOLFSSL_FAILURE; } #endif #endif /* NO_FILESYSTEM */ WOLFSSL_RSA *wolfSSL_d2i_RSAPublicKey(WOLFSSL_RSA **r, const unsigned char **pp, long len) { WOLFSSL_RSA *rsa = NULL; WOLFSSL_ENTER("d2i_RSAPublicKey"); if (pp == NULL) { WOLFSSL_MSG("Bad argument"); return NULL; } if ((rsa = wolfSSL_RSA_new()) == NULL) { WOLFSSL_MSG("RSA_new failed"); return NULL; } if (wolfSSL_RSA_LoadDer_ex(rsa, *pp, (int)len, WOLFSSL_RSA_LOAD_PUBLIC) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("RSA_LoadDer failed"); wolfSSL_RSA_free(rsa); rsa = NULL; } if (r != NULL) *r = rsa; return rsa; } /* Converts an RSA private key from DER format to an RSA structure. Returns pointer to the RSA structure on success and NULL if error. */ WOLFSSL_RSA *wolfSSL_d2i_RSAPrivateKey(WOLFSSL_RSA **r, const unsigned char **derBuf, long derSz) { WOLFSSL_RSA *rsa = NULL; WOLFSSL_ENTER("wolfSSL_d2i_RSAPrivateKey"); /* check for bad functions arguments */ if (derBuf == NULL) { WOLFSSL_MSG("Bad argument"); return NULL; } if ((rsa = wolfSSL_RSA_new()) == NULL) { WOLFSSL_MSG("RSA_new failed"); return NULL; } if (wolfSSL_RSA_LoadDer_ex(rsa, *derBuf, (int)derSz, WOLFSSL_RSA_LOAD_PRIVATE) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("RSA_LoadDer failed"); wolfSSL_RSA_free(rsa); rsa = NULL; } if (r != NULL) *r = rsa; return rsa; } #if !defined(HAVE_FAST_RSA) && defined(WOLFSSL_KEY_GEN) && \ !defined(NO_RSA) && !defined(HAVE_USER_RSA) /* Converts an internal RSA structure to DER format. * If "pp" is null then buffer size only is returned. * If "*pp" is null then a created buffer is set in *pp and the caller is * responsible for free'ing it. * Returns size of DER on success and WOLFSSL_FAILURE if error */ int wolfSSL_i2d_RSAPrivateKey(WOLFSSL_RSA *rsa, unsigned char **pp) { int ret; WOLFSSL_ENTER("wolfSSL_i2d_RSAPrivateKey"); /* check for bad functions arguments */ if (rsa == NULL) { WOLFSSL_MSG("Bad Function Arguments"); return BAD_FUNC_ARG; } if ((ret = wolfSSL_RSA_To_Der(rsa, pp, 0)) < 0) { WOLFSSL_MSG("wolfSSL_RSA_To_Der failed"); return WOLFSSL_FAILURE; } return ret; /* returns size of DER if successful */ } int wolfSSL_i2d_RSAPublicKey(WOLFSSL_RSA *rsa, const unsigned char **pp) { int ret; /* check for bad functions arguments */ if (rsa == NULL) { WOLFSSL_MSG("Bad Function Arguments"); return BAD_FUNC_ARG; } if ((ret = wolfSSL_RSA_To_Der(rsa, (byte**)pp, 1)) < 0) { WOLFSSL_MSG("wolfSSL_RSA_To_Der failed"); return WOLFSSL_FAILURE; } return ret; } #endif /* !defined(HAVE_FAST_RSA) && defined(WOLFSSL_KEY_GEN) && \ * !defined(NO_RSA) && !defined(HAVE_USER_RSA) */ #endif /* !NO_RSA */ #endif /* OPENSSL_EXTRA */ #if !defined(NO_RSA) && (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) /* return WOLFSSL_SUCCESS if success, WOLFSSL_FATAL_ERROR if error */ int wolfSSL_RSA_LoadDer(WOLFSSL_RSA* rsa, const unsigned char* derBuf, int derSz) { return wolfSSL_RSA_LoadDer_ex(rsa, derBuf, derSz, WOLFSSL_RSA_LOAD_PRIVATE); } int wolfSSL_RSA_LoadDer_ex(WOLFSSL_RSA* rsa, const unsigned char* derBuf, int derSz, int opt) { word32 idx = 0; int ret; WOLFSSL_ENTER("wolfSSL_RSA_LoadDer"); if (rsa == NULL || rsa->internal == NULL || derBuf == NULL || derSz <= 0) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FATAL_ERROR; } if (opt == WOLFSSL_RSA_LOAD_PRIVATE) { ret = wc_RsaPrivateKeyDecode(derBuf, &idx, (RsaKey*)rsa->internal, derSz); } else { ret = wc_RsaPublicKeyDecode(derBuf, &idx, (RsaKey*)rsa->internal, derSz); } if (ret < 0) { if (opt == WOLFSSL_RSA_LOAD_PRIVATE) { WOLFSSL_MSG("RsaPrivateKeyDecode failed"); } else { WOLFSSL_MSG("RsaPublicKeyDecode failed"); } return SSL_FATAL_ERROR; } if (SetRsaExternal(rsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetRsaExternal failed"); return WOLFSSL_FATAL_ERROR; } rsa->inSet = 1; return WOLFSSL_SUCCESS; } #if defined(WC_RSA_PSS) && (defined(OPENSSL_ALL) || defined(WOLFSSL_ASIO) || \ defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_NGINX)) static int hash2mgf(enum wc_HashType hType) { switch (hType) { #ifndef NO_SHA case WC_HASH_TYPE_SHA: return WC_MGF1SHA1; #endif #ifndef NO_SHA256 #ifdef WOLFSSL_SHA224 case WC_HASH_TYPE_SHA224: return WC_MGF1SHA224; #endif case WC_HASH_TYPE_SHA256: return WC_MGF1SHA256; #endif #ifdef WOLFSSL_SHA384 case WC_HASH_TYPE_SHA384: return WC_MGF1SHA384; #endif #ifdef WOLFSSL_SHA512 case WC_HASH_TYPE_SHA512: return WC_MGF1SHA512; #endif case WC_HASH_TYPE_NONE: case WC_HASH_TYPE_MD2: case WC_HASH_TYPE_MD4: case WC_HASH_TYPE_MD5: case WC_HASH_TYPE_MD5_SHA: case WC_HASH_TYPE_SHA3_224: case WC_HASH_TYPE_SHA3_256: case WC_HASH_TYPE_SHA3_384: case WC_HASH_TYPE_SHA3_512: case WC_HASH_TYPE_BLAKE2B: case WC_HASH_TYPE_BLAKE2S: default: WOLFSSL_MSG("Unrecognized or unsupported hash function"); return WC_MGF1NONE; } } /* * +-----------+ * | M | * +-----------+ * | * V * Hash * | * V * +--------+----------+----------+ * M' = |Padding1| mHash | salt | * +--------+----------+----------+ * | * +--------+----------+ V * DB = |Padding2|maskedseed| Hash * +--------+----------+ | * | | * V | +--+ * xor <--- MGF <---| |bc| * | | +--+ * | | | * V V V * +-------------------+----------+--+ * EM = | maskedDB |maskedseed|bc| * +-------------------+----------+--+ * Diagram taken from https://tools.ietf.org/html/rfc3447#section-9.1 */ int wolfSSL_RSA_padding_add_PKCS1_PSS(WOLFSSL_RSA *rsa, unsigned char *EM, const unsigned char *mHash, const WOLFSSL_EVP_MD *hashAlg, int saltLen) { int hashLen, emLen, mgf; int ret = WOLFSSL_FAILURE; int initTmpRng = 0; WC_RNG *rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; #else WC_RNG _tmpRNG[1]; WC_RNG* tmpRNG = _tmpRNG; #endif enum wc_HashType hashType; WOLFSSL_ENTER("wolfSSL_RSA_padding_add_PKCS1_PSS"); if (!rsa || !EM || !mHash || !hashAlg) { return WOLFSSL_FAILURE; } if (!(rng = WOLFSSL_RSA_GetRNG(rsa, (WC_RNG**)&tmpRNG, &initTmpRng))) { WOLFSSL_MSG("WOLFSSL_RSA_GetRNG error"); goto cleanup; } if (!rsa->exSet && SetRsaExternal(rsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetRsaExternal error"); goto cleanup; } hashType = wolfSSL_EVP_md2macType(hashAlg); if (hashType < WC_HASH_TYPE_NONE || hashType > WC_HASH_TYPE_MAX) { WOLFSSL_MSG("wolfSSL_EVP_md2macType error"); goto cleanup; } if ((mgf = hash2mgf(hashType)) == WC_MGF1NONE) { WOLFSSL_MSG("hash2mgf error"); goto cleanup; } if ((hashLen = wolfSSL_EVP_MD_size(hashAlg)) < 0) { WOLFSSL_MSG("wolfSSL_EVP_MD_size error"); goto cleanup; } if ((emLen = wolfSSL_RSA_size(rsa)) <= 0) { WOLFSSL_MSG("wolfSSL_RSA_size error"); goto cleanup; } switch (saltLen) { /* Negative saltLen values are treated differently */ case RSA_PSS_SALTLEN_DIGEST: saltLen = hashLen; break; case RSA_PSS_SALTLEN_MAX_SIGN: case RSA_PSS_SALTLEN_MAX: saltLen = emLen - hashLen - 2; break; default: if (saltLen < 0) { /* Not any currently implemented negative value */ WOLFSSL_MSG("invalid saltLen"); goto cleanup; } } if (wc_RsaPad_ex(mHash, wolfSSL_EVP_MD_size(hashAlg), EM, emLen, RSA_BLOCK_TYPE_1, rng, WC_RSA_PSS_PAD, wolfSSL_EVP_md2macType(hashAlg), mgf, NULL, 0, saltLen, wolfSSL_BN_num_bits(rsa->n), NULL) != MP_OKAY) { WOLFSSL_MSG("wc_RsaPad_ex error"); goto cleanup; } ret = WOLFSSL_SUCCESS; cleanup: if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK if (tmpRNG) XFREE(tmpRNG, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif return ret; } /* * Refer to wolfSSL_RSA_padding_add_PKCS1_PSS * for an explanation of the parameters. */ int wolfSSL_RSA_verify_PKCS1_PSS(WOLFSSL_RSA *rsa, const unsigned char *mHash, const WOLFSSL_EVP_MD *hashAlg, const unsigned char *EM, int saltLen) { int hashLen, mgf, emLen, mPrimeLen; enum wc_HashType hashType; byte *mPrime = NULL; byte *buf = NULL; WOLFSSL_ENTER("wolfSSL_RSA_verify_PKCS1_PSS"); if (!rsa || !mHash || !hashAlg || !EM) { return WOLFSSL_FAILURE; } if ((hashLen = wolfSSL_EVP_MD_size(hashAlg)) < 0) { return WOLFSSL_FAILURE; } if ((emLen = wolfSSL_RSA_size(rsa)) <= 0) { WOLFSSL_MSG("wolfSSL_RSA_size error"); return WOLFSSL_FAILURE; } switch (saltLen) { /* Negative saltLen values are treated differently */ case RSA_PSS_SALTLEN_DIGEST: saltLen = hashLen; break; case RSA_PSS_SALTLEN_MAX_SIGN: case RSA_PSS_SALTLEN_MAX: saltLen = emLen - hashLen - 2; break; default: if (saltLen < 0) { /* Not any currently implemented negative value */ WOLFSSL_MSG("invalid saltLen"); return WOLFSSL_FAILURE; } } if (!rsa->exSet && SetRsaExternal(rsa) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } hashType = wolfSSL_EVP_md2macType(hashAlg); if (hashType < WC_HASH_TYPE_NONE || hashType > WC_HASH_TYPE_MAX) { WOLFSSL_MSG("wolfSSL_EVP_md2macType error"); return WOLFSSL_FAILURE; } if ((mgf = hash2mgf(hashType)) == WC_MGF1NONE) { WOLFSSL_MSG("hash2mgf error"); return WOLFSSL_FAILURE; } if ((hashLen = wolfSSL_EVP_MD_size(hashAlg)) < 0) { WOLFSSL_MSG("wolfSSL_EVP_MD_size error"); return WOLFSSL_FAILURE; } if (!(buf = (byte*)XMALLOC(emLen, NULL, DYNAMIC_TYPE_TMP_BUFFER))) { WOLFSSL_MSG("malloc error"); return WOLFSSL_FAILURE; } XMEMCPY(buf, EM, emLen); /* Remove and verify the PSS padding */ if ((mPrimeLen = wc_RsaUnPad_ex(buf, emLen, &mPrime, RSA_BLOCK_TYPE_1, WC_RSA_PSS_PAD, hashType, mgf, NULL, 0, saltLen, wolfSSL_BN_num_bits(rsa->n), NULL)) < 0) { WOLFSSL_MSG("wc_RsaPad_ex error"); XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } /* Verify the hash is correct */ if (wc_RsaPSS_CheckPadding_ex(mHash, hashLen, mPrime, mPrimeLen, hashType, saltLen, wolfSSL_BN_num_bits(rsa->n)) != MP_OKAY) { WOLFSSL_MSG("wc_RsaPSS_CheckPadding_ex error"); XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_SUCCESS; } #endif #if defined(OPENSSL_EXTRA) WOLFSSL_RSA_METHOD *wolfSSL_RSA_meth_new(const char *name, int flags) { int name_len; WOLFSSL_RSA_METHOD* meth; if (name == NULL) { return NULL; } meth = (WOLFSSL_RSA_METHOD*)XMALLOC(sizeof(WOLFSSL_RSA_METHOD), NULL, DYNAMIC_TYPE_OPENSSL); name_len = (int)XSTRLEN(name); if (!meth) { return NULL; } meth->flags = flags; meth->name = (char*)XMALLOC(name_len+1, NULL, DYNAMIC_TYPE_OPENSSL); if (!meth->name) { XFREE(meth, NULL, DYNAMIC_TYPE_OPENSSL); return NULL; } XMEMCPY(meth->name, name, name_len+1); return meth; } void wolfSSL_RSA_meth_free(WOLFSSL_RSA_METHOD *meth) { if (meth) { XFREE(meth->name, NULL, DYNAMIC_TYPE_OPENSSL); XFREE(meth, NULL, DYNAMIC_TYPE_OPENSSL); } } #ifndef NO_WOLFSSL_STUB int wolfSSL_RSA_meth_set(WOLFSSL_RSA_METHOD *rsa, void* p) { (void)rsa; (void)p; WOLFSSL_STUB("RSA_METHOD is not implemented."); return 1; } #endif int wolfSSL_RSA_set_method(WOLFSSL_RSA *rsa, WOLFSSL_RSA_METHOD *meth) { if (rsa) rsa->meth = meth; return 1; } const WOLFSSL_RSA_METHOD* wolfSSL_RSA_get_method(const WOLFSSL_RSA *rsa) { if (!rsa) { return NULL; } return rsa->meth; } const WOLFSSL_RSA_METHOD* wolfSSL_RSA_get_default_method(void) { return wolfSSL_RSA_meth_new("wolfSSL RSA", 0); } int wolfSSL_RSA_flags(const WOLFSSL_RSA *r) { if (r && r->meth) { return r->meth->flags; } else { return 0; } } void wolfSSL_RSA_set_flags(WOLFSSL_RSA *r, int flags) { if (r && r->meth) { r->meth->flags = flags; } } #if defined(WOLFSSL_KEY_GEN) && !defined(NO_RSA) && !defined(HAVE_USER_RSA) WOLFSSL_RSA* wolfSSL_RSAPublicKey_dup(WOLFSSL_RSA *rsa) { int derSz = 0; byte *derBuf = NULL; WOLFSSL_RSA* local; WOLFSSL_ENTER("wolfSSL_RSAPublicKey_dup"); if (!rsa) { return NULL; } local = wolfSSL_RSA_new(); if (local == NULL) { WOLFSSL_MSG("Error creating a new WOLFSSL_RSA structure"); return NULL; } if ((derSz = wolfSSL_RSA_To_Der(rsa, &derBuf, 1)) < 0) { WOLFSSL_MSG("wolfSSL_RSA_To_Der failed"); return NULL; } if (wolfSSL_RSA_LoadDer_ex(local, derBuf, derSz, WOLFSSL_RSA_LOAD_PUBLIC) != SSL_SUCCESS) { wolfSSL_RSA_free(local); local = NULL; } XFREE(derBuf, NULL, DYNAMIC_TYPE_ASN1); return local; } #endif void* wolfSSL_RSA_get_ex_data(const WOLFSSL_RSA *rsa, int idx) { WOLFSSL_ENTER("wolfSSL_RSA_get_ex_data"); #ifdef HAVE_EX_DATA if (rsa) { return wolfSSL_CRYPTO_get_ex_data(&rsa->ex_data, idx); } #else (void)rsa; (void)idx; #endif return NULL; } int wolfSSL_RSA_set_ex_data(WOLFSSL_RSA *rsa, int idx, void *data) { WOLFSSL_ENTER("wolfSSL_RSA_set_ex_data"); #ifdef HAVE_EX_DATA if (rsa) { return wolfSSL_CRYPTO_set_ex_data(&rsa->ex_data, idx, data); } #else (void)rsa; (void)idx; (void)data; #endif return WOLFSSL_FAILURE; } int wolfSSL_RSA_set0_key(WOLFSSL_RSA *r, WOLFSSL_BIGNUM *n, WOLFSSL_BIGNUM *e, WOLFSSL_BIGNUM *d) { /* If the fields n and e in r are NULL, the corresponding input * parameters MUST be non-NULL for n and e. d may be * left NULL (in case only the public key is used). */ if ((!r->n && !n) || (!r->e && !e)) return 0; if (n) { wolfSSL_BN_free(r->n); r->n = n; } if (e) { wolfSSL_BN_free(r->e); r->e = e; } if (d) { wolfSSL_BN_clear_free(r->d); r->d = d; } return 1; } #endif /* OPENSSL_EXTRA */ #endif /* NO_RSA */ #ifdef OPENSSL_EXTRA #ifndef NO_DSA /* return WOLFSSL_SUCCESS if success, WOLFSSL_FATAL_ERROR if error */ int wolfSSL_DSA_LoadDer(WOLFSSL_DSA* dsa, const unsigned char* derBuf, int derSz) { word32 idx = 0; int ret; WOLFSSL_ENTER("wolfSSL_DSA_LoadDer"); if (dsa == NULL || dsa->internal == NULL || derBuf == NULL || derSz <= 0) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FATAL_ERROR; } ret = DsaPrivateKeyDecode(derBuf, &idx, (DsaKey*)dsa->internal, derSz); if (ret < 0) { WOLFSSL_MSG("DsaPrivateKeyDecode failed"); return WOLFSSL_FATAL_ERROR; } if (SetDsaExternal(dsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetDsaExternal failed"); return WOLFSSL_FATAL_ERROR; } dsa->inSet = 1; return WOLFSSL_SUCCESS; } /* Loads DSA key from DER buffer. opt = DSA_LOAD_PRIVATE or DSA_LOAD_PUBLIC. returns 1 on success, or 0 on failure. */ int wolfSSL_DSA_LoadDer_ex(WOLFSSL_DSA* dsa, const unsigned char* derBuf, int derSz, int opt) { word32 idx = 0; int ret; WOLFSSL_ENTER("wolfSSL_DSA_LoadDer"); if (dsa == NULL || dsa->internal == NULL || derBuf == NULL || derSz <= 0) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FATAL_ERROR; } if (opt == WOLFSSL_DSA_LOAD_PRIVATE) { ret = DsaPrivateKeyDecode(derBuf, &idx, (DsaKey*)dsa->internal, derSz); } else { ret = DsaPublicKeyDecode(derBuf, &idx, (DsaKey*)dsa->internal, derSz); } if (ret < 0 && opt == WOLFSSL_DSA_LOAD_PRIVATE) { WOLFSSL_MSG("DsaPrivateKeyDecode failed"); return WOLFSSL_FATAL_ERROR; } else if (ret < 0 && opt == WOLFSSL_DSA_LOAD_PUBLIC) { WOLFSSL_MSG("DsaPublicKeyDecode failed"); return WOLFSSL_FATAL_ERROR; } if (SetDsaExternal(dsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetDsaExternal failed"); return WOLFSSL_FATAL_ERROR; } dsa->inSet = 1; return WOLFSSL_SUCCESS; } #endif /* !NO_DSA */ #ifdef HAVE_ECC /* return WOLFSSL_SUCCESS if success, WOLFSSL_FATAL_ERROR if error */ int wolfSSL_EC_KEY_LoadDer(WOLFSSL_EC_KEY* key, const unsigned char* derBuf, int derSz) { return wolfSSL_EC_KEY_LoadDer_ex(key, derBuf, derSz, WOLFSSL_EC_KEY_LOAD_PRIVATE); } int wolfSSL_EC_KEY_LoadDer_ex(WOLFSSL_EC_KEY* key, const unsigned char* derBuf, int derSz, int opt) { word32 idx = 0; int ret; WOLFSSL_ENTER("wolfSSL_EC_KEY_LoadDer"); if (key == NULL || key->internal == NULL || derBuf == NULL || derSz <= 0) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FATAL_ERROR; } if (opt == WOLFSSL_EC_KEY_LOAD_PRIVATE) { ret = wc_EccPrivateKeyDecode(derBuf, &idx, (ecc_key*)key->internal, derSz); } else { ret = wc_EccPublicKeyDecode(derBuf, &idx, (ecc_key*)key->internal, derSz); } if (ret < 0) { if (opt == WOLFSSL_EC_KEY_LOAD_PRIVATE) { WOLFSSL_MSG("wc_EccPrivateKeyDecode failed"); } else { WOLFSSL_MSG("wc_EccPublicKeyDecode failed"); } return WOLFSSL_FATAL_ERROR; } if (SetECKeyExternal(key) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetECKeyExternal failed"); return WOLFSSL_FATAL_ERROR; } key->inSet = 1; return WOLFSSL_SUCCESS; } #endif /* HAVE_ECC */ #if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL) || defined(WOLFSSL_OPENSSH)) /* return WOLFSSL_SUCCESS if success, WOLFSSL_FATAL_ERROR if error */ int wolfSSL_DH_LoadDer(WOLFSSL_DH* dh, const unsigned char* derBuf, int derSz) { word32 idx = 0; int ret; if (dh == NULL || dh->internal == NULL || derBuf == NULL || derSz <= 0) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FATAL_ERROR; } ret = wc_DhKeyDecode(derBuf, &idx, (DhKey*)dh->internal, (word32)derSz); if (ret < 0) { WOLFSSL_MSG("wc_DhKeyDecode failed"); return WOLFSSL_FATAL_ERROR; } if (SetDhExternal(dh) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetDhExternal failed"); return WOLFSSL_FATAL_ERROR; } return WOLFSSL_SUCCESS; } #endif /* ! NO_DH && WOLFSSL_QT || OPENSSL_ALL */ #endif /* OPENSSL_EXTRA */ #if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL) /* increments ref count of WOLFSSL_RSA. Return 1 on success, 0 on error */ int wolfSSL_RSA_up_ref(WOLFSSL_RSA* rsa) { if (rsa) { if (wc_LockMutex(&rsa->refMutex) != 0) { WOLFSSL_MSG("Failed to lock x509 mutex"); } rsa->refCount++; wc_UnLockMutex(&rsa->refMutex); return 1; } return 0; } /* increments ref count of WOLFSSL_X509. Return 1 on success, 0 on error */ int wolfSSL_X509_up_ref(WOLFSSL_X509* x509) { if (x509) { if (wc_LockMutex(&x509->refMutex) != 0) { WOLFSSL_MSG("Failed to lock x509 mutex"); } x509->refCount++; wc_UnLockMutex(&x509->refMutex); return 1; } return 0; } #endif /* OPENSSL_EXTRA || OPENSSL_ALL */ #ifdef WOLFSSL_ALT_CERT_CHAINS int wolfSSL_is_peer_alt_cert_chain(const WOLFSSL* ssl) { int isUsing = 0; if (ssl) isUsing = ssl->options.usingAltCertChain; return isUsing; } #endif /* WOLFSSL_ALT_CERT_CHAINS */ #ifdef SESSION_CERTS #ifdef WOLFSSL_ALT_CERT_CHAINS /* Get peer's alternate certificate chain */ WOLFSSL_X509_CHAIN* wolfSSL_get_peer_alt_chain(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_peer_alt_chain"); if (ssl) return &ssl->session.altChain; return 0; } #endif /* WOLFSSL_ALT_CERT_CHAINS */ /* Get peer's certificate chain */ WOLFSSL_X509_CHAIN* wolfSSL_get_peer_chain(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_peer_chain"); if (ssl) return &ssl->session.chain; return 0; } /* Get peer's certificate chain total count */ int wolfSSL_get_chain_count(WOLFSSL_X509_CHAIN* chain) { WOLFSSL_ENTER("wolfSSL_get_chain_count"); if (chain) return chain->count; return 0; } /* Get peer's ASN.1 DER certificate at index (idx) length in bytes */ int wolfSSL_get_chain_length(WOLFSSL_X509_CHAIN* chain, int idx) { WOLFSSL_ENTER("wolfSSL_get_chain_length"); if (chain) return chain->certs[idx].length; return 0; } /* Get peer's ASN.1 DER certificate at index (idx) */ byte* wolfSSL_get_chain_cert(WOLFSSL_X509_CHAIN* chain, int idx) { WOLFSSL_ENTER("wolfSSL_get_chain_cert"); if (chain) return chain->certs[idx].buffer; return 0; } /* Get peer's wolfSSL X509 certificate at index (idx) */ WOLFSSL_X509* wolfSSL_get_chain_X509(WOLFSSL_X509_CHAIN* chain, int idx) { int ret; WOLFSSL_X509* x509 = NULL; #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert = NULL; #else DecodedCert cert[1]; #endif WOLFSSL_ENTER("wolfSSL_get_chain_X509"); if (chain != NULL) { #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (cert != NULL) #endif { InitDecodedCert(cert, chain->certs[idx].buffer, chain->certs[idx].length, NULL); if ((ret = ParseCertRelative(cert, CERT_TYPE, 0, NULL)) != 0) { WOLFSSL_MSG("Failed to parse cert"); } else { x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL, DYNAMIC_TYPE_X509); if (x509 == NULL) { WOLFSSL_MSG("Failed alloc X509"); } else { InitX509(x509, 1, NULL); if ((ret = CopyDecodedToX509(x509, cert)) != 0) { WOLFSSL_MSG("Failed to copy decoded"); wolfSSL_X509_free(x509); x509 = NULL; } } } FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, NULL, DYNAMIC_TYPE_DCERT); #endif } } (void)ret; return x509; } /* Get peer's PEM certificate at index (idx), output to buffer if inLen big enough else return error (-1). If buffer is NULL only calculate outLen. Output length is in *outLen WOLFSSL_SUCCESS on ok */ int wolfSSL_get_chain_cert_pem(WOLFSSL_X509_CHAIN* chain, int idx, unsigned char* buf, int inLen, int* outLen) { #if defined(WOLFSSL_PEM_TO_DER) || defined(WOLFSSL_DER_TO_PEM) const char* header = NULL; const char* footer = NULL; int headerLen; int footerLen; int i; int err; word32 szNeeded = 0; WOLFSSL_ENTER("wolfSSL_get_chain_cert_pem"); if (!chain || !outLen || idx < 0 || idx >= wolfSSL_get_chain_count(chain)) return BAD_FUNC_ARG; err = wc_PemGetHeaderFooter(CERT_TYPE, &header, &footer); if (err != 0) return err; headerLen = (int)XSTRLEN(header); footerLen = (int)XSTRLEN(footer); /* Null output buffer return size needed in outLen */ if(!buf) { if(Base64_Encode(chain->certs[idx].buffer, chain->certs[idx].length, NULL, &szNeeded) != LENGTH_ONLY_E) return WOLFSSL_FAILURE; *outLen = szNeeded + headerLen + footerLen; return LENGTH_ONLY_E; } /* don't even try if inLen too short */ if (inLen < headerLen + footerLen + chain->certs[idx].length) return BAD_FUNC_ARG; /* header */ if (XMEMCPY(buf, header, headerLen) == NULL) return WOLFSSL_FATAL_ERROR; i = headerLen; /* body */ *outLen = inLen; /* input to Base64_Encode */ if ( (err = Base64_Encode(chain->certs[idx].buffer, chain->certs[idx].length, buf + i, (word32*)outLen)) < 0) return err; i += *outLen; /* footer */ if ( (i + footerLen) > inLen) return BAD_FUNC_ARG; if (XMEMCPY(buf + i, footer, footerLen) == NULL) return WOLFSSL_FATAL_ERROR; *outLen += headerLen + footerLen; return WOLFSSL_SUCCESS; #else (void)chain; (void)idx; (void)buf; (void)inLen; (void)outLen; return WOLFSSL_FAILURE; #endif /* WOLFSSL_PEM_TO_DER || WOLFSSL_DER_TO_PEM */ } /* get session ID */ WOLFSSL_ABI const byte* wolfSSL_get_sessionID(const WOLFSSL_SESSION* session) { WOLFSSL_ENTER("wolfSSL_get_sessionID"); if (session) return session->sessionID; return NULL; } #endif /* SESSION_CERTS */ #ifdef HAVE_FUZZER void wolfSSL_SetFuzzerCb(WOLFSSL* ssl, CallbackFuzzer cbf, void* fCtx) { if (ssl) { ssl->fuzzerCb = cbf; ssl->fuzzerCtx = fCtx; } } #endif #ifndef NO_CERTS #ifdef HAVE_PK_CALLBACKS #ifdef HAVE_ECC void wolfSSL_CTX_SetEccKeyGenCb(WOLFSSL_CTX* ctx, CallbackEccKeyGen cb) { if (ctx) ctx->EccKeyGenCb = cb; } void wolfSSL_SetEccKeyGenCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->EccKeyGenCtx = ctx; } void* wolfSSL_GetEccKeyGenCtx(WOLFSSL* ssl) { if (ssl) return ssl->EccKeyGenCtx; return NULL; } WOLFSSL_ABI void wolfSSL_CTX_SetEccSignCb(WOLFSSL_CTX* ctx, CallbackEccSign cb) { if (ctx) ctx->EccSignCb = cb; } void wolfSSL_SetEccSignCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->EccSignCtx = ctx; } void* wolfSSL_GetEccSignCtx(WOLFSSL* ssl) { if (ssl) return ssl->EccSignCtx; return NULL; } void wolfSSL_CTX_SetEccVerifyCb(WOLFSSL_CTX* ctx, CallbackEccVerify cb) { if (ctx) ctx->EccVerifyCb = cb; } void wolfSSL_SetEccVerifyCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->EccVerifyCtx = ctx; } void* wolfSSL_GetEccVerifyCtx(WOLFSSL* ssl) { if (ssl) return ssl->EccVerifyCtx; return NULL; } void wolfSSL_CTX_SetEccSharedSecretCb(WOLFSSL_CTX* ctx, CallbackEccSharedSecret cb) { if (ctx) ctx->EccSharedSecretCb = cb; } void wolfSSL_SetEccSharedSecretCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->EccSharedSecretCtx = ctx; } void* wolfSSL_GetEccSharedSecretCtx(WOLFSSL* ssl) { if (ssl) return ssl->EccSharedSecretCtx; return NULL; } #endif /* HAVE_ECC */ #ifdef HAVE_ED25519 void wolfSSL_CTX_SetEd25519SignCb(WOLFSSL_CTX* ctx, CallbackEd25519Sign cb) { if (ctx) ctx->Ed25519SignCb = cb; } void wolfSSL_SetEd25519SignCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->Ed25519SignCtx = ctx; } void* wolfSSL_GetEd25519SignCtx(WOLFSSL* ssl) { if (ssl) return ssl->Ed25519SignCtx; return NULL; } void wolfSSL_CTX_SetEd25519VerifyCb(WOLFSSL_CTX* ctx, CallbackEd25519Verify cb) { if (ctx) ctx->Ed25519VerifyCb = cb; } void wolfSSL_SetEd25519VerifyCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->Ed25519VerifyCtx = ctx; } void* wolfSSL_GetEd25519VerifyCtx(WOLFSSL* ssl) { if (ssl) return ssl->Ed25519VerifyCtx; return NULL; } #endif /* HAVE_ED25519 */ #ifdef HAVE_CURVE25519 void wolfSSL_CTX_SetX25519KeyGenCb(WOLFSSL_CTX* ctx, CallbackX25519KeyGen cb) { if (ctx) ctx->X25519KeyGenCb = cb; } void wolfSSL_SetX25519KeyGenCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->X25519KeyGenCtx = ctx; } void* wolfSSL_GetX25519KeyGenCtx(WOLFSSL* ssl) { if (ssl) return ssl->X25519KeyGenCtx; return NULL; } void wolfSSL_CTX_SetX25519SharedSecretCb(WOLFSSL_CTX* ctx, CallbackX25519SharedSecret cb) { if (ctx) ctx->X25519SharedSecretCb = cb; } void wolfSSL_SetX25519SharedSecretCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->X25519SharedSecretCtx = ctx; } void* wolfSSL_GetX25519SharedSecretCtx(WOLFSSL* ssl) { if (ssl) return ssl->X25519SharedSecretCtx; return NULL; } #endif /* HAVE_CURVE25519 */ #ifdef HAVE_ED448 void wolfSSL_CTX_SetEd448SignCb(WOLFSSL_CTX* ctx, CallbackEd448Sign cb) { if (ctx) ctx->Ed448SignCb = cb; } void wolfSSL_SetEd448SignCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->Ed448SignCtx = ctx; } void* wolfSSL_GetEd448SignCtx(WOLFSSL* ssl) { if (ssl) return ssl->Ed448SignCtx; return NULL; } void wolfSSL_CTX_SetEd448VerifyCb(WOLFSSL_CTX* ctx, CallbackEd448Verify cb) { if (ctx) ctx->Ed448VerifyCb = cb; } void wolfSSL_SetEd448VerifyCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->Ed448VerifyCtx = ctx; } void* wolfSSL_GetEd448VerifyCtx(WOLFSSL* ssl) { if (ssl) return ssl->Ed448VerifyCtx; return NULL; } #endif /* HAVE_ED448 */ #ifdef HAVE_CURVE448 void wolfSSL_CTX_SetX448KeyGenCb(WOLFSSL_CTX* ctx, CallbackX448KeyGen cb) { if (ctx) ctx->X448KeyGenCb = cb; } void wolfSSL_SetX448KeyGenCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->X448KeyGenCtx = ctx; } void* wolfSSL_GetX448KeyGenCtx(WOLFSSL* ssl) { if (ssl) return ssl->X448KeyGenCtx; return NULL; } void wolfSSL_CTX_SetX448SharedSecretCb(WOLFSSL_CTX* ctx, CallbackX448SharedSecret cb) { if (ctx) ctx->X448SharedSecretCb = cb; } void wolfSSL_SetX448SharedSecretCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->X448SharedSecretCtx = ctx; } void* wolfSSL_GetX448SharedSecretCtx(WOLFSSL* ssl) { if (ssl) return ssl->X448SharedSecretCtx; return NULL; } #endif /* HAVE_CURVE448 */ #ifndef NO_RSA void wolfSSL_CTX_SetRsaSignCb(WOLFSSL_CTX* ctx, CallbackRsaSign cb) { if (ctx) ctx->RsaSignCb = cb; } void wolfSSL_CTX_SetRsaSignCheckCb(WOLFSSL_CTX* ctx, CallbackRsaVerify cb) { if (ctx) ctx->RsaSignCheckCb = cb; } void wolfSSL_SetRsaSignCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->RsaSignCtx = ctx; } void* wolfSSL_GetRsaSignCtx(WOLFSSL* ssl) { if (ssl) return ssl->RsaSignCtx; return NULL; } void wolfSSL_CTX_SetRsaVerifyCb(WOLFSSL_CTX* ctx, CallbackRsaVerify cb) { if (ctx) ctx->RsaVerifyCb = cb; } void wolfSSL_SetRsaVerifyCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->RsaVerifyCtx = ctx; } void* wolfSSL_GetRsaVerifyCtx(WOLFSSL* ssl) { if (ssl) return ssl->RsaVerifyCtx; return NULL; } #ifdef WC_RSA_PSS void wolfSSL_CTX_SetRsaPssSignCb(WOLFSSL_CTX* ctx, CallbackRsaPssSign cb) { if (ctx) ctx->RsaPssSignCb = cb; } void wolfSSL_CTX_SetRsaPssSignCheckCb(WOLFSSL_CTX* ctx, CallbackRsaPssVerify cb) { if (ctx) ctx->RsaPssSignCheckCb = cb; } void wolfSSL_SetRsaPssSignCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->RsaPssSignCtx = ctx; } void* wolfSSL_GetRsaPssSignCtx(WOLFSSL* ssl) { if (ssl) return ssl->RsaPssSignCtx; return NULL; } void wolfSSL_CTX_SetRsaPssVerifyCb(WOLFSSL_CTX* ctx, CallbackRsaPssVerify cb) { if (ctx) ctx->RsaPssVerifyCb = cb; } void wolfSSL_SetRsaPssVerifyCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->RsaPssVerifyCtx = ctx; } void* wolfSSL_GetRsaPssVerifyCtx(WOLFSSL* ssl) { if (ssl) return ssl->RsaPssVerifyCtx; return NULL; } #endif /* WC_RSA_PSS */ void wolfSSL_CTX_SetRsaEncCb(WOLFSSL_CTX* ctx, CallbackRsaEnc cb) { if (ctx) ctx->RsaEncCb = cb; } void wolfSSL_SetRsaEncCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->RsaEncCtx = ctx; } void* wolfSSL_GetRsaEncCtx(WOLFSSL* ssl) { if (ssl) return ssl->RsaEncCtx; return NULL; } void wolfSSL_CTX_SetRsaDecCb(WOLFSSL_CTX* ctx, CallbackRsaDec cb) { if (ctx) ctx->RsaDecCb = cb; } void wolfSSL_SetRsaDecCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->RsaDecCtx = ctx; } void* wolfSSL_GetRsaDecCtx(WOLFSSL* ssl) { if (ssl) return ssl->RsaDecCtx; return NULL; } #endif /* NO_RSA */ #endif /* HAVE_PK_CALLBACKS */ #endif /* NO_CERTS */ #if defined(HAVE_PK_CALLBACKS) && !defined(NO_DH) void wolfSSL_CTX_SetDhAgreeCb(WOLFSSL_CTX* ctx, CallbackDhAgree cb) { if (ctx) ctx->DhAgreeCb = cb; } void wolfSSL_SetDhAgreeCtx(WOLFSSL* ssl, void *ctx) { if (ssl) ssl->DhAgreeCtx = ctx; } void* wolfSSL_GetDhAgreeCtx(WOLFSSL* ssl) { if (ssl) return ssl->DhAgreeCtx; return NULL; } #endif /* HAVE_PK_CALLBACKS && !NO_DH */ #ifdef WOLFSSL_HAVE_WOLFSCEP /* Used by autoconf to see if wolfSCEP is available */ void wolfSSL_wolfSCEP(void) {} #endif #ifdef WOLFSSL_HAVE_CERT_SERVICE /* Used by autoconf to see if cert service is available */ void wolfSSL_cert_service(void) {} #endif #ifdef OPENSSL_EXTRA #ifndef NO_CERTS void wolfSSL_X509_NAME_free(WOLFSSL_X509_NAME *name) { WOLFSSL_ENTER("wolfSSL_X509_NAME_free"); FreeX509Name(name, NULL); XFREE(name, NULL, DYNAMIC_TYPE_X509); } /* Malloc's a new WOLFSSL_X509_NAME structure * * returns NULL on failure, otherwise returns a new structure. */ WOLFSSL_X509_NAME* wolfSSL_X509_NAME_new(void) { WOLFSSL_X509_NAME* name; WOLFSSL_ENTER("wolfSSL_X509_NAME_new"); name = (WOLFSSL_X509_NAME*)XMALLOC(sizeof(WOLFSSL_X509_NAME), NULL, DYNAMIC_TYPE_X509); if (name != NULL) { InitX509Name(name, 1); } return name; } /* Creates a duplicate of a WOLFSSL_X509_NAME structure. Returns a new WOLFSSL_X509_NAME structure or NULL on failure */ WOLFSSL_X509_NAME* wolfSSL_X509_NAME_dup(WOLFSSL_X509_NAME *name) { WOLFSSL_X509_NAME* dup = NULL; WOLFSSL_ENTER("wolfSSL_X509_NAME_dup"); if (name == NULL) { WOLFSSL_MSG("NULL parameter"); return NULL; } if (!(dup = wolfSSL_X509_NAME_new())) { return NULL; } /* copy contents */ XMEMCPY(dup, name, sizeof(WOLFSSL_X509_NAME)); InitX509Name(dup, 1); dup->sz = name->sz; /* handle dynamic portions */ if (name->dynamicName) { if (!(dup->name = (char*)XMALLOC(name->sz, 0, DYNAMIC_TYPE_OPENSSL))) { goto err; } } XMEMCPY(dup->name, name->name, name->sz); #if (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) && \ !defined(NO_ASN) if (!(dup->fullName.fullName = (char*)XMALLOC(name->fullName.fullNameLen, 0, DYNAMIC_TYPE_OPENSSL))) { goto err; } XMEMCPY(dup->fullName.fullName, name->fullName.fullName, name->fullName.fullNameLen); #endif return dup; err: if (dup) { if (dup->dynamicName && dup->name) { XFREE(dup->name, 0, DYNAMIC_TYPE_OPENSSL); dup->name = NULL; } #if (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) && \ !defined(NO_ASN) if (dup->fullName.fullName && dup->fullName.fullName != name->fullName.fullName) { XFREE(dup->fullName.fullName, 0, DYNAMIC_TYPE_OPENSSL); dup->fullName.fullName = NULL; } #endif wolfSSL_X509_NAME_free(dup); } return NULL; } #if defined(WOLFSSL_CERT_GEN) /* helper function for CopyX509NameToCertName() * * returns WOLFSSL_SUCCESS on success */ static int CopyX509NameEntry(char* out, int mx, char* in, int inLen) { if (inLen > mx) { WOLFSSL_MSG("Name too long"); XMEMCPY(out, in, mx); } else { XMEMCPY(out, in, inLen); out[inLen] = '\0'; } /* make sure is null terminated */ out[mx-1] = '\0'; return WOLFSSL_SUCCESS; } /* Helper function to copy cert name from a WOLFSSL_X509_NAME structure to * a CertName structure. * * returns WOLFSSL_SUCCESS on success and a negative error value on failure */ static int CopyX509NameToCertName(WOLFSSL_X509_NAME* n, CertName* cName) { DecodedName* dn = NULL; if (n == NULL || cName == NULL) { return BAD_FUNC_ARG; } dn = &(n->fullName); /* initialize cert name */ cName->country[0] = '\0'; cName->countryEnc = CTC_PRINTABLE; cName->state[0] = '\0'; cName->stateEnc = CTC_UTF8; cName->locality[0] = '\0'; cName->localityEnc = CTC_UTF8; cName->sur[0] = '\0'; cName->surEnc = CTC_UTF8; cName->org[0] = '\0'; cName->orgEnc = CTC_UTF8; cName->unit[0] = '\0'; cName->unitEnc = CTC_UTF8; cName->commonName[0] = '\0'; cName->commonNameEnc = CTC_UTF8; cName->serialDev[0] = '\0'; cName->serialDevEnc = CTC_PRINTABLE; #ifdef WOLFSSL_CERT_EXT cName->busCat[0] = '\0'; cName->busCatEnc = CTC_UTF8; cName->joiC[0] = '\0'; cName->joiCEnc = CTC_PRINTABLE; cName->joiSt[0] = '\0'; cName->joiStEnc = CTC_PRINTABLE; #endif cName->email[0] = '\0'; /* ASN_COUNTRY_NAME */ WOLFSSL_MSG("Copy Country Name"); if (CopyX509NameEntry(cName->country, CTC_NAME_SIZE, dn->fullName + dn->cIdx, dn->cLen) != SSL_SUCCESS) { return BUFFER_E; } /* ASN_ORGUNIT_NAME */ WOLFSSL_MSG("Copy Org Unit Name"); if (CopyX509NameEntry(cName->unit, CTC_NAME_SIZE, dn->fullName + dn->ouIdx, dn->ouLen) != SSL_SUCCESS) { return BUFFER_E; } /* ASN_ORG_NAME */ WOLFSSL_MSG("Copy Org Name"); if (CopyX509NameEntry(cName->org, CTC_NAME_SIZE, dn->fullName + dn->oIdx, dn->oLen) != SSL_SUCCESS) { return BUFFER_E; } /* ASN_STATE_NAME */ WOLFSSL_MSG("Copy State Name"); if (CopyX509NameEntry(cName->state, CTC_NAME_SIZE, dn->fullName + dn->stIdx, dn->stLen) != SSL_SUCCESS) { return BUFFER_E; } /* ASN_LOCALITY_NAME */ WOLFSSL_MSG("Copy Locality Name"); if (CopyX509NameEntry(cName->locality, CTC_NAME_SIZE, dn->fullName + dn->lIdx, dn->lLen) != SSL_SUCCESS) { return BUFFER_E; } /* ASN_SUR_NAME */ WOLFSSL_MSG("Copy Sur Name"); if (CopyX509NameEntry(cName->sur, CTC_NAME_SIZE, dn->fullName + dn->snIdx, dn->snLen) != SSL_SUCCESS) { return BUFFER_E; } /* ASN_COMMON_NAME */ WOLFSSL_MSG("Copy Common Name"); if (CopyX509NameEntry(cName->commonName, CTC_NAME_SIZE, dn->fullName + dn->cnIdx, dn->cnLen) != SSL_SUCCESS) { return BUFFER_E; } /* ASN_SERIAL_NUMBER */ WOLFSSL_MSG("Copy Serial Number of Device"); if (CopyX509NameEntry(cName->serialDev, CTC_NAME_SIZE, dn->fullName + dn->serialIdx, dn->serialLen) != SSL_SUCCESS) { return BUFFER_E; } #ifdef WOLFSSL_CERT_EXT /* ASN_BUS_CAT */ WOLFSSL_MSG("Copy Business Category"); if (CopyX509NameEntry(cName->busCat, CTC_NAME_SIZE, dn->fullName + dn->bcIdx, dn->bcLen) != SSL_SUCCESS) { return BUFFER_E; } /* JoI Country */ WOLFSSL_MSG("Copy Jurisdiction of Incorporation Country"); if (CopyX509NameEntry(cName->joiC, CTC_NAME_SIZE, dn->fullName + dn->jcIdx, dn->jcLen) != SSL_SUCCESS) { return BUFFER_E; } /* JoI State */ WOLFSSL_MSG("Copy Jurisdiction of Incorporation State"); if (CopyX509NameEntry(cName->joiSt, CTC_NAME_SIZE, dn->fullName + dn->jsIdx, dn->jsLen) != SSL_SUCCESS) { return BUFFER_E; } #endif WOLFSSL_MSG("Copy Email"); if (CopyX509NameEntry(cName->email, CTC_NAME_SIZE, dn->fullName + dn->emailIdx, dn->emailLen) != SSL_SUCCESS) { return BUFFER_E; } return WOLFSSL_SUCCESS; } #ifdef WOLFSSL_CERT_REQ static int ReqCertFromX509(Cert* cert, WOLFSSL_X509* req) { int ret; if (wc_InitCert(cert) != 0) return WOLFSSL_FAILURE; ret = CopyX509NameToCertName(&req->subject, &cert->subject); if (ret == WOLFSSL_SUCCESS) { cert->version = req->version; cert->isCA = req->isCa; #ifdef WOLFSSL_CERT_EXT if (req->subjKeyIdSz != 0) { XMEMCPY(cert->skid, req->subjKeyId, req->subjKeyIdSz); cert->skidSz = req->subjKeyIdSz; } if (req->keyUsageSet) cert->keyUsage = req->keyUsage; /* Extended Key Usage not supported. */ #endif } return ret; } #endif /* convert a WOLFSSL_X509 to a Cert structure for writing out */ static int CertFromX509(Cert* cert, WOLFSSL_X509* x509) { int ret; #ifdef WOLFSSL_CERT_EXT int i; #endif WOLFSSL_ENTER("wolfSSL_X509_to_Cert()"); if (x509 == NULL || cert == NULL) { return BAD_FUNC_ARG; } wc_InitCert(cert); cert->version = (int)wolfSSL_X509_get_version(x509); #ifdef WOLFSSL_ALT_NAMES if (x509->notBefore.length > 0) { if ((x509->notBefore.length + 2) < CTC_DATE_SIZE) { cert->beforeDate[0] = x509->notBefore.type; cert->beforeDate[1] = x509->notBefore.length; XMEMCPY(&cert->beforeDate[2], x509->notBefore.data, x509->notBefore.length); cert->beforeDateSz = x509->notBefore.length + 2; } else { WOLFSSL_MSG("Not before date too large"); return WOLFSSL_FAILURE; } } else { cert->beforeDateSz = 0; } if (x509->notAfter.length > 0) { if ((x509->notAfter.length + 2) < CTC_DATE_SIZE) { cert->afterDate[0] = x509->notAfter.type; cert->afterDate[1] = x509->notAfter.length; XMEMCPY(&cert->afterDate[2], x509->notAfter.data, x509->notAfter.length); cert->afterDateSz = x509->notAfter.length + 2; } else { WOLFSSL_MSG("Not after date too large"); return WOLFSSL_FAILURE; } } else { cert->afterDateSz = 0; } cert->altNamesSz = FlattenAltNames(cert->altNames, sizeof(cert->altNames), x509->altNames); #endif /* WOLFSSL_ALT_NAMES */ cert->sigType = wolfSSL_X509_get_signature_type(x509); cert->keyType = x509->pubKeyOID; cert->isCA = wolfSSL_X509_get_isCA(x509); #ifdef WOLFSSL_CERT_EXT if (x509->subjKeyIdSz < CTC_MAX_SKID_SIZE) { XMEMCPY(cert->skid, x509->subjKeyId, x509->subjKeyIdSz); cert->skidSz = (int)x509->subjKeyIdSz; } else { WOLFSSL_MSG("Subject Key ID too large"); return WOLFSSL_FAILURE; } if (x509->authKeyIdSz < CTC_MAX_AKID_SIZE) { XMEMCPY(cert->akid, x509->authKeyId, x509->authKeyIdSz); cert->akidSz = (int)x509->authKeyIdSz; } else { WOLFSSL_MSG("Auth Key ID too large"); return WOLFSSL_FAILURE; } for (i = 0; i < x509->certPoliciesNb; i++) { /* copy the smaller of MAX macros, by default they are currently equal*/ if ((int)CTC_MAX_CERTPOL_SZ <= (int)MAX_CERTPOL_SZ) { XMEMCPY(cert->certPolicies[i], x509->certPolicies[i], CTC_MAX_CERTPOL_SZ); } else { XMEMCPY(cert->certPolicies[i], x509->certPolicies[i], MAX_CERTPOL_SZ); } } cert->certPoliciesNb = (word16)x509->certPoliciesNb; cert->keyUsage = x509->keyUsage; #endif /* WOLFSSL_CERT_EXT */ #ifdef WOLFSSL_CERT_REQ /* copy over challenge password for REQ certs */ XMEMCPY(cert->challengePw, x509->challengePw, CTC_NAME_SIZE); #endif if (x509->serialSz <= CTC_SERIAL_SIZE) { XMEMCPY(cert->serial, x509->serial, x509->serialSz); } else { WOLFSSL_MSG("Serial size error"); return WOLFSSL_FAILURE; } /* copy over Name structures */ if (x509->issuerSet) cert->selfSigned = 0; if ((ret = CopyX509NameToCertName(&(x509->issuer), &(cert->issuer))) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error copying over issuer names"); WOLFSSL_LEAVE("wolfSSL_X509_to_Cert()", ret); return WOLFSSL_FAILURE; } if ((ret = CopyX509NameToCertName(&(x509->subject), &(cert->subject))) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error copying over subject names"); WOLFSSL_LEAVE("wolfSSL_X509_to_Cert()", ret); return WOLFSSL_FAILURE; } cert->heap = x509->heap; return WOLFSSL_SUCCESS; } /* returns the sig type to use on success i.e CTC_SHAwRSA and WOLFSSL_FALURE * on fail case */ static int wolfSSL_sigTypeFromPKEY(WOLFSSL_EVP_MD* md, WOLFSSL_EVP_PKEY* pkey) { int hashType; int sigType = WOLFSSL_FAILURE; /* Convert key type and hash algorithm to a signature algorithm */ if (wolfSSL_EVP_get_hashinfo(md, &hashType, NULL) == WOLFSSL_FAILURE) return WOLFSSL_FAILURE; if (pkey->type == EVP_PKEY_RSA) { switch (hashType) { case WC_HASH_TYPE_SHA: sigType = CTC_SHAwRSA; break; case WC_HASH_TYPE_SHA224: sigType = CTC_SHA224wRSA; break; case WC_HASH_TYPE_SHA256: sigType = CTC_SHA256wRSA; break; case WC_HASH_TYPE_SHA384: sigType = CTC_SHA384wRSA; break; case WC_HASH_TYPE_SHA512: sigType = CTC_SHA512wRSA; break; default: return WOLFSSL_FAILURE; } } else if (pkey->type == EVP_PKEY_EC) { switch (hashType) { case WC_HASH_TYPE_SHA: sigType = CTC_SHAwECDSA; break; case WC_HASH_TYPE_SHA224: sigType = CTC_SHA224wECDSA; break; case WC_HASH_TYPE_SHA256: sigType = CTC_SHA256wECDSA; break; case WC_HASH_TYPE_SHA384: sigType = CTC_SHA384wECDSA; break; case WC_HASH_TYPE_SHA512: sigType = CTC_SHA512wECDSA; break; default: return WOLFSSL_FAILURE; } } else return WOLFSSL_FAILURE; return sigType; } /* generates DER buffer from WOLFSSL_X509 * If req == 1 then creates a request DER buffer * * updates derSz with certificate body size on success * return WOLFSSL_SUCCESS on success */ static int wolfSSL_X509_make_der(WOLFSSL_X509* x509, int req, unsigned char* der, int* derSz) { int ret; Cert cert; void* key = NULL; int type = -1; #ifndef NO_RSA RsaKey rsa; #endif #ifdef HAVE_ECC ecc_key ecc; #endif WC_RNG rng; word32 idx = 0; if (x509 == NULL || der == NULL || derSz == NULL) return BAD_FUNC_ARG; #ifndef WOLFSSL_CERT_REQ if (req) { WOLFSSL_MSG("WOLFSSL_CERT_REQ needed for certificate request"); return WOLFSSL_FAILURE; } #endif #ifdef WOLFSSL_CERT_REQ if (req) { if (ReqCertFromX509(&cert, x509) != WOLFSSL_SUCCESS) return WOLFSSL_FAILURE; } else #endif { /* Create a Cert that has the certificate fields. */ if (CertFromX509(&cert, x509) != WOLFSSL_SUCCESS) return WOLFSSL_FAILURE; } /* Create a public key object from requests public key. */ #ifndef NO_RSA if (x509->pubKeyOID == RSAk) { type = RSA_TYPE; ret = wc_InitRsaKey(&rsa, x509->heap); if (ret != 0) return ret; ret = wc_RsaPublicKeyDecode(x509->pubKey.buffer, &idx, &rsa, x509->pubKey.length); if (ret != 0) { wc_FreeRsaKey(&rsa); return ret; } key = (void*)&rsa; } #endif #ifdef HAVE_ECC if (x509->pubKeyOID == ECDSAk) { type = ECC_TYPE; ret = wc_ecc_init(&ecc); if (ret != 0) return ret; ret = wc_EccPublicKeyDecode(x509->pubKey.buffer, &idx, &ecc, x509->pubKey.length); if (ret != 0) { wc_ecc_free(&ecc); return ret; } key = (void*)&ecc; } #endif if (key == NULL) return WOLFSSL_FAILURE; /* Make the body of the certificate request. */ #ifdef WOLFSSL_CERT_REQ if (req) { ret = wc_MakeCertReq_ex(&cert, der, *derSz, type, key); } else #endif { ret = wc_InitRng(&rng); if (ret != 0) return WOLFSSL_FAILURE; ret = wc_MakeCert_ex(&cert, der, *derSz, type, key, &rng); wc_FreeRng(&rng); } if (ret < 0) { return ret; } /* Dispose of the public key object. */ #ifndef NO_RSA if (x509->pubKeyOID == RSAk) wc_FreeRsaKey(&rsa); #endif #ifdef HAVE_ECC if (x509->pubKeyOID == ECDSAk) wc_ecc_free(&ecc); #endif *derSz = ret; return WOLFSSL_SUCCESS; } /* signs a der buffer for the WOLFSSL_X509 structure using the PKEY and MD * hash passed in * * WARNING: this free's and replaces the existing DER buffer in the * WOLFSSL_X509 with the newly signed buffer. * returns size of signed buffer on success and negative values on fail */ static int wolfSSL_X509_resign_cert(WOLFSSL_X509* x509, int req, unsigned char* der, int derSz, int certBodySz, WOLFSSL_EVP_MD* md, WOLFSSL_EVP_PKEY* pkey) { int ret; void* key = NULL; int type = -1; int sigType; WC_RNG rng; sigType = wolfSSL_sigTypeFromPKEY(md, pkey); if (sigType == WOLFSSL_FAILURE) return WOLFSSL_FATAL_ERROR; /* Get the private key object and type from pkey. */ #ifndef NO_RSA if (pkey->type == EVP_PKEY_RSA) { type = RSA_TYPE; key = pkey->rsa->internal; } #endif #ifdef HAVE_ECC if (pkey->type == EVP_PKEY_EC) { type = ECC_TYPE; key = pkey->ecc->internal; } #endif /* Sign the certificate request body. */ ret = wc_InitRng(&rng); if (ret != 0) return ret; ret = wc_SignCert_ex(certBodySz, sigType, der, derSz, type, key, &rng); wc_FreeRng(&rng); if (ret < 0) return ret; /* Put in the new certificate encoding into the x509 object. */ FreeDer(&x509->derCert); type = CERT_TYPE; #ifdef WOLFSSL_REQ_CERT if (req) { type = CERTREQ_TYPE; } #endif if (AllocDer(&x509->derCert, ret, type, NULL) != 0) return WOLFSSL_FATAL_ERROR; XMEMCPY(x509->derCert->buffer, der, ret); x509->derCert->length = ret; (void)req; return ret; } /* returns the size of signature on success */ int wolfSSL_X509_sign(WOLFSSL_X509* x509, WOLFSSL_EVP_PKEY* pkey, const WOLFSSL_EVP_MD* md) { int ret; byte der[4096]; /* @TODO dynamic set based on expected cert size */ int derSz = sizeof(der); WOLFSSL_ENTER("wolfSSL_X509_sign"); if (x509 == NULL || pkey == NULL || md == NULL) return WOLFSSL_FAILURE; x509->sigOID = wolfSSL_sigTypeFromPKEY((WOLFSSL_EVP_MD*)md, pkey); if ((ret = wolfSSL_X509_make_der(x509, 0, der, &derSz)) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Unable to make DER for X509"); WOLFSSL_LEAVE("wolfSSL_X509_sign", ret); return WOLFSSL_FAILURE; } ret = wolfSSL_X509_resign_cert(x509, 0, der, sizeof(der), derSz, (WOLFSSL_EVP_MD*)md, pkey); if (ret <= 0) { WOLFSSL_LEAVE("wolfSSL_X509_sign", ret); return WOLFSSL_FAILURE; } return ret; } /* Converts the x509 name structure into DER format. * * out pointer to either a pre setup buffer or a pointer to null for * creating a dynamic buffer. In the case that a pre-existing buffer is * used out will be incremented the size of the DER buffer on success. * * returns the size of the buffer on success, or negative value with failure */ int wolfSSL_i2d_X509_NAME(WOLFSSL_X509_NAME* name, unsigned char** out) { CertName cName; unsigned char buf[256]; /* ASN_MAX_NAME */ int sz; WOLFSSL_ENTER("wolfSSL_i2d_X509_NAME"); if (out == NULL || name == NULL) { return BAD_FUNC_ARG; } XMEMSET(&cName, 0, sizeof(CertName)); if (CopyX509NameToCertName(name, &cName) != SSL_SUCCESS) { WOLFSSL_MSG("Error converting x509 name to internal CertName"); return SSL_FATAL_ERROR; } sz = SetName(buf, sizeof(buf), &cName); if (sz < 0) { return sz; } /* using buffer passed in */ if (*out != NULL) { XMEMCPY(*out, buf, sz); *out += sz; } else { *out = (unsigned char*)XMALLOC(sz, NULL, DYNAMIC_TYPE_OPENSSL); if (*out == NULL) { return MEMORY_E; } XMEMCPY(*out, buf, sz); } return sz; } #endif /* WOLFSSL_CERT_GEN */ /* Compares the two X509 names. If the size of x is larger then y then a * positive value is returned if x is smaller a negative value is returned. * In the case that the sizes are equal a the value of strcmp between the * two names is returned. * * x First name for comparison * y Second name to compare with x */ int wolfSSL_X509_NAME_cmp(const WOLFSSL_X509_NAME* x, const WOLFSSL_X509_NAME* y) { const char* _x; const char* _y; WOLFSSL_ENTER("wolfSSL_X509_NAME_cmp"); if (x == NULL || y == NULL) { WOLFSSL_MSG("Bad argument passed in"); return -2; } if (x == y) { return 0; /* match */ } if (x->sz != y->sz) { return x->sz - y->sz; } /* * If the name member is not set or is immediately null terminated then * compare the staticName member */ _x = (x->name && *x->name) ? x->name : x->staticName; _y = (y->name && *y->name) ? y->name : y->staticName; return XSTRNCMP(_x, _y, x->sz); /* y sz is the same */ } WOLFSSL_X509 *wolfSSL_PEM_read_bio_X509(WOLFSSL_BIO *bp, WOLFSSL_X509 **x, pem_password_cb *cb, void *u) { WOLFSSL_X509* x509 = NULL; #if defined(WOLFSSL_PEM_TO_DER) || defined(WOLFSSL_DER_TO_PEM) unsigned char* pem = NULL; int pemSz; long i = 0, l; const char* footer = NULL; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_X509"); if (bp == NULL) { WOLFSSL_LEAVE("wolfSSL_PEM_read_bio_X509", BAD_FUNC_ARG); return NULL; } if ((l = wolfSSL_BIO_get_len(bp)) <= 0) { #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) /* No certificate in buffer */ WOLFSSL_ERROR(ASN_NO_PEM_HEADER); #endif return NULL; } pem = (unsigned char*)XMALLOC(l, 0, DYNAMIC_TYPE_PEM); if (pem == NULL) return NULL; i = 0; if (wc_PemGetHeaderFooter(CERT_TYPE, NULL, &footer) != 0) { XFREE(pem, 0, DYNAMIC_TYPE_PEM); return NULL; } /* TODO: Inefficient * reading in one byte at a time until see "END CERTIFICATE" */ while ((l = wolfSSL_BIO_read(bp, (char *)&pem[i], 1)) == 1) { i++; if (i > 26 && XMEMCMP((char *)&pem[i-26], footer, 25) == 0) { if (pem[i-1] == '\r') { /* found \r , Windows line ending is \r\n so try to read one * more byte for \n, ignoring return value */ (void)wolfSSL_BIO_read(bp, (char *)&pem[i++], 1); } break; } } #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) if (l == 0) WOLFSSL_ERROR(ASN_NO_PEM_HEADER); #endif pemSz = (int)i; x509 = wolfSSL_X509_load_certificate_buffer(pem, pemSz, WOLFSSL_FILETYPE_PEM); if (x != NULL) { *x = x509; } XFREE(pem, NULL, DYNAMIC_TYPE_PEM); #endif /* WOLFSSL_PEM_TO_DER || WOLFSSL_DER_TO_PEM */ (void)bp; (void)x; (void)cb; (void)u; return x509; } WOLFSSL_X509_CRL *wolfSSL_PEM_read_bio_X509_CRL(WOLFSSL_BIO *bp, WOLFSSL_X509_CRL **x, pem_password_cb *cb, void *u) { #if defined(WOLFSSL_PEM_TO_DER) && defined(HAVE_CRL) unsigned char* pem = NULL; int pemSz; int derSz; DerBuffer* der = NULL; WOLFSSL_X509_CRL* crl = NULL; if ((pemSz = wolfSSL_BIO_get_len(bp)) <= 0) { goto err; } pem = (unsigned char*)XMALLOC(pemSz, 0, DYNAMIC_TYPE_PEM); if (pem == NULL) { goto err; } if (wolfSSL_BIO_read(bp, pem, pemSz) != pemSz) { goto err; } if((PemToDer(pem, pemSz, CRL_TYPE, &der, NULL, NULL, NULL)) < 0) { goto err; } derSz = der->length; if((crl = wolfSSL_d2i_X509_CRL(x, der->buffer, derSz)) == NULL) { goto err; } err: if(pem != NULL) { XFREE(pem, 0, DYNAMIC_TYPE_PEM); } if(der != NULL) { FreeDer(&der); } (void)cb; (void)u; return crl; #else (void)bp; (void)x; (void)cb; (void)u; return NULL; #endif } #if !defined(NO_FILESYSTEM) static void* wolfSSL_PEM_read_X509_ex(XFILE fp, void **x, pem_password_cb *cb, void *u, int type) { unsigned char* pem = NULL; int pemSz; long i = 0, l; void *newx509; int derSz; DerBuffer* der = NULL; WOLFSSL_ENTER("wolfSSL_PEM_read_X509"); if (fp == XBADFILE) { WOLFSSL_LEAVE("wolfSSL_PEM_read_X509", BAD_FUNC_ARG); return NULL; } /* Read cert from file */ i = XFTELL(fp); if (i < 0) { WOLFSSL_LEAVE("wolfSSL_PEM_read_X509", BAD_FUNC_ARG); return NULL; } if (XFSEEK(fp, 0, XSEEK_END) != 0) return NULL; l = XFTELL(fp); if (l < 0) return NULL; if (XFSEEK(fp, i, SEEK_SET) != 0) return NULL; pemSz = (int)(l - i); /* check calculated length */ if (pemSz > MAX_WOLFSSL_FILE_SIZE || pemSz < 0) { WOLFSSL_MSG("PEM_read_X509_ex file size error"); return NULL; } /* allocate pem buffer */ pem = (unsigned char*)XMALLOC(pemSz, NULL, DYNAMIC_TYPE_PEM); if (pem == NULL) return NULL; if ((int)XFREAD((char *)pem, 1, pemSz, fp) != pemSz) goto err_exit; switch (type) { case CERT_TYPE: newx509 = (void *)wolfSSL_X509_load_certificate_buffer(pem, pemSz, WOLFSSL_FILETYPE_PEM); break; #ifdef HAVE_CRL case CRL_TYPE: if ((PemToDer(pem, pemSz, CRL_TYPE, &der, NULL, NULL, NULL)) < 0) goto err_exit; derSz = der->length; newx509 = (void*)wolfSSL_d2i_X509_CRL((WOLFSSL_X509_CRL **)x, (const unsigned char *)der->buffer, derSz); if (newx509 == NULL) goto err_exit; FreeDer(&der); break; #endif default: goto err_exit; } if (x != NULL) { *x = newx509; } XFREE(pem, NULL, DYNAMIC_TYPE_PEM); return newx509; err_exit: if (pem != NULL) XFREE(pem, NULL, DYNAMIC_TYPE_PEM); if (der != NULL) FreeDer(&der); /* unused */ (void)cb; (void)u; (void)derSz; return NULL; } WOLFSSL_API WOLFSSL_X509* wolfSSL_PEM_read_X509(XFILE fp, WOLFSSL_X509 **x, pem_password_cb *cb, void *u) { return (WOLFSSL_X509* )wolfSSL_PEM_read_X509_ex(fp, (void **)x, cb, u, CERT_TYPE); } #if defined(HAVE_CRL) WOLFSSL_API WOLFSSL_X509_CRL* wolfSSL_PEM_read_X509_CRL(XFILE fp, WOLFSSL_X509_CRL **crl, pem_password_cb *cb, void *u) { return (WOLFSSL_X509_CRL* )wolfSSL_PEM_read_X509_ex(fp, (void **)crl, cb, u, CRL_TYPE); } #endif int wolfSSL_PEM_write_X509(XFILE fp, WOLFSSL_X509* x) { int ret; WOLFSSL_BIO* bio; if (x == NULL) return 0; bio = wolfSSL_BIO_new(wolfSSL_BIO_s_file()); if (bio == NULL) return 0; if (wolfSSL_BIO_set_fp(bio, fp, BIO_NOCLOSE) != WOLFSSL_SUCCESS) { wolfSSL_BIO_free(bio); bio = NULL; } ret = wolfSSL_PEM_write_bio_X509(bio, x); if (bio != NULL) wolfSSL_BIO_free(bio); return ret; } #endif /* !NO_FILESYSTEM */ #define PEM_BEGIN "-----BEGIN " #define PEM_BEGIN_SZ 11 #define PEM_END "-----END " #define PEM_END_SZ 9 #define PEM_HDR_FIN "-----" #define PEM_HDR_FIN_SZ 5 #define PEM_HDR_FIN_EOL_NEWLINE "-----\n" #define PEM_HDR_FIN_EOL_NULL_TERM "-----\0" #define PEM_HDR_FIN_EOL_SZ 6 int wolfSSL_PEM_read_bio(WOLFSSL_BIO* bio, char **name, char **header, unsigned char **data, long *len) { int ret = WOLFSSL_SUCCESS; char pem[256]; int pemLen; char* p; char* nameStr = NULL; int nameLen = 0; char* headerStr = NULL; int headerLen; int headerFound = 0; unsigned char* der = NULL; word32 derLen = 0; if (bio == NULL || name == NULL || header == NULL || data == NULL || len == NULL) { return WOLFSSL_FAILURE; } /* Find header line. */ pem[sizeof(pem) - 1] = '\0'; while ((pemLen = wolfSSL_BIO_gets(bio, pem, sizeof(pem) - 1)) > 0) { if (XSTRNCMP(pem, PEM_BEGIN, PEM_BEGIN_SZ) == 0) break; } if (pemLen <= 0) ret = WOLFSSL_FAILURE; /* Have a header line. */ if (ret == WOLFSSL_SUCCESS) { while (pem[pemLen - 1] == '\r' || pem[pemLen - 1] == '\n') pemLen--; pem[pemLen] = '\0'; if (XSTRNCMP(pem + pemLen - PEM_HDR_FIN_SZ, PEM_HDR_FIN, PEM_HDR_FIN_SZ) != 0) { ret = WOLFSSL_FAILURE; } } /* Get out name. */ if (ret == WOLFSSL_SUCCESS) { nameLen = pemLen - PEM_BEGIN_SZ - PEM_HDR_FIN_SZ; nameStr = (char*)XMALLOC(nameLen + 1, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (nameStr == NULL) ret = WOLFSSL_FAILURE; } if (ret == WOLFSSL_SUCCESS) { XSTRNCPY(nameStr, pem + PEM_BEGIN_SZ, nameLen); nameStr[nameLen] = '\0'; /* Get header of PEM - encryption header. */ headerLen = 0; while ((pemLen = wolfSSL_BIO_gets(bio, pem, sizeof(pem) - 1)) > 0) { while (pemLen > 0 && (pem[pemLen - 1] == '\r' || pem[pemLen - 1] == '\n')) { pemLen--; } pem[pemLen++] = '\n'; pem[pemLen] = '\0'; /* Header separator is a blank line. */ if (pem[0] == '\n') { headerFound = 1; break; } /* Didn't find a blank line - no header. */ if (XSTRNCMP(pem, PEM_END, PEM_END_SZ) == 0) { der = (unsigned char*)headerStr; derLen = headerLen; /* Empty header - empty string. */ headerStr = (char*)XMALLOC(1, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (headerStr == NULL) ret = WOLFSSL_FAILURE; else headerStr[0] = '\0'; break; } p = (char*)XREALLOC(headerStr, headerLen + pemLen + 1, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (p == NULL) { ret = WOLFSSL_FAILURE; break; } headerStr = p; XMEMCPY(headerStr + headerLen, pem, pemLen + 1); headerLen += pemLen; } if (pemLen <= 0) ret = WOLFSSL_FAILURE; } /* Get body of PEM - if there was a header */ if (ret == WOLFSSL_SUCCESS && headerFound) { derLen = 0; while ((pemLen = wolfSSL_BIO_gets(bio, pem, sizeof(pem) - 1)) > 0) { while (pemLen > 0 && (pem[pemLen - 1] == '\r' || pem[pemLen - 1] == '\n')) { pemLen--; } pem[pemLen++] = '\n'; pem[pemLen] = '\0'; if (XSTRNCMP(pem, PEM_END, PEM_END_SZ) == 0) break; p = (char*)XREALLOC(der, derLen + pemLen + 1, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (p == NULL) { ret = WOLFSSL_FAILURE; break; } der = (unsigned char*)p; XMEMCPY(der + derLen, pem, pemLen + 1); derLen += pemLen; } if (pemLen <= 0) ret = WOLFSSL_FAILURE; } /* Check trailer. */ if (ret == WOLFSSL_SUCCESS) { if (XSTRNCMP(pem + PEM_END_SZ, nameStr, nameLen) != 0) ret = WOLFSSL_FAILURE; } if (ret == WOLFSSL_SUCCESS) { if (XSTRNCMP(pem + PEM_END_SZ + nameLen, PEM_HDR_FIN_EOL_NEWLINE, PEM_HDR_FIN_EOL_SZ) != 0 && XSTRNCMP(pem + PEM_END_SZ + nameLen, PEM_HDR_FIN_EOL_NULL_TERM, PEM_HDR_FIN_EOL_SZ) != 0) { ret = WOLFSSL_FAILURE; } } /* Base64 decode body. */ if (ret == WOLFSSL_SUCCESS) { if (Base64_Decode(der, derLen, der, &derLen) != 0) ret = WOLFSSL_FAILURE; } if (ret == WOLFSSL_SUCCESS) { *name = nameStr; *header = headerStr; *data = der; *len = derLen; nameStr = NULL; headerStr = NULL; der = NULL; } if (nameStr != NULL) XFREE(nameStr, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (headerStr != NULL) XFREE(headerStr, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (der != NULL) XFREE(der, NULL, DYNAMIC_TYPE_TMP_BUFFER); return ret; } int wolfSSL_PEM_write_bio(WOLFSSL_BIO* bio, const char *name, const char *header, const unsigned char *data, long len) { int err = 0; int outSz = 0; int nameLen; int headerLen; byte* pem = NULL; word32 pemLen; word32 derLen = (word32)len; if (bio == NULL || name == NULL || header == NULL || data == NULL) return 0; nameLen = (int)XSTRLEN(name); headerLen = (int)XSTRLEN(header); pemLen = (derLen + 2) / 3 * 4; pemLen += (pemLen + 63) / 64; pem = (byte*)XMALLOC(pemLen, NULL, DYNAMIC_TYPE_TMP_BUFFER); err = pem == NULL; if (!err) err = Base64_Encode(data, derLen, pem, &pemLen) != 0; if (!err) { err = wolfSSL_BIO_write(bio, PEM_BEGIN, PEM_BEGIN_SZ) != (int)PEM_BEGIN_SZ; } if (!err) err = wolfSSL_BIO_write(bio, name, nameLen) != nameLen; if (!err) { err = wolfSSL_BIO_write(bio, PEM_HDR_FIN_EOL_NEWLINE, PEM_HDR_FIN_EOL_SZ) != (int)PEM_HDR_FIN_EOL_SZ; } if (!err && headerLen > 0) { err = wolfSSL_BIO_write(bio, header, headerLen) != headerLen; /* Blank line after a header and before body. */ if (!err) err = wolfSSL_BIO_write(bio, "\n", 1) != 1; headerLen++; } if (!err) err = wolfSSL_BIO_write(bio, pem, pemLen) != (int)pemLen; if (!err) err = wolfSSL_BIO_write(bio, PEM_END, PEM_END_SZ) != (int)PEM_END_SZ; if (!err) err = wolfSSL_BIO_write(bio, name, nameLen) != nameLen; if (!err) { err = wolfSSL_BIO_write(bio, PEM_HDR_FIN_EOL_NEWLINE, PEM_HDR_FIN_EOL_SZ) != (int)PEM_HDR_FIN_EOL_SZ; } if (!err) { outSz = PEM_BEGIN_SZ + nameLen + PEM_HDR_FIN_EOL_SZ + headerLen + pemLen + PEM_END_SZ + nameLen + PEM_HDR_FIN_EOL_SZ; } if (pem != NULL) XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER); return outSz; } #if !defined(NO_FILESYSTEM) int wolfSSL_PEM_read(XFILE fp, char **name, char **header, unsigned char **data, long *len) { int ret; WOLFSSL_BIO* bio; if (name == NULL || header == NULL || data == NULL || len == NULL) return WOLFSSL_FAILURE; bio = wolfSSL_BIO_new(wolfSSL_BIO_s_file()); if (bio == NULL) return 0; if (wolfSSL_BIO_set_fp(bio, fp, BIO_NOCLOSE) != WOLFSSL_SUCCESS) { wolfSSL_BIO_free(bio); bio = NULL; } ret = wolfSSL_PEM_read_bio(bio, name, header, data, len); if (bio != NULL) wolfSSL_BIO_free(bio); return ret; } int wolfSSL_PEM_write(XFILE fp, const char *name, const char *header, const unsigned char *data, long len) { int ret; WOLFSSL_BIO* bio; if (name == NULL || header == NULL || data == NULL) return 0; bio = wolfSSL_BIO_new(wolfSSL_BIO_s_file()); if (bio == NULL) return 0; if (wolfSSL_BIO_set_fp(bio, fp, BIO_NOCLOSE) != WOLFSSL_SUCCESS) { wolfSSL_BIO_free(bio); bio = NULL; } ret = wolfSSL_PEM_write_bio(bio, name, header, data, len); if (bio != NULL) wolfSSL_BIO_free(bio); return ret; } #endif int wolfSSL_PEM_get_EVP_CIPHER_INFO(char* header, EncryptedInfo* cipher) { if (header == NULL || cipher == NULL) return WOLFSSL_FAILURE; XMEMSET(cipher, 0, sizeof(*cipher)); if (wc_EncryptedInfoParse(cipher, &header, XSTRLEN(header)) != 0) return WOLFSSL_FAILURE; return WOLFSSL_SUCCESS; } int wolfSSL_PEM_do_header(EncryptedInfo* cipher, unsigned char* data, long* len, pem_password_cb* callback, void* ctx) { int ret = WOLFSSL_SUCCESS; char password[NAME_SZ]; int passwordSz; if (cipher == NULL || data == NULL || len == NULL || callback == NULL) return WOLFSSL_FAILURE; passwordSz = callback(password, sizeof(password), PEM_PASS_READ, ctx); if (passwordSz < 0) ret = WOLFSSL_FAILURE; if (ret == WOLFSSL_SUCCESS) { if (wc_BufferKeyDecrypt(cipher, data, (word32)*len, (byte*)password, passwordSz, WC_MD5) != 0) { ret = WOLFSSL_FAILURE; } } if (passwordSz > 0) XMEMSET(password, 0, passwordSz); return ret; } /* * bp : bio to read X509 from * x : x509 to write to * cb : password call back for reading PEM * u : password * _AUX is for working with a trusted X509 certificate */ WOLFSSL_X509 *wolfSSL_PEM_read_bio_X509_AUX(WOLFSSL_BIO *bp, WOLFSSL_X509 **x, pem_password_cb *cb, void *u) { WOLFSSL_ENTER("wolfSSL_PEM_read_bio_X509"); /* AUX info is; trusted/rejected uses, friendly name, private key id, * and potentially a stack of "other" info. wolfSSL does not store * friendly name or private key id yet in WOLFSSL_X509 for human * readability and does not support extra trusted/rejected uses for * root CA. */ return wolfSSL_PEM_read_bio_X509(bp, x, cb, u); } #ifdef OPENSSL_ALL /* create and return a new WOLFSSL_X509_PKEY structure or NULL on failure */ static WOLFSSL_X509_PKEY* wolfSSL_X509_PKEY_new(void* heap) { WOLFSSL_X509_PKEY* ret; ret = (WOLFSSL_X509_PKEY*)XMALLOC(sizeof(WOLFSSL_X509_PKEY), heap, DYNAMIC_TYPE_KEY); if (ret != NULL) { XMEMSET(ret, 0, sizeof(WOLFSSL_X509_PKEY)); ret->heap = heap; } return ret; } /* sets the values of X509_PKEY based on certificate passed in * return WOLFSSL_SUCCESS on success */ static int wolfSSL_X509_PKEY_set(WOLFSSL_X509_PKEY* xPkey, WOLFSSL_X509* x509) { if (xPkey == NULL || x509 == NULL) { return BAD_FUNC_ARG; } wolfSSL_EVP_PKEY_free(xPkey->dec_pkey); xPkey->dec_pkey = wolfSSL_X509_get_pubkey(x509); if (xPkey->dec_pkey == NULL) { return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* free up all memory used by "xPkey" passed in */ static void wolfSSL_X509_PKEY_free(WOLFSSL_X509_PKEY* xPkey) { if (xPkey != NULL) { wolfSSL_EVP_PKEY_free(xPkey->dec_pkey); } XFREE(xPkey, xPkey->heap, DYNAMIC_TYPE_KEY); } /* Takes control of x509 on success * helper function to break out code needed to set WOLFSSL_X509_INFO up * free's "info" passed in if is not defaults * * returns WOLFSSL_SUCCESS on success */ static int wolfSSL_X509_INFO_set(WOLFSSL_X509_INFO* info, WOLFSSL_X509* x509) { if (info == NULL || x509 == NULL) { return BAD_FUNC_ARG; } /* check is fresh "info" passed in, if not free it */ if (info->x509 != NULL || info->x_pkey != NULL) { WOLFSSL_X509_INFO* tmp; tmp = wolfSSL_X509_INFO_new(); if (tmp == NULL) { WOLFSSL_MSG("Unable to create new structure"); return MEMORY_E; } wolfSSL_X509_INFO_free(info); info = tmp; } info->x509 = x509; //@TODO info->num //@TODO info->enc_cipher //@TODO info->enc_len //@TODO info->enc_data //@TODO info->crl info->x_pkey = wolfSSL_X509_PKEY_new(x509->heap); return wolfSSL_X509_PKEY_set(info->x_pkey, x509); } /* * bio WOLFSSL_BIO to read certificates from * sk possible stack to push more X509_INFO structs to. Can be NULL * cb callback password for encrypted PEM certificates * u user input such as password * * returns stack on success and NULL or default stack passed in on fail */ WOLF_STACK_OF(WOLFSSL_X509_INFO)* wolfSSL_PEM_X509_INFO_read_bio( WOLFSSL_BIO* bio, WOLF_STACK_OF(WOLFSSL_X509_INFO)* sk, pem_password_cb* cb, void* u) { WOLF_STACK_OF(WOLFSSL_X509_INFO)* localSk; WOLFSSL_X509* x509 = NULL; int ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_PEM_X509_INFO_read_bio"); /* attempt to used passed in stack or create a new one */ if (sk != NULL) { localSk = sk; } else { localSk = wolfSSL_sk_X509_INFO_new_null(); } if (localSk == NULL) { WOLFSSL_LEAVE("wolfSSL_PEM_X509_INFO_read_bio", MEMORY_E); return NULL; } /* parse through BIO and push new info's found onto stack */ do { x509 = wolfSSL_PEM_read_bio_X509(bio, NULL, cb, u); if (x509 != NULL) { WOLFSSL_X509_INFO* current; current = wolfSSL_X509_INFO_new(); if (current == NULL) { WOLFSSL_LEAVE("wolfSSL_PEM_X509_INFO_read_bio", MEMORY_E); return NULL; } ret = wolfSSL_X509_INFO_set(current, x509); if (ret != WOLFSSL_SUCCESS) { wolfSSL_X509_free(x509); } else { wolfSSL_sk_X509_INFO_push(localSk, current); } } } while (x509 != NULL && ret == WOLFSSL_SUCCESS); WOLFSSL_LEAVE("wolfSSL_PEM_X509_INFO_read_bio", ret); return localSk; } #endif /* OPENSSL_ALL */ void wolfSSL_X509_NAME_ENTRY_free(WOLFSSL_X509_NAME_ENTRY* ne) { WOLFSSL_ENTER("wolfSSL_X509_NAME_ENTRY_free"); if (ne != NULL) { if (ne->value != NULL && ne->value != &(ne->data)) { wolfSSL_ASN1_STRING_free(ne->value); } XFREE(ne, NULL, DYNAMIC_TYPE_NAME_ENTRY); } } WOLFSSL_X509_NAME_ENTRY* wolfSSL_X509_NAME_ENTRY_new(void) { WOLFSSL_X509_NAME_ENTRY* ne; ne = (WOLFSSL_X509_NAME_ENTRY*)XMALLOC(sizeof(WOLFSSL_X509_NAME_ENTRY), NULL, DYNAMIC_TYPE_NAME_ENTRY); if (ne != NULL) { XMEMSET(ne, 0, sizeof(WOLFSSL_X509_NAME_ENTRY)); ne->value = &(ne->data); } return ne; } /* Create a new WOLFSSL_X509_NAME_ENTRY structure based on the text passed * in. Returns NULL on failure */ WOLFSSL_X509_NAME_ENTRY* wolfSSL_X509_NAME_ENTRY_create_by_txt( WOLFSSL_X509_NAME_ENTRY **neIn, const char *txt, int type, const unsigned char *data, int dataSz) { int nid = -1; WOLFSSL_X509_NAME_ENTRY* ne = NULL; WOLFSSL_ENTER("wolfSSL_X509_NAME_ENTRY_create_by_txt()"); if (txt == NULL) { return NULL; } if (neIn != NULL) { ne = *neIn; } nid = wolfSSL_OBJ_txt2nid(txt); if (nid == NID_undef) { WOLFSSL_MSG("Unable to find text"); ne = NULL; } else { if (ne == NULL) { ne = wolfSSL_X509_NAME_ENTRY_new(); if (ne == NULL) { return NULL; } } ne->nid = nid; ne->value = wolfSSL_ASN1_STRING_type_new(type); if (ne->value != NULL) { wolfSSL_ASN1_STRING_set(ne->value, (const void*)data, dataSz); ne->set = 1; } } return ne; } WOLFSSL_X509_NAME_ENTRY* wolfSSL_X509_NAME_ENTRY_create_by_NID( WOLFSSL_X509_NAME_ENTRY** out, int nid, int type, const unsigned char* data, int dataSz) { WOLFSSL_X509_NAME_ENTRY* ne; WOLFSSL_ENTER("wolfSSL_X509_NAME_ENTRY_create_by_NID()"); ne = wolfSSL_X509_NAME_ENTRY_new(); if (ne == NULL) { return NULL; } ne->nid = nid; ne->value = wolfSSL_ASN1_STRING_type_new(type); wolfSSL_ASN1_STRING_set(ne->value, (const void*)data, dataSz); ne->set = 1; if (out != NULL) { *out = ne; } return ne; } static int RebuildFullNameAdd(DecodedName* dName, char* data) { int totalLen = 0; int i; char* fullName; int idx; if (dName->cnLen != 0) totalLen += dName->cnLen + 4; if (dName->snLen != 0) totalLen += dName->snLen + 4; if (dName->cLen != 0) totalLen += dName->cLen + 3; if (dName->lLen != 0) totalLen += dName->lLen + 3; if (dName->stLen != 0) totalLen += dName->stLen + 4; if (dName->oLen != 0) totalLen += dName->oLen + 3; if (dName->ouLen != 0) totalLen += dName->ouLen + 4; if (dName->emailLen != 0) totalLen += dName->emailLen + 14; if (dName->uidLen != 0) totalLen += dName->uidLen + 5; if (dName->serialLen != 0) totalLen += dName->serialLen + 14; if (dName->dcNum != 0) { for (i = 0; i < dName->dcNum; i++) totalLen += dName->dcLen[i] + 4; } fullName = (char*)XMALLOC(totalLen + 1, NULL, DYNAMIC_TYPE_X509); if (fullName == NULL) return MEMORY_E; idx = 0; dName->entryCount = 0; if (dName->cnLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, WOLFSSL_COMMON_NAME, 4); idx += 4; if (dName->cnIdx == -1) XMEMCPY(fullName + idx, data, dName->cnLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->cnIdx, dName->cnLen); } dName->cnIdx = idx; idx += dName->cnLen; } if (dName->snLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, WOLFSSL_SUR_NAME, 4); idx += 4; if (dName->snIdx == -1) XMEMCPY(fullName + idx, data, dName->snLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->snIdx, dName->snLen); } dName->snIdx = idx; idx += dName->snLen; } if (dName->cLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, WOLFSSL_COUNTRY_NAME, 3); idx += 3; if (dName->cIdx == -1) XMEMCPY(fullName + idx, data, dName->cLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->cIdx, dName->cLen); } dName->cIdx = idx; idx += dName->cLen; } if (dName->lLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, WOLFSSL_LOCALITY_NAME, 3); idx += 3; if (dName->lIdx == -1) XMEMCPY(fullName + idx, data, dName->lLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->lIdx, dName->lLen); } dName->lIdx = idx; idx += dName->lLen; } if (dName->stLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, WOLFSSL_STATE_NAME, 4); idx += 4; if (dName->stIdx == -1) XMEMCPY(fullName + idx, data, dName->stLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->stIdx, dName->stLen); } dName->stIdx = idx; idx += dName->stLen; } if (dName->oLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, WOLFSSL_ORG_NAME, 3); idx += 3; if (dName->oIdx == -1) XMEMCPY(fullName + idx, data, dName->oLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->oIdx, dName->oLen); } dName->oIdx = idx; idx += dName->oLen; } if (dName->ouLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, WOLFSSL_ORGUNIT_NAME, 4); idx += 4; if (dName->ouIdx == -1) XMEMCPY(fullName + idx, data, dName->ouLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->ouIdx, dName->ouLen); } dName->ouIdx = idx; idx += dName->ouLen; } if (dName->emailLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, "/emailAddress=", 14); idx += 14; if (dName->emailIdx == -1) XMEMCPY(fullName + idx, data, dName->emailLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->emailIdx, dName->emailLen); } dName->emailIdx = idx; idx += dName->emailLen; } if (dName->dcNum != 0) { for (i = 0; i < dName->dcNum; i++) { dName->entryCount++; XMEMCPY(fullName + idx, WOLFSSL_DOMAIN_COMPONENT, 4); idx += 4; XMEMCPY(fullName + idx, dName->fullName + dName->dcIdx[i], dName->dcLen[i]); dName->dcIdx[i] = idx; idx += dName->dcLen[i]; } } if (dName->uidLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, "/UID=", 5); idx += 5; if (dName->uidIdx == -1) XMEMCPY(fullName + idx, data, dName->uidLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->uidIdx, dName->uidLen); } dName->uidIdx = idx; idx += dName->uidLen; } if (dName->serialLen != 0) { dName->entryCount++; XMEMCPY(fullName + idx, WOLFSSL_SERIAL_NUMBER, 14); idx += 14; if (dName->serialIdx == -1) XMEMCPY(fullName + idx, data, dName->serialLen); else { XMEMCPY(fullName + idx, dName->fullName + dName->serialIdx, dName->serialLen); } dName->serialIdx = idx; idx += dName->serialLen; } if (dName->fullName != NULL) XFREE(dName->fullName, NULL, DYNAMIC_TYPE_X509); dName->fullName = fullName; dName->fullNameLen = idx + 1; return 0; } /* Copies entry into name. With it being copied freeing entry becomes the * callers responsibility. * returns 1 for success and 0 for error */ int wolfSSL_X509_NAME_add_entry(WOLFSSL_X509_NAME* name, WOLFSSL_X509_NAME_ENTRY* entry, int idx, int set) { int i; int fullName = 1; WOLFSSL_ENTER("wolfSSL_X509_NAME_add_entry()"); switch (entry->nid) { case ASN_COMMON_NAME: name->fullName.cnIdx = -1; name->fullName.cnLen = entry->value->length; name->fullName.cnNid = entry->nid; break; case ASN_SUR_NAME: name->fullName.snIdx = -1; name->fullName.snLen = entry->value->length; name->fullName.snNid = entry->nid; break; case ASN_SERIAL_NUMBER: name->fullName.serialIdx = -1; name->fullName.serialLen = entry->value->length; name->fullName.serialNid = entry->nid; break; case ASN_COUNTRY_NAME: name->fullName.cIdx = -1; name->fullName.cLen = entry->value->length; name->fullName.cNid = entry->nid; break; case ASN_LOCALITY_NAME: name->fullName.lIdx = -1; name->fullName.lLen = entry->value->length; name->fullName.lNid = entry->nid; break; case ASN_STATE_NAME: name->fullName.stIdx = -1; name->fullName.stLen = entry->value->length; name->fullName.stNid = entry->nid; break; case ASN_ORG_NAME: name->fullName.oIdx = -1; name->fullName.oLen = entry->value->length; name->fullName.oNid = entry->nid; break; case ASN_ORGUNIT_NAME: name->fullName.ouIdx = -1; name->fullName.ouLen = entry->value->length; name->fullName.ouNid = entry->nid; break; case NID_emailAddress: name->fullName.emailIdx = -1; name->fullName.emailLen = entry->value->length; name->fullName.emailNid = entry->nid; break; case ASN_USER_ID: name->fullName.uidIdx = -1; name->fullName.uidLen = entry->value->length; name->fullName.uidNid = entry->nid; break; case ASN_DOMAIN_COMPONENT: name->fullName.dcIdx[0] = -1; name->fullName.dcLen[0] = entry->value->length; break; default: fullName = 0; break; } if (fullName) { int nid = entry->nid; if (nid == NID_emailAddress) { nid = (int)ASN_EMAIL_NAME; } if (idx >= DN_NAMES_MAX + DOMAIN_COMPONENT_MAX) { return WOLFSSL_FAILURE; } if (idx >= 0) { name->fullName.loc[idx] = nid; if (idx == name->fullName.locSz) { name->fullName.locSz += 1; } } /* place at end */ if (idx < 0 && name->fullName.locSz + 1 < DN_NAMES_MAX + DOMAIN_COMPONENT_MAX) { name->fullName.loc[name->fullName.locSz] = nid; name->fullName.locSz += 1; } if (RebuildFullNameAdd(&name->fullName, entry->value->data) != 0) return WOLFSSL_FAILURE; } else { for (i = 0; i < MAX_NAME_ENTRIES; i++) { if (name->extra[i].set != 1) { /* not set so overwritten */ WOLFSSL_X509_NAME_ENTRY* current = &(name->extra[i]); WOLFSSL_ASN1_STRING* str; WOLFSSL_MSG("Found place for name entry"); XMEMCPY(current, entry, sizeof(WOLFSSL_X509_NAME_ENTRY)); str = entry->value; XMEMCPY(&(current->data), str, sizeof(WOLFSSL_ASN1_STRING)); current->value = &(current->data); current->data.data = (char*)XMALLOC(str->length, name->x509->heap, DYNAMIC_TYPE_OPENSSL); if (current->data.data == NULL) { return SSL_FAILURE; } XMEMCPY(current->data.data, str->data, str->length); /* make sure is null terminated */ current->data.data[str->length - 1] = '\0'; current->set = 1; /* make sure now listed as set */ break; } } if (i == MAX_NAME_ENTRIES) { WOLFSSL_MSG("No spot found for name entry"); return SSL_FAILURE; } } (void)idx; (void)set; return SSL_SUCCESS; } int wolfSSL_X509_NAME_add_entry_by_txt(WOLFSSL_X509_NAME *name, const char *field, int type, const unsigned char *bytes, int len, int loc, int set) { int ret = WOLFSSL_FAILURE; int nid; WOLFSSL_X509_NAME_ENTRY* entry; (void)type; WOLFSSL_ENTER("wolfSSL_X509_NAME_add_entry_by_txt"); if (name == NULL || field == NULL) return WOLFSSL_FAILURE; if ((nid = wolfSSL_OBJ_txt2nid(field)) == NID_undef) return WOLFSSL_FAILURE; entry = wolfSSL_X509_NAME_ENTRY_create_by_NID(NULL, nid, type, (unsigned char*)bytes, len); if (entry == NULL) return WOLFSSL_FAILURE; ret = wolfSSL_X509_NAME_add_entry(name, entry, loc, set); wolfSSL_X509_NAME_ENTRY_free(entry); return ret; } int wolfSSL_X509_NAME_add_entry_by_NID(WOLFSSL_X509_NAME *name, int nid, int type, const unsigned char *bytes, int len, int loc, int set) { int ret; WOLFSSL_X509_NAME_ENTRY* entry; entry = wolfSSL_X509_NAME_ENTRY_create_by_NID(NULL, nid, type, bytes, len); if (entry == NULL) return WOLFSSL_FAILURE; ret = wolfSSL_X509_NAME_add_entry(name, entry, loc, set); wolfSSL_X509_NAME_ENTRY_free(entry); return ret; } #endif /* !NO_CERTS */ /* NID variables are dependent on compatibility header files currently * * returns a pointer to a new WOLFSSL_ASN1_OBJECT struct on success and NULL * on fail */ WOLFSSL_ASN1_OBJECT* wolfSSL_OBJ_nid2obj(int id) { return wolfSSL_OBJ_nid2obj_ex(id, NULL); } WOLFSSL_LOCAL WOLFSSL_ASN1_OBJECT* wolfSSL_OBJ_nid2obj_ex(int id, WOLFSSL_ASN1_OBJECT* arg_obj) { word32 oidSz = 0; const byte* oid; word32 type = 0; WOLFSSL_ASN1_OBJECT* obj = arg_obj; byte objBuf[MAX_OID_SZ + MAX_LENGTH_SZ + 1]; /* +1 for object tag */ word32 objSz = 0; const char* sName = NULL; int i; WOLFSSL_ENTER("wolfSSL_OBJ_nid2obj()"); for (i = 0; i < (int)WOLFSSL_OBJECT_INFO_SZ; i++) { if (wolfssl_object_info[i].nid == id) { id = wolfssl_object_info[i].id; sName = wolfssl_object_info[i].sName; type = wolfssl_object_info[i].type; break; } } if (i == (int)WOLFSSL_OBJECT_INFO_SZ) { WOLFSSL_MSG("NID not in table"); #ifdef WOLFSSL_QT sName = NULL; type = id; #else return NULL; #endif } #ifdef HAVE_ECC if (type == 0 && wc_ecc_get_oid(id, &oid, &oidSz) > 0) { type = oidCurveType; } #endif /* HAVE_ECC */ if (sName != NULL) { if (XSTRLEN(sName) > WOLFSSL_MAX_SNAME - 1) { WOLFSSL_MSG("Attempted short name is too large"); return NULL; } } oid = OidFromId(id, type, &oidSz); /* set object ID to buffer */ if (obj == NULL){ obj = wolfSSL_ASN1_OBJECT_new(); if (obj == NULL) { WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct"); return NULL; } obj->dynamic |= WOLFSSL_ASN1_DYNAMIC; } else { obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC; } obj->type = id; obj->grp = type; obj->sName[0] = '\0'; if (sName != NULL) { XMEMCPY(obj->sName, (char*)sName, XSTRLEN((char*)sName)); } objBuf[0] = ASN_OBJECT_ID; objSz++; objSz += SetLength(oidSz, objBuf + 1); XMEMCPY(objBuf + objSz, oid, oidSz); objSz += oidSz; obj->objSz = objSz; if(((obj->dynamic & WOLFSSL_ASN1_DYNAMIC_DATA) != 0) || (obj->obj == NULL)) { obj->obj = (byte*)XREALLOC((byte*)obj->obj, obj->objSz, NULL, DYNAMIC_TYPE_ASN1); if (obj->obj == NULL) { wolfSSL_ASN1_OBJECT_free(obj); return NULL; } obj->dynamic |= WOLFSSL_ASN1_DYNAMIC_DATA ; } else { obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA ; } XMEMCPY((byte*)obj->obj, objBuf, obj->objSz); (void)type; return obj; } static const char* oid_translate_num_to_str(const char* oid) { const struct oid_dict { const char* num; const char* desc; } oid_dict[] = { { "2.5.29.37.0", "Any Extended Key Usage" }, { "1.3.6.1.5.5.7.3.1", "TLS Web Server Authentication" }, { "1.3.6.1.5.5.7.3.2", "TLS Web Client Authentication" }, { "1.3.6.1.5.5.7.3.3", "Code Signing" }, { "1.3.6.1.5.5.7.3.4", "E-mail Protection" }, { "1.3.6.1.5.5.7.3.8", "Time Stamping" }, { "1.3.6.1.5.5.7.3.9", "OCSP Signing" }, { NULL, NULL } }; const struct oid_dict* idx; for (idx = oid_dict; idx->num != NULL; idx++) { if (!XSTRNCMP(oid, idx->num, XSTRLEN(idx->num))) { return idx->desc; } } return NULL; } /* if no_name is one than use numerical form otherwise can be short name. * * returns the buffer size on success */ int wolfSSL_OBJ_obj2txt(char *buf, int bufLen, WOLFSSL_ASN1_OBJECT *a, int no_name) { int bufSz; const char* desc; WOLFSSL_ENTER("wolfSSL_OBJ_obj2txt()"); if (buf == NULL || bufLen <= 1 || a == NULL) { WOLFSSL_MSG("Bad input argument"); return WOLFSSL_FAILURE; } if (no_name == 1) { int length; word32 idx = 0; byte tag; if (GetASNTag(a->obj, &idx, &tag, a->objSz) != 0) { return WOLFSSL_FAILURE; } if (tag != ASN_OBJECT_ID) { WOLFSSL_MSG("Bad ASN1 Object"); return WOLFSSL_FAILURE; } if (GetLength((const byte*)a->obj, &idx, &length, a->objSz) < 0 || length < 0) { return ASN_PARSE_E; } if (bufLen < MAX_OID_STRING_SZ) { bufSz = bufLen - 1; } else { bufSz = MAX_OID_STRING_SZ; } if ((bufSz = DecodePolicyOID(buf, (word32)bufSz, a->obj + idx, (word32)length)) <= 0) { WOLFSSL_MSG("Error decoding OID"); return WOLFSSL_FAILURE; } } else { /* return short name */ if (XSTRLEN(a->sName) + 1 < (word32)bufLen - 1) { bufSz = (int)XSTRLEN(a->sName); } else { bufSz = bufLen - 1; } if (bufSz) { XMEMCPY(buf, a->sName, bufSz); } else if (wolfSSL_OBJ_obj2txt(buf, bufLen, a, 1)) { if ((desc = oid_translate_num_to_str(buf))) { bufSz = (int)XSTRLEN(desc); XMEMCPY(buf, desc, min(bufSz, bufLen)); } } else if (a->type == GEN_DNS || a->type == GEN_EMAIL || a->type == GEN_URI) { bufSz = (int)XSTRLEN((const char*)a->obj); XMEMCPY(buf, a->obj, min(bufSz, bufLen)); } } buf[bufSz] = '\0'; #ifdef WOLFSSL_QT /* For unknown extension types, QT expects the short name to be the text representation of the oid */ if (XSTRLEN(a->sName) == 0) { XMEMCPY(a->sName, buf, bufSz); } #endif return bufSz; } #endif /* OPENSSL_EXTRA */ #if defined(OPENSSL_EXTRA) && !defined(NO_ASN) /* DN_Tags to strings */ static const struct DN_Tag_Strings { enum DN_Tags tag; const char* str; } dn_tag_strings[] = { { ASN_COMMON_NAME, "CN" }, { ASN_SUR_NAME, "SN" }, { ASN_SERIAL_NUMBER, "serialNumber" }, { ASN_COUNTRY_NAME, "C" }, { ASN_LOCALITY_NAME, "L" }, { ASN_STATE_NAME, "ST" }, { ASN_ORG_NAME, "O"}, { ASN_ORGUNIT_NAME, "OU"}, { ASN_BUS_CAT, "businessCategory"}, { ASN_EMAIL_NAME, "emailAddress"}, { ASN_USER_ID, "UID"}, { ASN_DOMAIN_COMPONENT, "DC"}, { ASN_DN_NULL, NULL } }; int wolfSSL_X509_NAME_get_index_by_OBJ(WOLFSSL_X509_NAME *name, const WOLFSSL_ASN1_OBJECT *obj, int idx) { const struct DN_Tag_Strings* dn; enum DN_Tags tag = ASN_DN_NULL; if (!name || idx >= name->fullName.locSz || !obj || !obj->obj) { return -1; } if (idx < 0) { idx = 0; } for (dn = dn_tag_strings; dn->str != NULL; dn++) { /* Find the DN_Tags number for the name */ if (XSTRNCMP((const char*) obj->sName, dn->str, obj->objSz - 1) == 0) { tag = dn->tag; break; } } if (!tag) { /* Unable to identify desired name */ return -1; } for (idx++; idx < name->fullName.locSz; idx++) { /* Find index of desired name */ if ((enum DN_Tags)name->fullName.loc[idx] == tag) { return idx; } } return -1; } #endif #if defined(OPENSSL_EXTRA) || defined(HAVE_LIGHTY) || \ defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(HAVE_STUNNEL) || \ defined(WOLFSSL_NGINX) || defined(HAVE_POCO_LIB) || \ defined(WOLFSSL_HAPROXY) #ifndef NO_SHA /* One shot SHA1 hash of message. * * d message to hash * n size of d buffer * md buffer to hold digest. Should be SHA_DIGEST_SIZE. * * Note: if md is null then a static buffer of SHA_DIGEST_SIZE is used. * When the static buffer is used this function is not thread safe. * * Returns a pointer to the message digest on success and NULL on failure. */ unsigned char *wolfSSL_SHA1(const unsigned char *d, size_t n, unsigned char *md) { static byte dig[WC_SHA_DIGEST_SIZE]; wc_Sha sha; WOLFSSL_ENTER("wolfSSL_SHA1"); if (wc_InitSha_ex(&sha, NULL, 0) != 0) { WOLFSSL_MSG("SHA1 Init failed"); return NULL; } if (wc_ShaUpdate(&sha, (const byte*)d, (word32)n) != 0) { WOLFSSL_MSG("SHA1 Update failed"); return NULL; } if (wc_ShaFinal(&sha, dig) != 0) { WOLFSSL_MSG("SHA1 Final failed"); return NULL; } wc_ShaFree(&sha); if (md != NULL) { XMEMCPY(md, dig, WC_SHA_DIGEST_SIZE); return md; } else { return (unsigned char*)dig; } } #endif /* ! NO_SHA */ #ifndef NO_SHA256 /* One shot SHA256 hash of message. * * d message to hash * n size of d buffer * md buffer to hold digest. Should be WC_SHA256_DIGEST_SIZE. * * Note: if md is null then a static buffer of WC_SHA256_DIGEST_SIZE is used. * When the static buffer is used this function is not thread safe. * * Returns a pointer to the message digest on success and NULL on failure. */ unsigned char *wolfSSL_SHA256(const unsigned char *d, size_t n, unsigned char *md) { static byte dig[WC_SHA256_DIGEST_SIZE]; wc_Sha256 sha; WOLFSSL_ENTER("wolfSSL_SHA256"); if (wc_InitSha256_ex(&sha, NULL, 0) != 0) { WOLFSSL_MSG("SHA256 Init failed"); return NULL; } if (wc_Sha256Update(&sha, (const byte*)d, (word32)n) != 0) { WOLFSSL_MSG("SHA256 Update failed"); return NULL; } if (wc_Sha256Final(&sha, dig) != 0) { WOLFSSL_MSG("SHA256 Final failed"); return NULL; } wc_Sha256Free(&sha); if (md != NULL) { XMEMCPY(md, dig, WC_SHA256_DIGEST_SIZE); return md; } else { return (unsigned char*)dig; } } #endif /* ! NO_SHA256 */ #ifdef WOLFSSL_SHA384 /* One shot SHA384 hash of message. * * d message to hash * n size of d buffer * md buffer to hold digest. Should be WC_SHA256_DIGEST_SIZE. * * Note: if md is null then a static buffer of WC_SHA256_DIGEST_SIZE is used. * When the static buffer is used this function is not thread safe. * * Returns a pointer to the message digest on success and NULL on failure. */ unsigned char *wolfSSL_SHA384(const unsigned char *d, size_t n, unsigned char *md) { static byte dig[WC_SHA384_DIGEST_SIZE]; wc_Sha384 sha; WOLFSSL_ENTER("wolfSSL_SHA384"); if (wc_InitSha384_ex(&sha, NULL, 0) != 0) { WOLFSSL_MSG("SHA384 Init failed"); return NULL; } if (wc_Sha384Update(&sha, (const byte*)d, (word32)n) != 0) { WOLFSSL_MSG("SHA384 Update failed"); return NULL; } if (wc_Sha384Final(&sha, dig) != 0) { WOLFSSL_MSG("SHA384 Final failed"); return NULL; } wc_Sha384Free(&sha); if (md != NULL) { XMEMCPY(md, dig, WC_SHA384_DIGEST_SIZE); return md; } else { return (unsigned char*)dig; } } #endif /* WOLFSSL_SHA384 */ #if defined(WOLFSSL_SHA512) /* One shot SHA512 hash of message. * * d message to hash * n size of d buffer * md buffer to hold digest. Should be WC_SHA256_DIGEST_SIZE. * * Note: if md is null then a static buffer of WC_SHA256_DIGEST_SIZE is used. * When the static buffer is used this function is not thread safe. * * Returns a pointer to the message digest on success and NULL on failure. */ unsigned char *wolfSSL_SHA512(const unsigned char *d, size_t n, unsigned char *md) { static byte dig[WC_SHA512_DIGEST_SIZE]; wc_Sha512 sha; WOLFSSL_ENTER("wolfSSL_SHA512"); if (wc_InitSha512_ex(&sha, NULL, 0) != 0) { WOLFSSL_MSG("SHA512 Init failed"); return NULL; } if (wc_Sha512Update(&sha, (const byte*)d, (word32)n) != 0) { WOLFSSL_MSG("SHA512 Update failed"); return NULL; } if (wc_Sha512Final(&sha, dig) != 0) { WOLFSSL_MSG("SHA512 Final failed"); return NULL; } wc_Sha512Free(&sha); if (md != NULL) { XMEMCPY(md, dig, WC_SHA512_DIGEST_SIZE); return md; } else { return (unsigned char*)dig; } } #endif /* defined(WOLFSSL_SHA512) */ #endif /* OPENSSL_EXTRA */ #ifndef WOLFCRYPT_ONLY #if defined(OPENSSL_EXTRA) || defined(HAVE_LIGHTY) || \ defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(HAVE_STUNNEL) || \ defined(WOLFSSL_NGINX) || defined(HAVE_POCO_LIB) || \ defined(WOLFSSL_HAPROXY) char wolfSSL_CTX_use_certificate(WOLFSSL_CTX *ctx, WOLFSSL_X509 *x) { int ret; WOLFSSL_ENTER("wolfSSL_CTX_use_certificate"); FreeDer(&ctx->certificate); /* Make sure previous is free'd */ ret = AllocDer(&ctx->certificate, x->derCert->length, CERT_TYPE, ctx->heap); if (ret != 0) return 0; XMEMCPY(ctx->certificate->buffer, x->derCert->buffer, x->derCert->length); #ifdef KEEP_OUR_CERT if (ctx->ourCert != NULL && ctx->ownOurCert) { FreeX509(ctx->ourCert); XFREE(ctx->ourCert, ctx->heap, DYNAMIC_TYPE_X509); } #ifndef WOLFSSL_X509_STORE_CERTS ctx->ourCert = x; #else ctx->ourCert = wolfSSL_X509_d2i(NULL, x->derCert->buffer,x->derCert->length); if(ctx->ourCert == NULL){ return 0; } #endif ctx->ownOurCert = 0; #endif /* Update the available options with public keys. */ switch (x->pubKeyOID) { case RSAk: ctx->haveRSA = 1; break; #ifdef HAVE_ED25519 case ED25519k: #endif #ifdef HAVE_ED448 case ED448k: #endif case ECDSAk: ctx->haveECC = 1; #if defined(HAVE_ECC) || defined(HAVE_ED25519) || defined(HAVE_ED448) ctx->pkCurveOID = x->pkCurveOID; #endif break; } return WOLFSSL_SUCCESS; } int wolfSSL_CTX_add1_chain_cert(WOLFSSL_CTX* ctx, WOLFSSL_X509* x509) { int ret; if (ctx == NULL || x509 == NULL || x509->derCert == NULL) { return WOLFSSL_FAILURE; } ret = wolfSSL_CTX_load_verify_buffer(ctx, x509->derCert->buffer, x509->derCert->length, WOLFSSL_FILETYPE_ASN1); return (ret == 0) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE; } int wolfSSL_BIO_read_filename(WOLFSSL_BIO *b, const char *name) { #ifndef NO_FILESYSTEM XFILE fp; WOLFSSL_ENTER("wolfSSL_BIO_new_file"); if ((wolfSSL_BIO_get_fp(b, &fp) == WOLFSSL_SUCCESS) && (fp != XBADFILE)) { XFCLOSE(fp); } fp = XFOPEN(name, "r"); if (fp == XBADFILE) return WOLFSSL_BAD_FILE; if (wolfSSL_BIO_set_fp(b, fp, BIO_CLOSE) != WOLFSSL_SUCCESS) { XFCLOSE(fp); return WOLFSSL_BAD_FILE; } /* file is closed when bio is free'd */ return WOLFSSL_SUCCESS; #else (void)name; (void)b; return WOLFSSL_NOT_IMPLEMENTED; #endif } /* Return the corresponding short name for the nid . * or NULL if short name can't be found. */ const char * wolfSSL_OBJ_nid2sn(int n) { const WOLFSSL_ObjectInfo *obj_info = wolfssl_object_info; size_t i; WOLFSSL_ENTER("wolfSSL_OBJ_nid2sn"); for (i = 0; i < WOLFSSL_OBJECT_INFO_SZ; i++, obj_info++) { if (obj_info->nid == n) { return obj_info->sName; } } WOLFSSL_MSG("SN not found"); return NULL; } #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) int wolfSSL_OBJ_sn2nid(const char *sn) { WOLFSSL_ENTER("wolfSSL_OBJ_sn2nid"); if (sn == NULL) return NID_undef; return wc_OBJ_sn2nid(sn); } #endif /* Gets the NID value that corresponds with the ASN1 object. * * o ASN1 object to get NID of * * Return NID on success and a negative value on failure */ int wolfSSL_OBJ_obj2nid(const WOLFSSL_ASN1_OBJECT *o) { word32 oid = 0; word32 idx = 0; WOLFSSL_ENTER("wolfSSL_OBJ_obj2nid"); if (o == NULL) { return -1; } #ifdef WOLFSSL_QT if (o->grp == oidCertExtType) { /* If nid is an unknown extension, return NID_undef */ if (wolfSSL_OBJ_nid2sn(o->nid) == NULL) return NID_undef; } #endif if (o->nid > 0) return o->nid; if (GetObjectId(o->obj, &idx, &oid, o->grp, o->objSz) < 0) { WOLFSSL_MSG("Issue getting OID of object"); return -1; } return oid2nid(oid, o->grp); } /* Returns the long name that corresponds with an ASN1_OBJECT nid value. * n : NID value of ASN1_OBJECT to search */ const char* wolfSSL_OBJ_nid2ln(int n) { const WOLFSSL_ObjectInfo *obj_info = wolfssl_object_info; size_t i; WOLFSSL_ENTER("wolfSSL_OBJ_nid2ln"); for (i = 0; i < WOLFSSL_OBJECT_INFO_SZ; i++, obj_info++) { if (obj_info->nid == n) { return obj_info->lName; } } WOLFSSL_MSG("NID not found in table"); return NULL; } /* Return the corresponding NID for the long name * or NID_undef if NID can't be found. */ int wolfSSL_OBJ_ln2nid(const char *ln) { const WOLFSSL_ObjectInfo *obj_info = wolfssl_object_info; size_t i, lnlen; WOLFSSL_ENTER("wolfSSL_OBJ_ln2nid"); if (ln && (lnlen = XSTRLEN(ln)) > 0) { /* Accept input like "/commonName=" */ if (ln[0] == '/') { ln++; lnlen--; } if (lnlen) { if (ln[lnlen-1] == '=') { lnlen--; } for (i = 0; i < WOLFSSL_OBJECT_INFO_SZ; i++, obj_info++) { if (lnlen == XSTRLEN(obj_info->lName) && XSTRNCMP(ln, obj_info->lName, lnlen) == 0) { return obj_info->nid; } } } } return NID_undef; } /* compares two objects, return 0 if equal */ int wolfSSL_OBJ_cmp(const WOLFSSL_ASN1_OBJECT* a, const WOLFSSL_ASN1_OBJECT* b) { WOLFSSL_ENTER("wolfSSL_OBJ_cmp"); if (a != NULL && b != NULL && a->obj != NULL && b->obj != NULL && a->objSz == b->objSz) { return XMEMCMP(a->obj, b->obj, a->objSz); } return WOLFSSL_FATAL_ERROR; } /* Gets the NID value that is related to the OID string passed in. Example * string would be "2.5.29.14" for subject key ID. * * returns NID value on success and NID_undef on error */ int wolfSSL_OBJ_txt2nid(const char* s) { unsigned int i; #ifdef WOLFSSL_CERT_EXT int ret; unsigned int sum = 0; unsigned int outSz = MAX_OID_SZ; unsigned char out[MAX_OID_SZ]; #endif WOLFSSL_ENTER("OBJ_txt2nid"); if (s == NULL) { return NID_undef; } #ifdef WOLFSSL_CERT_EXT ret = EncodePolicyOID(out, &outSz, s, NULL); if (ret == 0) { /* sum OID */ for (i = 0; i < outSz; i++) { sum += out[i]; } } #endif /* WOLFSSL_CERT_EXT */ /* get the group that the OID's sum is in * @TODO possible conflict with multiples */ for (i = 0; i < WOLFSSL_OBJECT_INFO_SZ; i++) { int len; #ifdef WOLFSSL_CERT_EXT if (ret == 0) { if (wolfssl_object_info[i].id == (int)sum) { return wolfssl_object_info[i].nid; } } #endif /* try as a short name */ len = (int)XSTRLEN(s); if (XSTRNCMP(wolfssl_object_info[i].sName, s, len) == 0) { return wolfssl_object_info[i].nid; } /* try as a long name */ if (XSTRNCMP(wolfssl_object_info[i].lName, s, len) == 0) { return wolfssl_object_info[i].nid; } } return NID_undef; } /* Creates new ASN1_OBJECT from short name, long name, or text * representation of oid. If no_name is 0, then short name, long name, and * numerical value of oid are interpreted. If no_name is 1, then only the * numerical value of the oid is interpreted. * * Returns pointer to ASN1_OBJECT on success, or NULL on error. */ #if defined(WOLFSSL_CERT_EXT) && defined(WOLFSSL_CERT_GEN) WOLFSSL_ASN1_OBJECT* wolfSSL_OBJ_txt2obj(const char* s, int no_name) { int len, i, ret; int nid = NID_undef; unsigned int outSz = MAX_OID_SZ; unsigned char out[MAX_OID_SZ]; unsigned int sum = 0; WOLFSSL_ENTER("wolfSSL_OBJ_txt2obj"); if (s == NULL) return NULL; /* If s is numerical value, try to sum oid */ ret = EncodePolicyOID(out, &outSz, s, NULL); if (ret == 0) { for (i = 0; i < (int)outSz; i++) { sum += out[i]; } } len = (int)XSTRLEN(s); /* TODO: update short names in wolfssl_object_info and check OID sums are correct */ for (i = 0; i < (int)WOLFSSL_OBJECT_INFO_SZ; i++) { /* Short name, long name, and numerical value are interpreted */ if (no_name == 0 && ((XSTRNCMP(s, wolfssl_object_info[i].sName, len) == 0) || (XSTRNCMP(s, wolfssl_object_info[i].lName, len) == 0) || (wolfssl_object_info[i].id == (int)sum))) nid = wolfssl_object_info[i].nid; /* Only numerical value is interpreted */ else if (no_name == 1 && wolfssl_object_info[i].id == (int)sum) nid = wolfssl_object_info[i].nid; } if (nid != NID_undef) return wolfSSL_OBJ_nid2obj(nid); return NULL; } #endif /* compatibility function. Its intended use is to remove OID's from an * internal table that have been added with OBJ_create. wolfSSL manages its * own internal OID values and does not currently support OBJ_create. */ void wolfSSL_OBJ_cleanup(void) { WOLFSSL_ENTER("wolfSSL_OBJ_cleanup()"); } #ifndef NO_WOLFSSL_STUB int wolfSSL_OBJ_create(const char *oid, const char *sn, const char *ln) { (void)oid; (void)sn; (void)ln; WOLFSSL_STUB("wolfSSL_OBJ_create"); return WOLFSSL_FAILURE; } #endif void wolfSSL_set_verify_depth(WOLFSSL *ssl, int depth) { #if !defined(OPENSSL_EXTRA) && !defined(NO_WOLFSSL_STUB) (void)ssl; (void)depth; WOLFSSL_STUB("wolfSSL_set_verify_depth"); #else WOLFSSL_ENTER("wolfSSL_set_verify_depth"); ssl->options.verifyDepth = (byte)depth; #endif } WOLFSSL_ASN1_OBJECT * wolfSSL_X509_NAME_ENTRY_get_object(WOLFSSL_X509_NAME_ENTRY *ne) { WOLFSSL_ENTER("wolfSSL_X509_NAME_ENTRY_get_object"); if (ne == NULL) return NULL; if (wolfSSL_OBJ_nid2obj_ex(ne->nid, &ne->object) != NULL) { ne->object.nid = ne->nid; return &ne->object; } return NULL; } /* looks up the DN given the location "loc". "loc" is the number indicating * the order that the DN was parsed as, 0 is first DN parsed. * * returns the setup WOLFSSL_X509_NAME pointer on success and NULL on fail */ static WOLFSSL_X509_NAME* wolfSSL_nameByLoc(WOLFSSL_X509_NAME *name, int loc) { char* pt = NULL; int sz = 0; switch (name->fullName.loc[loc]) { case ASN_COMMON_NAME: sz = name->fullName.cnLen; pt = &name->fullName.fullName[name->fullName.cnIdx]; name->cnEntry.nid = name->fullName.cnNid; break; case ASN_COUNTRY_NAME: sz = name->fullName.cLen; pt = &name->fullName.fullName[name->fullName.cIdx]; name->cnEntry.nid = name->fullName.cNid; break; case ASN_LOCALITY_NAME: sz = name->fullName.lLen; pt = &name->fullName.fullName[name->fullName.lIdx]; name->cnEntry.nid = name->fullName.lNid; break; case ASN_STATE_NAME: sz = name->fullName.stLen; pt = &name->fullName.fullName[name->fullName.stIdx]; name->cnEntry.nid = name->fullName.stNid; break; case ASN_ORG_NAME: sz = name->fullName.oLen; pt = &name->fullName.fullName[name->fullName.oIdx]; name->cnEntry.nid = name->fullName.oNid; break; case ASN_ORGUNIT_NAME: sz = name->fullName.ouLen; pt = &name->fullName.fullName[name->fullName.ouIdx]; name->cnEntry.nid = name->fullName.ouNid; break; case ASN_EMAIL_NAME: sz = name->fullName.emailLen; pt = &name->fullName.fullName[name->fullName.emailIdx]; name->cnEntry.nid = name->fullName.emailNid; break; case ASN_SUR_NAME: sz = name->fullName.snLen; pt = &name->fullName.fullName[name->fullName.snIdx]; name->cnEntry.nid = name->fullName.snNid; break; case ASN_USER_ID: sz = name->fullName.uidLen; pt = &name->fullName.fullName[name->fullName.uidIdx]; name->cnEntry.nid = name->fullName.uidNid; break; case ASN_SERIAL_NUMBER: sz = name->fullName.serialLen; pt = &name->fullName.fullName[name->fullName.serialIdx]; name->cnEntry.nid = name->fullName.serialNid; break; #ifdef WOLFSSL_CERT_EXT case ASN_BUS_CAT: sz = name->fullName.bcLen; pt = &name->fullName.fullName[name->fullName.bcIdx]; break; #endif case ASN_DOMAIN_COMPONENT: /* get index of DC i.e. first or second or ... case */ { int idx = 0, i; for (i = 0; i < loc; i++) { if (name->fullName.loc[i] == ASN_DOMAIN_COMPONENT) { idx++; } } /* check that index is not larger than max buffer size or larger * than the number of domain components parsed */ if (idx >= DOMAIN_COMPONENT_MAX || idx > name->fullName.dcNum) { WOLFSSL_MSG("Index was larger then domain buffer"); return NULL; } pt = &name->fullName.fullName[name->fullName.dcIdx[idx]], sz = name->fullName.dcLen[idx]; name->cnEntry.nid = ASN_DOMAIN_COMPONENT; name->cnEntry.data.type = CTC_UTF8; } break; default: return NULL; } /* -1 to leave room for trailing terminator 0 */ if (sz == 0 || sz >= CTC_NAME_SIZE - 1) return NULL; if (wolfSSL_ASN1_STRING_set(name->cnEntry.value, pt, sz) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error setting local ASN1 string data"); return NULL; } name->cnEntry.value->type = CTC_UTF8; name->cnEntry.set = 1; return name; } WOLFSSL_X509_NAME_ENTRY *wolfSSL_X509_NAME_get_entry( WOLFSSL_X509_NAME *name, int loc) { WOLFSSL_ENTER("wolfSSL_X509_NAME_get_entry"); if (name == NULL) { return NULL; } if (loc < 0) { WOLFSSL_MSG("Bad argument"); return NULL; } if (loc <= DN_NAMES_MAX + name->fullName.dcNum) { if (wolfSSL_nameByLoc(name, loc) != NULL) return &name->cnEntry; } /* DC component */ if (name->fullName.dcMode) { if (name->fullName.fullName != NULL){ if (loc == name->fullName.dcNum){ name->cnEntry.data.data = &name->fullName.fullName[name->fullName.cIdx]; name->cnEntry.data.length = name->fullName.cLen; name->cnEntry.nid = ASN_COUNTRY_NAME; } else { name->cnEntry.data.data = &name->fullName.fullName[name->fullName.dcIdx[loc]]; name->cnEntry.data.length = name->fullName.dcLen[loc]; name->cnEntry.nid = ASN_DOMAIN_COMPONENT; } } name->cnEntry.data.type = CTC_UTF8; /* common name index case */ } else if (loc == name->fullName.cnIdx && name->x509 != NULL) { /* get CN shortcut from x509 since it has null terminator */ name->cnEntry.data.data = name->x509->subjectCN; name->cnEntry.data.length = name->fullName.cnLen; name->cnEntry.data.type = CTC_UTF8; name->cnEntry.nid = ASN_COMMON_NAME; name->cnEntry.set = 1; } else { WOLFSSL_MSG("loc passed in is not in range of parsed DN's"); return NULL; } return &name->cnEntry; } #ifndef NO_WOLFSSL_STUB int wolfSSL_X509_check_private_key(WOLFSSL_X509 *x509, WOLFSSL_EVP_PKEY *key) { (void) x509; (void) key; WOLFSSL_ENTER("wolfSSL_X509_check_private_key"); WOLFSSL_STUB("X509_check_private_key"); return WOLFSSL_SUCCESS; } WOLF_STACK_OF(WOLFSSL_X509_NAME) *wolfSSL_dup_CA_list( WOLF_STACK_OF(WOLFSSL_X509_NAME) *sk) { (void) sk; WOLFSSL_ENTER("wolfSSL_dup_CA_list"); WOLFSSL_STUB("SSL_dup_CA_list"); return NULL; } #endif #endif /* OPENSSL_ALL || HAVE_LIGHTY || WOLFSSL_MYSQL_COMPATIBLE || HAVE_STUNNEL || WOLFSSL_NGINX || HAVE_POCO_LIB || WOLFSSL_HAPROXY */ #endif /* OPENSSL_EXTRA */ #ifndef WOLFCRYPT_ONLY #ifdef OPENSSL_EXTRA /* wolfSSL uses negative values for error states. This function returns an * unsigned type so the value returned is the absolute value of the error. */ unsigned long wolfSSL_ERR_peek_last_error_line(const char **file, int *line) { WOLFSSL_ENTER("wolfSSL_ERR_peek_last_error"); (void)line; (void)file; #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(DEBUG_WOLFSSL) || \ defined(WOLFSSL_HAPROXY) { int ret; if ((ret = wc_PeekErrorNode(-1, file, NULL, line)) < 0) { WOLFSSL_MSG("Issue peeking at error node in queue"); return 0; } #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) if (ret == -ASN_NO_PEM_HEADER) return (ERR_LIB_PEM << 24) | PEM_R_NO_START_LINE; #endif return (unsigned long)ret; } #else return (unsigned long)(0 - NOT_COMPILED_IN); #endif } #ifndef NO_CERTS int wolfSSL_CTX_use_PrivateKey(WOLFSSL_CTX *ctx, WOLFSSL_EVP_PKEY *pkey) { WOLFSSL_ENTER("wolfSSL_CTX_use_PrivateKey"); if (ctx == NULL || pkey == NULL) { return WOLFSSL_FAILURE; } if (pkey->pkey.ptr != NULL) { /* ptr for WOLFSSL_EVP_PKEY struct is expected to be DER format */ return wolfSSL_CTX_use_PrivateKey_buffer(ctx, (const unsigned char*)pkey->pkey.ptr, pkey->pkey_sz, SSL_FILETYPE_ASN1); } WOLFSSL_MSG("wolfSSL private key not set"); return BAD_FUNC_ARG; } #endif /* !NO_CERTS */ #if defined(HAVE_EX_DATA) || defined(FORTRESS) void* wolfSSL_CTX_get_ex_data(const WOLFSSL_CTX* ctx, int idx) { WOLFSSL_ENTER("wolfSSL_CTX_get_ex_data"); #ifdef HAVE_EX_DATA if(ctx != NULL) { return wolfSSL_CRYPTO_get_ex_data(&ctx->ex_data, idx); } #else (void)ctx; (void)idx; #endif return NULL; } int wolfSSL_CTX_get_ex_new_index(long idx, void* arg, void* a, void* b, void* c) { static int ctx_idx = 0; WOLFSSL_ENTER("wolfSSL_CTX_get_ex_new_index"); (void)idx; (void)arg; (void)a; (void)b; (void)c; return ctx_idx++; } /* Return the index that can be used for the WOLFSSL structure to store * application data. * */ int wolfSSL_get_ex_new_index(long argValue, void* arg, WOLFSSL_CRYPTO_EX_new* cb1, WOLFSSL_CRYPTO_EX_dup* cb2, WOLFSSL_CRYPTO_EX_free* cb3) { static int ssl_idx = 0; WOLFSSL_ENTER("wolfSSL_get_ex_new_index"); (void)argValue; (void)arg; (void)cb1; (void)cb2; (void)cb3; return ssl_idx++; } int wolfSSL_CTX_set_ex_data(WOLFSSL_CTX* ctx, int idx, void* data) { WOLFSSL_ENTER("wolfSSL_CTX_set_ex_data"); #ifdef HAVE_EX_DATA if (ctx != NULL) { return wolfSSL_CRYPTO_set_ex_data(&ctx->ex_data, idx, data); } #else (void)ctx; (void)idx; (void)data; #endif return WOLFSSL_FAILURE; } #endif /* Returns char* to app data stored in ex[0]. * * ssl WOLFSSL structure to get app data from */ void* wolfSSL_get_app_data(const WOLFSSL *ssl) { /* checkout exdata stuff... */ WOLFSSL_ENTER("wolfSSL_get_app_data"); return wolfSSL_get_ex_data(ssl, 0); } /* Set ex array 0 to have app data * * ssl WOLFSSL struct to set app data in * arg data to be stored * * Returns SSL_SUCCESS on success and SSL_FAILURE on failure */ int wolfSSL_set_app_data(WOLFSSL *ssl, void* arg) { WOLFSSL_ENTER("wolfSSL_set_app_data"); return wolfSSL_set_ex_data(ssl, 0, arg); } int wolfSSL_set_ex_data(WOLFSSL* ssl, int idx, void* data) { WOLFSSL_ENTER("wolfSSL_set_ex_data"); #if defined(HAVE_EX_DATA) || defined(FORTRESS) if (ssl != NULL) { return wolfSSL_CRYPTO_set_ex_data(&ssl->ex_data, idx, data); } #else WOLFSSL_MSG("HAVE_EX_DATA macro is not defined"); (void)ssl; (void)idx; (void)data; #endif return WOLFSSL_FAILURE; } void* wolfSSL_get_ex_data(const WOLFSSL* ssl, int idx) { WOLFSSL_ENTER("wolfSSL_get_ex_data"); #if defined(HAVE_EX_DATA) || defined(FORTRESS) if (ssl != NULL) { return wolfSSL_CRYPTO_get_ex_data(&ssl->ex_data, idx); } #else WOLFSSL_MSG("HAVE_EX_DATA macro is not defined"); (void)ssl; (void)idx; #endif return 0; } #ifndef NO_DSA WOLFSSL_DSA *wolfSSL_PEM_read_bio_DSAparams(WOLFSSL_BIO *bp, WOLFSSL_DSA **x, pem_password_cb *cb, void *u) { WOLFSSL_DSA* dsa; DsaKey* key; int length; unsigned char* buf; word32 bufSz; int ret; word32 idx = 0; DerBuffer* pDer; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_DSAparams"); ret = wolfSSL_BIO_get_mem_data(bp, &buf); if (ret <= 0) { WOLFSSL_LEAVE("wolfSSL_PEM_read_bio_DSAparams", ret); return NULL; } bufSz = (word32)ret; if (cb != NULL || u != NULL) { /* * cb is for a call back when encountering encrypted PEM files * if cb == NULL and u != NULL then u = null terminated password string */ WOLFSSL_MSG("Not yet supporting call back or password for encrypted PEM"); } if ((ret = PemToDer(buf, (long)bufSz, DSA_PARAM_TYPE, &pDer, NULL, NULL, NULL)) < 0 ) { WOLFSSL_MSG("Issue converting from PEM to DER"); return NULL; } if ((ret = GetSequence(pDer->buffer, &idx, &length, pDer->length)) < 0) { WOLFSSL_LEAVE("wolfSSL_PEM_read_bio_DSAparams", ret); FreeDer(&pDer); return NULL; } dsa = wolfSSL_DSA_new(); if (dsa == NULL) { FreeDer(&pDer); WOLFSSL_MSG("Error creating DSA struct"); return NULL; } key = (DsaKey*)dsa->internal; if (key == NULL) { FreeDer(&pDer); wolfSSL_DSA_free(dsa); WOLFSSL_MSG("Error finding DSA key struct"); return NULL; } if (GetInt(&key->p, pDer->buffer, &idx, pDer->length) < 0 || GetInt(&key->q, pDer->buffer, &idx, pDer->length) < 0 || GetInt(&key->g, pDer->buffer, &idx, pDer->length) < 0 ) { WOLFSSL_MSG("dsa key error"); FreeDer(&pDer); wolfSSL_DSA_free(dsa); return NULL; } if (SetIndividualExternal(&dsa->p, &key->p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa p key error"); FreeDer(&pDer); wolfSSL_DSA_free(dsa); return NULL; } if (SetIndividualExternal(&dsa->q, &key->q) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa q key error"); FreeDer(&pDer); wolfSSL_DSA_free(dsa); return NULL; } if (SetIndividualExternal(&dsa->g, &key->g) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa g key error"); FreeDer(&pDer); wolfSSL_DSA_free(dsa); return NULL; } if (x != NULL) { *x = dsa; } FreeDer(&pDer); return dsa; } #endif /* NO_DSA */ #endif /* OPENSSL_EXTRA */ #endif /* WOLFCRYPT_ONLY */ #if defined(OPENSSL_EXTRA) /* Begin functions for openssl/buffer.h */ WOLFSSL_BUF_MEM* wolfSSL_BUF_MEM_new(void) { WOLFSSL_BUF_MEM* buf; buf = (WOLFSSL_BUF_MEM*)XMALLOC(sizeof(WOLFSSL_BUF_MEM), NULL, DYNAMIC_TYPE_OPENSSL); if (buf) { XMEMSET(buf, 0, sizeof(WOLFSSL_BUF_MEM)); } return buf; } /* returns length of buffer on success */ int wolfSSL_BUF_MEM_grow(WOLFSSL_BUF_MEM* buf, size_t len) { int len_int = (int)len; int mx; /* verify provided arguments */ if (buf == NULL || len_int < 0) { return 0; /* BAD_FUNC_ARG; */ } /* check to see if fits in existing length */ if (buf->length > len) { buf->length = len; return len_int; } /* check to see if fits in max buffer */ if (buf->max >= len) { if (buf->data != NULL) { XMEMSET(&buf->data[buf->length], 0, len - buf->length); } buf->length = len; return len_int; } /* expand size, to handle growth */ mx = (len_int + 3) / 3 * 4; /* use realloc */ buf->data = (char*)XREALLOC(buf->data, mx, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (buf->data == NULL) { return 0; /* ERR_R_MALLOC_FAILURE; */ } buf->max = mx; XMEMSET(&buf->data[buf->length], 0, len - buf->length); buf->length = len; return len_int; } void wolfSSL_BUF_MEM_free(WOLFSSL_BUF_MEM* buf) { if (buf) { if (buf->data) { XFREE(buf->data, NULL, DYNAMIC_TYPE_TMP_BUFFER); buf->data = NULL; } buf->max = 0; buf->length = 0; XFREE(buf, NULL, DYNAMIC_TYPE_OPENSSL); } } /* End Functions for openssl/buffer.h */ #endif /* OPENSSL_EXTRA */ #if defined(HAVE_LIGHTY) || defined(HAVE_STUNNEL) \ || defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(OPENSSL_EXTRA) WOLFSSL_BIO *wolfSSL_BIO_new_file(const char *filename, const char *mode) { #ifndef NO_FILESYSTEM WOLFSSL_BIO* bio; XFILE fp; WOLFSSL_ENTER("wolfSSL_BIO_new_file"); fp = XFOPEN(filename, mode); if (fp == XBADFILE) return NULL; bio = wolfSSL_BIO_new(wolfSSL_BIO_s_file()); if (bio == NULL) { XFCLOSE(fp); return bio; } if (wolfSSL_BIO_set_fp(bio, fp, BIO_CLOSE) != WOLFSSL_SUCCESS) { XFCLOSE(fp); wolfSSL_BIO_free(bio); bio = NULL; } /* file is closed when BIO is free'd */ return bio; #else (void)filename; (void)mode; return NULL; #endif /* NO_FILESYSTEM */ } #ifndef NO_FILESYSTEM WOLFSSL_BIO* wolfSSL_BIO_new_fp(XFILE fp, int close_flag) { WOLFSSL_BIO* bio; WOLFSSL_ENTER("wolfSSL_BIO_new_fp"); bio = wolfSSL_BIO_new(wolfSSL_BIO_s_file()); if (bio == NULL) { return bio; } if (wolfSSL_BIO_set_fp(bio, fp, close_flag) != WOLFSSL_SUCCESS) { wolfSSL_BIO_free(bio); bio = NULL; } /* file is closed when BIO is free'd or by user depending on flag */ return bio; } #endif #ifndef NO_DH WOLFSSL_DH *wolfSSL_PEM_read_bio_DHparams(WOLFSSL_BIO *bio, WOLFSSL_DH **x, pem_password_cb *cb, void *u) { #ifndef NO_FILESYSTEM WOLFSSL_DH* localDh = NULL; unsigned char* mem = NULL; word32 size; long sz; int ret; DerBuffer *der = NULL; byte* p = NULL; byte* g = NULL; word32 pSz = MAX_DH_SIZE; word32 gSz = MAX_DH_SIZE; int memAlloced = 0; WOLFSSL_ENTER("wolfSSL_PEM_read_bio_DHparams"); (void)cb; (void)u; if (bio == NULL) { WOLFSSL_MSG("Bad Function Argument bio is NULL"); return NULL; } if (bio->type == WOLFSSL_BIO_MEMORY) { /* Use the buffer directly. */ ret = wolfSSL_BIO_get_mem_data(bio, &mem); if (mem == NULL || ret <= 0) { WOLFSSL_MSG("Failed to get data from bio struct"); goto end; } size = ret; } else if (bio->type == WOLFSSL_BIO_FILE) { /* Read whole file into a new buffer. */ if (XFSEEK((XFILE)bio->ptr, 0, SEEK_END) != 0) goto end; sz = XFTELL((XFILE)bio->ptr); if (XFSEEK((XFILE)bio->ptr, 0, SEEK_SET) != 0) goto end; if (sz > MAX_WOLFSSL_FILE_SIZE || sz <= 0L) { WOLFSSL_MSG("PEM_read_bio_DHparams file size error"); goto end; } mem = (unsigned char*)XMALLOC(sz, NULL, DYNAMIC_TYPE_PEM); if (mem == NULL) goto end; memAlloced = 1; if (wolfSSL_BIO_read(bio, (char *)mem, (int)sz) <= 0) goto end; size = (word32)sz; } else { WOLFSSL_MSG("BIO type not supported for reading DH parameters"); goto end; } ret = PemToDer(mem, size, DH_PARAM_TYPE, &der, NULL, NULL, NULL); if (ret != 0) goto end; /* Use the object passed in, otherwise allocate a new object */ if (x != NULL) localDh = *x; if (localDh == NULL) { localDh = wolfSSL_DH_new(); if (localDh == NULL) goto end; } /* Load data in manually */ p = (byte*)XMALLOC(pSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); g = (byte*)XMALLOC(gSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY); if (p == NULL || g == NULL) goto end; /* Extract the p and g as data from the DER encoded DH parameters. */ ret = wc_DhParamsLoad(der->buffer, der->length, p, &pSz, g, &gSz); if (ret != 0) { if (x != NULL && localDh != *x) XFREE(localDh, NULL, DYNAMIC_TYPE_OPENSSL); localDh = NULL; goto end; } if (x != NULL) *x = localDh; /* Put p and g in as big numbers. */ if (localDh->p != NULL) { wolfSSL_BN_free(localDh->p); localDh->p = NULL; } if (localDh->g != NULL) { wolfSSL_BN_free(localDh->g); localDh->g = NULL; } localDh->p = wolfSSL_BN_bin2bn(p, pSz, NULL); localDh->g = wolfSSL_BN_bin2bn(g, gSz, NULL); if (localDh->p == NULL || localDh->g == NULL) { if (x != NULL && localDh != *x) wolfSSL_DH_free(localDh); localDh = NULL; } if (localDh != NULL && localDh->inSet == 0) { if (SetDhInternal(localDh) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Unable to set internal DH structure"); wolfSSL_DH_free(localDh); localDh = NULL; } } end: if (memAlloced) XFREE(mem, NULL, DYNAMIC_TYPE_PEM); if (der != NULL) FreeDer(&der); XFREE(p, NULL, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(g, NULL, DYNAMIC_TYPE_PUBLIC_KEY); return localDh; #else (void)bio; (void)x; (void)cb; (void)u; return NULL; #endif } #ifndef NO_FILESYSTEM #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) || defined(WOLFSSL_OPENSSH) /* Convert DH key parameters to DER format, write to output (outSz) * If output is NULL then max expected size is set to outSz and LENGTH_ONLY_E is * returned. * * Note : static function due to redefinition complications with DhKey and FIPS * version 2 build. * * return bytes written on success */ int wc_DhParamsToDer(DhKey* key, byte* out, word32* outSz) { word32 sz = 0, idx = 0; int pSz = 0, gSz = 0, ret; byte scratch[MAX_LENGTH_SZ]; if (key == NULL || outSz == NULL) { return BAD_FUNC_ARG; } pSz = mp_unsigned_bin_size(&key->p); if (pSz < 0) { return pSz; } if (mp_leading_bit(&key->p)) { pSz++; } gSz = mp_unsigned_bin_size(&key->g); if (gSz < 0) { return gSz; } if (mp_leading_bit(&key->g)) { gSz++; } sz = ASN_TAG_SZ; /* Integer */ sz += SetLength(pSz, scratch); sz += ASN_TAG_SZ; /* Integer */ sz += SetLength(gSz, scratch); sz += gSz + pSz; if (out == NULL) { byte seqScratch[MAX_SEQ_SZ]; *outSz = sz + SetSequence(sz, seqScratch); return LENGTH_ONLY_E; } if (*outSz < MAX_SEQ_SZ || *outSz < sz) { return BUFFER_E; } idx += SetSequence(sz, out); if (*outSz < idx + sz) { return BUFFER_E; } out[idx++] = ASN_INTEGER; idx += SetLength(pSz, out + idx); if (mp_leading_bit(&key->p)) { out[idx++] = 0x00; pSz -= 1; /* subtract 1 from size to account for leading 0 */ } ret = mp_to_unsigned_bin(&key->p, out + idx); if (ret != MP_OKAY) { return BUFFER_E; } idx += pSz; out[idx++] = ASN_INTEGER; idx += SetLength(gSz, out + idx); if (mp_leading_bit(&key->g)) { out[idx++] = 0x00; gSz -= 1; /* subtract 1 from size to account for leading 0 */ } ret = mp_to_unsigned_bin(&key->g, out + idx); if (ret != MP_OKAY) { return BUFFER_E; } idx += gSz; return idx; } int wc_DhPubKeyToDer(DhKey* key, byte* out, word32* outSz) { word32 sz = 0; word32 paramSz = 0; int ret; int pubSz = 0; int idx = 0; byte scratch[MAX_ALGO_SZ]; /* Get size of entire key */ /* SEQUENCE <--| SetAlgoId * OBJECT IDENTIFIER <--| * SEQUENCE <-- * INTEGER | wc_DhParamsToDer * INTEGER <-- */ ret = wc_DhParamsToDer(key, NULL, ¶mSz); if (ret != LENGTH_ONLY_E) return ASN_PARSE_E; sz += paramSz; sz += SetAlgoID(DHk, scratch, oidKeyType, paramSz); /* BIT STRING * INTEGER */ pubSz = mp_unsigned_bin_size(&key->pub); if (pubSz < 0) return pubSz; if (mp_leading_bit(&key->pub)) pubSz++; sz += ASN_TAG_SZ; /* Integer */ sz += SetLength(pubSz, scratch); sz += pubSz; sz += SetBitString(pubSz, 0, scratch); if (out == NULL) { /* Uppermost SEQUENCE */ *outSz = sz + SetSequence(sz, scratch); return LENGTH_ONLY_E; } /* end get size of entire key */ /* Check for indexing errors */ if (*outSz < MAX_SEQ_SZ || *outSz < sz) { return BUFFER_E; } /* Build Up Entire Key */ idx += SetSequence(sz, out); idx += SetAlgoID(DHk, out+idx, oidKeyType, paramSz); ret = wc_DhParamsToDer(key, out+idx, ¶mSz); if (ret < 0) return ret; idx += ret; /* BIT STRING * INTEGER */ idx += SetBitString(pubSz, 0, out+idx); out[idx++] = ASN_INTEGER; idx += SetLength(pubSz, out + idx); if (mp_leading_bit(&key->pub)) { out[idx++] = 0x00; pubSz -= 1; /* subtract 1 from size to account for leading 0 */ } ret = mp_to_unsigned_bin(&key->pub, out + idx); if (ret != MP_OKAY) { return BUFFER_E; } idx += pubSz; return idx; } int wc_DhPrivKeyToDer(DhKey* key, byte* out, word32* outSz) { word32 sz = 0; word32 paramSz = 0; int ret; int privSz = 0; int idx = 0; byte scratch[MAX_ALGO_SZ]; /* Get size of entire key */ /* INTEGER 0 */ sz += ASN_TAG_SZ; /* Integer */ sz += SetLength(1, scratch); sz += 1; /* SEQUENCE <--| SetAlgoId * OBJECT IDENTIFIER <--| * SEQUENCE <-- * INTEGER | wc_DhParamsToDer * INTEGER <-- */ ret = wc_DhParamsToDer(key, NULL, ¶mSz); if (ret != LENGTH_ONLY_E) return ASN_PARSE_E; sz += paramSz; sz += SetAlgoID(DHk, scratch, oidKeyType, paramSz); /* OCTET STRING * INTEGER */ privSz = mp_unsigned_bin_size(&key->priv); if (privSz < 0) return privSz; else if (privSz > 256) /* Key is larger than 2048 */ return ASN_VERSION_E; if (mp_leading_bit(&key->priv)) privSz++; sz += ASN_TAG_SZ; /* Integer */ sz += SetLength(privSz, scratch); sz += privSz; sz += SetOctetString(privSz + ASN_OCTET_STRING, scratch); if (out == NULL) { /* Uppermost SEQUENCE */ *outSz = sz + SetSequence(sz, scratch); return LENGTH_ONLY_E; } /* end get size of entire key */ /* Check for indexing errors */ if (*outSz < MAX_SEQ_SZ || *outSz < sz) { return BUFFER_E; } /* Build Up Entire Key */ idx += SetSequence(sz, out); /* INTEGER 0 */ out[idx++] = ASN_INTEGER; idx += SetLength(1, out+idx); out[idx++] = 0; idx += SetAlgoID(DHk, out+idx, oidKeyType, paramSz); ret = wc_DhParamsToDer(key, out+idx, ¶mSz); if (ret < 0) return ret; idx += ret; /* OCTET STRING * INTEGER */ if (privSz == 256) { idx += SetOctetString(privSz + ASN_OCTET_STRING, out+idx); } else if (privSz == 128) { idx += SetOctetString(privSz + ASN_OCTET_STRING-1, out+idx); } else if (privSz == 64) { idx += SetOctetString(privSz + ASN_OCTET_STRING-2, out+idx); } else { WOLFSSL_MSG("Unsupported key size"); return ASN_VERSION_E; } out[idx++] = ASN_INTEGER; idx += SetLength(privSz, out + idx); if (mp_leading_bit(&key->priv)) { out[idx++] = 0x00; privSz -= 1; /* subtract 1 from size to account for leading 0 */ } ret = mp_to_unsigned_bin(&key->priv, out + idx); if (ret != MP_OKAY) { return BUFFER_E; } idx += privSz; return idx; } /* Writes the DH parameters in PEM format from "dh" out to the file pointer * passed in. * * returns WOLFSSL_SUCCESS on success */ int wolfSSL_PEM_write_DHparams(XFILE fp, WOLFSSL_DH* dh) { int ret; word32 derSz = 0, pemSz = 0; byte *der, *pem; DhKey* key; WOLFSSL_ENTER("wolfSSL_PEM_write_DHparams"); if (dh == NULL) { WOLFSSL_LEAVE("wolfSSL_PEM_write_DHparams", BAD_FUNC_ARG); return WOLFSSL_FAILURE; } if (dh->inSet == 0) { if (SetDhInternal(dh) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Unable to set internal DH structure"); return WOLFSSL_FAILURE; } } key = (DhKey*)dh->internal; ret = wc_DhParamsToDer(key, NULL, &derSz); if (ret != LENGTH_ONLY_E) { WOLFSSL_MSG("Failed to get size of DH params"); WOLFSSL_LEAVE("wolfSSL_PEM_write_DHparams", ret); return WOLFSSL_FAILURE; } der = (byte*)XMALLOC(derSz, key->heap, DYNAMIC_TYPE_TMP_BUFFER); if (der == NULL) { WOLFSSL_LEAVE("wolfSSL_PEM_write_DHparams", MEMORY_E); return WOLFSSL_FAILURE; } ret = wc_DhParamsToDer(key, der, &derSz); if (ret <= 0) { WOLFSSL_MSG("Failed to export DH params"); WOLFSSL_LEAVE("wolfSSL_PEM_write_DHparams", ret); XFREE(der, key->heap, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } /* convert to PEM */ ret = wc_DerToPem(der, derSz, NULL, 0, DH_PARAM_TYPE); if (ret < 0) { WOLFSSL_MSG("Failed to convert DH params to PEM"); WOLFSSL_LEAVE("wolfSSL_PEM_write_DHparams", ret); XFREE(der, key->heap, DYNAMIC_TYPE_TMP_BUFFER); return ret; } pemSz = (word32)ret; pem = (byte*)XMALLOC(pemSz, key->heap, DYNAMIC_TYPE_TMP_BUFFER); if (pem == NULL) { WOLFSSL_LEAVE("wolfSSL_PEM_write_DHparams", MEMORY_E); XFREE(der, key->heap, DYNAMIC_TYPE_TMP_BUFFER); return ret; } ret = wc_DerToPem(der, derSz, pem, pemSz, DH_PARAM_TYPE); XFREE(der, key->heap, DYNAMIC_TYPE_TMP_BUFFER); if (ret < 0) { WOLFSSL_MSG("Failed to convert DH params to PEM"); WOLFSSL_LEAVE("wolfSSL_PEM_write_DHparams", ret); XFREE(pem, key->heap, DYNAMIC_TYPE_TMP_BUFFER); return ret; } ret = (int)XFWRITE(pem, 1, pemSz, fp); XFREE(pem, key->heap, DYNAMIC_TYPE_TMP_BUFFER); if (ret <= 0) { WOLFSSL_MSG("Failed to write to file"); WOLFSSL_LEAVE("wolfSSL_PEM_write_DHparams", ret); return WOLFSSL_FAILURE; } WOLFSSL_LEAVE("wolfSSL_PEM_write_DHparams", WOLFSSL_SUCCESS); return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_QT || OPENSSL_ALL */ #endif /* !NO_FILESYSTEM */ #endif /* !NO_DH */ #ifdef WOLFSSL_CERT_GEN #ifdef WOLFSSL_CERT_REQ /* writes the x509 from x to the WOLFSSL_BIO bp * * returns WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on fail */ int wolfSSL_PEM_write_bio_X509_REQ(WOLFSSL_BIO *bp, WOLFSSL_X509 *x) { byte* pem; int pemSz = 0; const unsigned char* der; int derSz; int ret; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_X509_REQ()"); if (x == NULL || bp == NULL) { return WOLFSSL_FAILURE; } der = wolfSSL_X509_get_der(x, &derSz); if (der == NULL) { return WOLFSSL_FAILURE; } /* get PEM size */ pemSz = wc_DerToPemEx(der, derSz, NULL, 0, NULL, CERTREQ_TYPE); if (pemSz < 0) { return WOLFSSL_FAILURE; } /* create PEM buffer and convert from DER */ pem = (byte*)XMALLOC(pemSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (pem == NULL) { return WOLFSSL_FAILURE; } if (wc_DerToPemEx(der, derSz, pem, pemSz, NULL, CERTREQ_TYPE) < 0) { XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } /* write the PEM to BIO */ ret = wolfSSL_BIO_write(bp, pem, pemSz); XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (ret <= 0) return WOLFSSL_FAILURE; return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_CERT_REQ */ /* writes the x509 from x to the WOLFSSL_BIO bp * * returns WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on fail */ int wolfSSL_PEM_write_bio_X509_AUX(WOLFSSL_BIO *bp, WOLFSSL_X509 *x) { byte* pem; int pemSz = 0; const unsigned char* der; int derSz; int ret; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_X509_AUX()"); if (bp == NULL || x == NULL) { WOLFSSL_MSG("NULL argument passed in"); return WOLFSSL_FAILURE; } der = wolfSSL_X509_get_der(x, &derSz); if (der == NULL) { return WOLFSSL_FAILURE; } /* get PEM size */ pemSz = wc_DerToPemEx(der, derSz, NULL, 0, NULL, CERT_TYPE); if (pemSz < 0) { return WOLFSSL_FAILURE; } /* create PEM buffer and convert from DER */ pem = (byte*)XMALLOC(pemSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (pem == NULL) { return WOLFSSL_FAILURE; } if (wc_DerToPemEx(der, derSz, pem, pemSz, NULL, CERT_TYPE) < 0) { XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } /* write the PEM to BIO */ ret = wolfSSL_BIO_write(bp, pem, pemSz); XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (ret <= 0) return WOLFSSL_FAILURE; return WOLFSSL_SUCCESS; } #endif /* WOLFSSL_CERT_GEN */ int wolfSSL_PEM_write_bio_X509(WOLFSSL_BIO *bio, WOLFSSL_X509 *cert) { byte* pem; int pemSz = 0; const unsigned char* der; int derSz; int ret; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_X509_AUX()"); if (bio == NULL || cert == NULL) { WOLFSSL_MSG("NULL argument passed in"); return WOLFSSL_FAILURE; } der = wolfSSL_X509_get_der(cert, &derSz); if (der == NULL) { return WOLFSSL_FAILURE; } /* get PEM size */ pemSz = wc_DerToPemEx(der, derSz, NULL, 0, NULL, CERT_TYPE); if (pemSz < 0) { return WOLFSSL_FAILURE; } /* create PEM buffer and convert from DER */ pem = (byte*)XMALLOC(pemSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (pem == NULL) { return WOLFSSL_FAILURE; } if (wc_DerToPemEx(der, derSz, pem, pemSz, NULL, CERT_TYPE) < 0) { XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } /* write the PEM to BIO */ ret = wolfSSL_BIO_write(bio, pem, pemSz); XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (ret <= 0) return WOLFSSL_FAILURE; return WOLFSSL_SUCCESS; } #if defined(OPENSSL_EXTRA) && !defined(NO_DH) /* Initialize ctx->dh with dh's params. Return WOLFSSL_SUCCESS on ok */ long wolfSSL_CTX_set_tmp_dh(WOLFSSL_CTX* ctx, WOLFSSL_DH* dh) { int pSz, gSz; byte *p, *g; int ret=0; WOLFSSL_ENTER("wolfSSL_CTX_set_tmp_dh"); if(!ctx || !dh) return BAD_FUNC_ARG; /* Get needed size for p and g */ pSz = wolfSSL_BN_bn2bin(dh->p, NULL); gSz = wolfSSL_BN_bn2bin(dh->g, NULL); if(pSz <= 0 || gSz <= 0) return WOLFSSL_FATAL_ERROR; p = (byte*)XMALLOC(pSz, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); if(!p) return MEMORY_E; g = (byte*)XMALLOC(gSz, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); if(!g) { XFREE(p, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); return MEMORY_E; } pSz = wolfSSL_BN_bn2bin(dh->p, p); gSz = wolfSSL_BN_bn2bin(dh->g, g); if(pSz >= 0 && gSz >= 0) /* Conversion successful */ ret = wolfSSL_CTX_SetTmpDH(ctx, p, pSz, g, gSz); XFREE(p, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(g, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY); return pSz > 0 && gSz > 0 ? ret : WOLFSSL_FATAL_ERROR; } #endif /* OPENSSL_EXTRA && !NO_DH */ /* returns the enum value associated with handshake state * * ssl the WOLFSSL structure to get state of */ int wolfSSL_get_state(const WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_state"); if (ssl == NULL) { WOLFSSL_MSG("Null argument passed in"); return SSL_FAILURE; } return ssl->options.handShakeState; } #endif /* HAVE_LIGHTY || HAVE_STUNNEL || WOLFSSL_MYSQL_COMPATIBLE */ #if defined(OPENSSL_ALL) || defined(WOLFSSL_ASIO) || defined(WOLFSSL_HAPROXY) \ || defined(WOLFSSL_NGINX) || defined(WOLFSSL_QT) long wolfSSL_ctrl(WOLFSSL* ssl, int cmd, long opt, void* pt) { WOLFSSL_ENTER("wolfSSL_ctrl"); if (ssl == NULL) return BAD_FUNC_ARG; switch (cmd) { #if defined(WOLFSSL_NGINX) || defined(WOLFSSL_QT) || defined(OPENSSL_ALL) case SSL_CTRL_SET_TLSEXT_HOSTNAME: WOLFSSL_MSG("Entering Case: SSL_CTRL_SET_TLSEXT_HOSTNAME."); #ifdef HAVE_SNI if (pt == NULL) { WOLFSSL_MSG("Passed in NULL Host Name."); break; } return wolfSSL_set_tlsext_host_name(ssl, (const char*) pt); #else WOLFSSL_MSG("SNI not enabled."); break; #endif /* HAVE_SNI */ #endif /* WOLFSSL_NGINX || WOLFSSL_QT || OPENSSL_ALL */ default: WOLFSSL_MSG("Case not implemented."); } (void)opt; (void)pt; return WOLFSSL_FAILURE; } long wolfSSL_CTX_ctrl(WOLFSSL_CTX* ctx, int cmd, long opt, void* pt) { #if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER) long ctrl_opt; #endif long ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_CTX_ctrl"); if (ctx == NULL) return WOLFSSL_FAILURE; switch (cmd) { case SSL_CTRL_CHAIN: #ifdef SESSION_CERTS { /* * We don't care about opt here because a copy of the certificate is * stored anyway so increasing the reference counter is not necessary. * Just check to make sure that it is set to one of the correct values. */ WOLF_STACK_OF(WOLFSSL_X509)* sk = (WOLF_STACK_OF(WOLFSSL_X509)*) pt; WOLFSSL_X509* x509; int i; if (opt != 0 && opt != 1) { ret = WOLFSSL_FAILURE; break; } /* Clear certificate chain */ FreeDer(&ctx->certChain); if (sk) { for (i = 0; i < wolfSSL_sk_X509_num(sk); i++) { x509 = wolfSSL_sk_X509_value(sk, i); /* Prevent wolfSSL_CTX_add_extra_chain_cert from freeing cert */ if (wolfSSL_X509_up_ref(x509) != 1) { WOLFSSL_MSG("Error increasing reference count"); continue; } if (wolfSSL_CTX_add_extra_chain_cert(ctx, x509) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Error adding certificate to context"); /* Decrease reference count on failure */ wolfSSL_X509_free(x509); } } } /* Free previous chain */ wolfSSL_sk_X509_free(ctx->x509Chain); ctx->x509Chain = sk; if (sk) { for (i = 0; i < wolfSSL_sk_X509_num(sk); i++) { x509 = wolfSSL_sk_X509_value(sk, i); /* On successful setting of new chain up all refs */ if (wolfSSL_X509_up_ref(x509) != 1) { WOLFSSL_MSG("Error increasing reference count"); continue; } } } } #else WOLFSSL_MSG("Session certificates not compiled in"); ret = WOLFSSL_FAILURE; #endif break; #if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER) case SSL_CTRL_OPTIONS: WOLFSSL_MSG("Entering Case: SSL_CTRL_OPTIONS."); ctrl_opt = wolfSSL_CTX_set_options(ctx, opt); #ifdef WOLFSSL_QT /* Set whether to use client or server cipher preference */ if ((ctrl_opt & SSL_OP_CIPHER_SERVER_PREFERENCE) == SSL_OP_CIPHER_SERVER_PREFERENCE) { WOLFSSL_MSG("Using Server's Cipher Preference."); ctx->useClientOrder = FALSE; } else { WOLFSSL_MSG("Using Client's Cipher Preference."); ctx->useClientOrder = TRUE; } #endif /* WOLFSSL_QT */ return ctrl_opt; #endif /* OPENSSL_EXTRA || HAVE_WEBSERVER */ case SSL_CTRL_EXTRA_CHAIN_CERT: WOLFSSL_MSG("Entering Case: SSL_CTRL_EXTRA_CHAIN_CERT."); if (pt == NULL) { WOLFSSL_MSG("Passed in x509 pointer NULL."); ret = WOLFSSL_FAILURE; break; } return wolfSSL_CTX_add_extra_chain_cert(ctx, (WOLFSSL_X509*)pt); #ifndef NO_DH case SSL_CTRL_SET_TMP_DH: WOLFSSL_MSG("Entering Case: SSL_CTRL_SET_TMP_DH."); if (pt == NULL) { WOLFSSL_MSG("Passed in DH pointer NULL."); ret = WOLFSSL_FAILURE; break; } return wolfSSL_CTX_set_tmp_dh(ctx, (WOLFSSL_DH*)pt); #endif #ifdef HAVE_ECC case SSL_CTRL_SET_TMP_ECDH: WOLFSSL_MSG("Entering Case: SSL_CTRL_SET_TMP_ECDH."); if (pt == NULL) { WOLFSSL_MSG("Passed in ECDH pointer NULL."); ret = WOLFSSL_FAILURE; break; } return wolfSSL_SSL_CTX_set_tmp_ecdh(ctx, (WOLFSSL_EC_KEY*)pt); #endif case SSL_CTRL_MODE: wolfSSL_CTX_set_mode(ctx,opt); break; default: WOLFSSL_MSG("CTX_ctrl cmd not implemented"); ret = WOLFSSL_FAILURE; break; } (void)ctx; (void)cmd; (void)opt; (void)pt; WOLFSSL_LEAVE("wolfSSL_CTX_ctrl", (int)ret); return ret; } #ifndef WOLFSSL_NO_STUB long wolfSSL_CTX_callback_ctrl(WOLFSSL_CTX* ctx, int cmd, void (*fp)(void)) { (void) ctx; (void) cmd; (void) fp; WOLFSSL_STUB("wolfSSL_CTX_callback_ctrl"); return WOLFSSL_FAILURE; } #endif /* WOLFSSL_NO_STUB */ #ifndef NO_WOLFSSL_STUB long wolfSSL_CTX_clear_extra_chain_certs(WOLFSSL_CTX* ctx) { return wolfSSL_CTX_ctrl(ctx, SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS, 0l, NULL); } #endif /* Returns the verifyCallback from the ssl structure if successful. Returns NULL otherwise. */ VerifyCallback wolfSSL_get_verify_callback(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_verify_callback()"); if (ssl) { return ssl->verifyCallback; } return NULL; } /* Creates a new bio pair. Returns WOLFSSL_SUCCESS if no error, WOLFSSL_FAILURE otherwise.*/ int wolfSSL_BIO_new_bio_pair(WOLFSSL_BIO **bio1_p, size_t writebuf1, WOLFSSL_BIO **bio2_p, size_t writebuf2) { WOLFSSL_BIO *bio1 = NULL, *bio2 = NULL; int ret = 1; WOLFSSL_ENTER("wolfSSL_BIO_new_bio_pair()"); if (bio1_p == NULL || bio2_p == NULL) { WOLFSSL_MSG("Bad Function Argument"); return BAD_FUNC_ARG; } /* set up the new bio structures and write buf sizes */ if ((bio1 = wolfSSL_BIO_new(wolfSSL_BIO_s_bio())) == NULL) { WOLFSSL_MSG("Bio allocation failed"); ret = WOLFSSL_FAILURE; } if (ret) { if ((bio2 = wolfSSL_BIO_new(wolfSSL_BIO_s_bio())) == NULL) { WOLFSSL_MSG("Bio allocation failed"); ret = WOLFSSL_FAILURE; } } if (ret && writebuf1) { if (!(ret = wolfSSL_BIO_set_write_buf_size(bio1, writebuf1))) { WOLFSSL_MSG("wolfSSL_BIO_set_write_buf() failure"); } } if (ret && writebuf2) { if (!(ret = wolfSSL_BIO_set_write_buf_size(bio2, writebuf2))) { WOLFSSL_MSG("wolfSSL_BIO_set_write_buf() failure"); } } if (ret) { if ((ret = wolfSSL_BIO_make_bio_pair(bio1, bio2))) { *bio1_p = bio1; *bio2_p = bio2; } } if (!ret) { wolfSSL_BIO_free(bio1); bio1 = NULL; wolfSSL_BIO_free(bio2); bio2 = NULL; } return ret; } #if !defined(HAVE_FAST_RSA) && defined(WOLFSSL_KEY_GEN) && \ !defined(NO_RSA) && !defined(HAVE_USER_RSA) /* Converts an rsa key from a bio buffer into an internal rsa structure. Returns a pointer to the new WOLFSSL_RSA structure. */ WOLFSSL_RSA* wolfSSL_d2i_RSAPrivateKey_bio(WOLFSSL_BIO *bio, WOLFSSL_RSA **out) { const unsigned char* bioMem = NULL; int bioMemSz = 0; WOLFSSL_RSA* key = NULL; unsigned char maxKeyBuf[4096]; unsigned char* bufPtr = NULL; unsigned char* extraBioMem = NULL; int extraBioMemSz = 0; int derLength = 0; int j = 0, i = 0; WOLFSSL_ENTER("wolfSSL_d2i_RSAPrivateKey_bio()"); if (bio == NULL) { WOLFSSL_MSG("Bad Function Argument"); return NULL; } (void)out; bioMemSz = wolfSSL_BIO_pending(bio); if (bioMemSz <= 0) { WOLFSSL_MSG("wolfSSL_BIO_pending() failure"); return NULL; } bioMem = (unsigned char*)XMALLOC(bioMemSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (bioMem == NULL) { WOLFSSL_MSG("Malloc failure"); return NULL; } bufPtr = maxKeyBuf; if (wolfSSL_BIO_read(bio, (unsigned char*)bioMem, (int)bioMemSz) == bioMemSz) { const byte* bioMemPt = bioMem; /* leave bioMem pointer unaltered */ if ((key = wolfSSL_d2i_RSAPrivateKey(NULL, &bioMemPt, bioMemSz)) == NULL) { XFREE((unsigned char*)bioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return NULL; } /* This function is used to get the total length of the rsa key. */ derLength = wolfSSL_i2d_RSAPrivateKey(key, &bufPtr); /* Write extra data back into bio object if necessary. */ extraBioMemSz = (bioMemSz - derLength); if (extraBioMemSz > 0) { extraBioMem = (unsigned char *)XMALLOC(extraBioMemSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (extraBioMem == NULL) { WOLFSSL_MSG("Malloc failure"); XFREE((unsigned char*)extraBioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); XFREE((unsigned char*)bioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return NULL; } for (i = derLength; i < bioMemSz; i++) { *(extraBioMem + j) = *(bioMem + i); j++; } wolfSSL_BIO_write(bio, extraBioMem, extraBioMemSz); if (wolfSSL_BIO_pending(bio) <= 0) { WOLFSSL_MSG("Failed to write memory to bio"); XFREE((unsigned char*)extraBioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); XFREE((unsigned char*)bioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return NULL; } XFREE((unsigned char*)extraBioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); } if (out != NULL && key != NULL) { *out = key; } } XFREE((unsigned char*)bioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return key; } #endif /* Adds the ASN1 certificate to the user ctx. Returns WOLFSSL_SUCCESS if no error, returns WOLFSSL_FAILURE otherwise.*/ int wolfSSL_CTX_use_certificate_ASN1(WOLFSSL_CTX *ctx, int derSz, const unsigned char *der) { WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_ASN1()"); if (der != NULL && ctx != NULL) { if (wolfSSL_CTX_use_certificate_buffer(ctx, der, derSz, WOLFSSL_FILETYPE_ASN1) == WOLFSSL_SUCCESS) { return WOLFSSL_SUCCESS; } } return WOLFSSL_FAILURE; } #if !defined(HAVE_FAST_RSA) && defined(WOLFSSL_KEY_GEN) && \ !defined(NO_RSA) && !defined(HAVE_USER_RSA) /* Adds the rsa private key to the user ctx. Returns WOLFSSL_SUCCESS if no error, returns WOLFSSL_FAILURE otherwise.*/ int wolfSSL_CTX_use_RSAPrivateKey(WOLFSSL_CTX* ctx, WOLFSSL_RSA* rsa) { int ret; int derSize; unsigned char maxDerBuf[4096]; unsigned char* key = NULL; WOLFSSL_ENTER("wolfSSL_CTX_use_RSAPrivateKey()"); if (ctx == NULL || rsa == NULL) { WOLFSSL_MSG("one or more inputs were NULL"); return BAD_FUNC_ARG; } key = maxDerBuf; /* convert RSA struct to der encoded buffer and get the size */ if ((derSize = wolfSSL_i2d_RSAPrivateKey(rsa, &key)) <= 0) { WOLFSSL_MSG("wolfSSL_i2d_RSAPrivateKey() failure"); return WOLFSSL_FAILURE; } ret = wolfSSL_CTX_use_PrivateKey_buffer(ctx, (const unsigned char*)maxDerBuf, derSize, SSL_FILETYPE_ASN1); if (ret != WOLFSSL_SUCCESS) { WOLFSSL_MSG("wolfSSL_CTX_USE_PrivateKey_buffer() failure"); return WOLFSSL_FAILURE; } return ret; } #endif /* NO_RSA && !HAVE_FAST_RSA */ /* Converts EVP_PKEY data from a bio buffer to a WOLFSSL_EVP_PKEY structure. Returns pointer to private EVP_PKEY struct upon success, NULL if there is a failure.*/ WOLFSSL_EVP_PKEY* wolfSSL_d2i_PrivateKey_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY** out) { unsigned char* mem = NULL; int memSz = 0; WOLFSSL_EVP_PKEY* key = NULL; int i = 0, j = 0; unsigned char* extraBioMem = NULL; int extraBioMemSz = 0; int derLength = 0; WOLFSSL_ENTER("wolfSSL_d2i_PrivateKey_bio()"); if (bio == NULL) { return NULL; } (void)out; memSz = wolfSSL_BIO_pending(bio); if (memSz <= 0) { WOLFSSL_MSG("wolfSSL_BIO_pending() failure"); return NULL; } mem = (unsigned char*)XMALLOC(memSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (mem == NULL) { WOLFSSL_MSG("Malloc failure"); return NULL; } if (wolfSSL_BIO_read(bio, (unsigned char*)mem, memSz) == memSz) { /* Determines key type and returns the new private EVP_PKEY object */ if ((key = wolfSSL_d2i_PrivateKey_EVP(NULL, &mem, (long)memSz)) == NULL) { WOLFSSL_MSG("wolfSSL_d2i_PrivateKey_EVP() failure"); XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return NULL; } /* Write extra data back into bio object if necessary. */ derLength = key->pkey_sz; extraBioMemSz = (memSz - derLength); if (extraBioMemSz > 0) { extraBioMem = (unsigned char *)XMALLOC(extraBioMemSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (extraBioMem == NULL) { WOLFSSL_MSG("Malloc failure"); XFREE((unsigned char*)extraBioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return NULL; } for (i = derLength; i < memSz; i++) { *(extraBioMem + j) = *(mem + i); j++; } wolfSSL_BIO_write(bio, extraBioMem, extraBioMemSz); if (wolfSSL_BIO_pending(bio) <= 0) { WOLFSSL_MSG("Failed to write memory to bio"); XFREE((unsigned char*)extraBioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return NULL; } XFREE((unsigned char*)extraBioMem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); } if (out != NULL) { *out = key; } } XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); return key; } /* Converts a DER encoded private key to a WOLFSSL_EVP_PKEY structure. * returns a pointer to a new WOLFSSL_EVP_PKEY structure on success and NULL * on fail */ WOLFSSL_EVP_PKEY* wolfSSL_d2i_PrivateKey_EVP(WOLFSSL_EVP_PKEY** out, unsigned char** in, long inSz) { WOLFSSL_EVP_PKEY* pkey = NULL; const unsigned char* mem; long memSz = inSz; WOLFSSL_ENTER("wolfSSL_d2i_PrivateKey_EVP()"); if (in == NULL || *in == NULL || inSz < 0) { WOLFSSL_MSG("Bad argument"); return NULL; } mem = *in; #if !defined(NO_RSA) { RsaKey rsa; word32 keyIdx = 0; /* test if RSA key */ if (wc_InitRsaKey(&rsa, NULL) == 0 && wc_RsaPrivateKeyDecode(mem, &keyIdx, &rsa, (word32)memSz) == 0) { wc_FreeRsaKey(&rsa); pkey = wolfSSL_EVP_PKEY_new(); if (pkey != NULL) { pkey->pkey_sz = keyIdx; pkey->pkey.ptr = (char*)XMALLOC(memSz, NULL, DYNAMIC_TYPE_PRIVATE_KEY); if (pkey->pkey.ptr == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } XMEMCPY(pkey->pkey.ptr, mem, keyIdx); pkey->type = EVP_PKEY_RSA; if (out != NULL) { *out = pkey; } pkey->ownRsa = 1; pkey->rsa = wolfSSL_RSA_new(); if (pkey->rsa == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } if (wolfSSL_RSA_LoadDer_ex(pkey->rsa, (const unsigned char*)pkey->pkey.ptr, pkey->pkey_sz, WOLFSSL_RSA_LOAD_PRIVATE) != 1) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } return pkey; } } wc_FreeRsaKey(&rsa); } #endif /* NO_RSA */ #ifdef HAVE_ECC { word32 keyIdx = 0; ecc_key ecc; /* test if ecc key */ if (wc_ecc_init(&ecc) == 0 && wc_EccPrivateKeyDecode(mem, &keyIdx, &ecc, (word32)memSz) == 0) { wc_ecc_free(&ecc); pkey = wolfSSL_EVP_PKEY_new(); if (pkey != NULL) { pkey->pkey_sz = keyIdx; pkey->pkey.ptr = (char*)XMALLOC(keyIdx, NULL, DYNAMIC_TYPE_PRIVATE_KEY); if (pkey->pkey.ptr == NULL) { wolfSSL_EVP_PKEY_free(pkey); return NULL; } XMEMCPY(pkey->pkey.ptr, mem, keyIdx); pkey->type = EVP_PKEY_EC; if (out != NULL) { *out = pkey; } return pkey; } } wc_ecc_free(&ecc); } #endif /* HAVE_ECC */ return pkey; } #endif /* OPENSSL_ALL || WOLFSSL_ASIO || WOLFSSL_HAPROXY || WOLFSSL_QT */ /* stunnel compatibility functions*/ #if defined(OPENSSL_ALL) || (defined(OPENSSL_EXTRA) && (defined(HAVE_STUNNEL) || \ defined(WOLFSSL_NGINX) || defined(HAVE_LIGHTY) || \ defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_OPENSSH))) void wolfSSL_ERR_remove_thread_state(void* pid) { (void) pid; return; } #ifndef NO_FILESYSTEM /***TBD ***/ void wolfSSL_print_all_errors_fp(XFILE fp) { (void)fp; } #endif int wolfSSL_SESSION_set_ex_data(WOLFSSL_SESSION* session, int idx, void* data) { WOLFSSL_ENTER("wolfSSL_SESSION_set_ex_data"); #ifdef HAVE_EX_DATA if(session != NULL) { return wolfSSL_CRYPTO_set_ex_data(&session->ex_data, idx, data); } #else (void)session; (void)idx; (void)data; #endif return WOLFSSL_FAILURE; } int wolfSSL_SESSION_get_ex_new_index(long idx, void* data, void* cb1, void* cb2, CRYPTO_free_func* cb3) { WOLFSSL_ENTER("wolfSSL_SESSION_get_ex_new_index"); (void)idx; (void)cb1; (void)cb2; (void)cb3; if (XSTRNCMP((const char*)data, "redirect index", 14) == 0) { return 0; } else if (XSTRNCMP((const char*)data, "addr index", 10) == 0) { return 1; } return WOLFSSL_FAILURE; } void* wolfSSL_SESSION_get_ex_data(const WOLFSSL_SESSION* session, int idx) { WOLFSSL_ENTER("wolfSSL_SESSION_get_ex_data"); #ifdef HAVE_EX_DATA if (session != NULL) { return wolfSSL_CRYPTO_get_ex_data(&session->ex_data, idx); } #else (void)session; (void)idx; #endif return NULL; } #ifndef NO_WOLFSSL_STUB int wolfSSL_CRYPTO_set_mem_ex_functions(void *(*m) (size_t, const char *, int), void *(*r) (void *, size_t, const char *, int), void (*f) (void *)) { (void) m; (void) r; (void) f; WOLFSSL_ENTER("wolfSSL_CRYPTO_set_mem_ex_functions"); WOLFSSL_STUB("CRYPTO_set_mem_ex_functions"); return WOLFSSL_FAILURE; } #endif void wolfSSL_CRYPTO_cleanup_all_ex_data(void){ WOLFSSL_ENTER("CRYPTO_cleanup_all_ex_data"); } #ifndef NO_WOLFSSL_STUB WOLFSSL_DH *wolfSSL_DH_generate_parameters(int prime_len, int generator, void (*callback) (int, int, void *), void *cb_arg) { (void)prime_len; (void)generator; (void)callback; (void)cb_arg; WOLFSSL_ENTER("wolfSSL_DH_generate_parameters"); WOLFSSL_STUB("DH_generate_parameters"); return NULL; } #endif #ifndef NO_WOLFSSL_STUB int wolfSSL_DH_generate_parameters_ex(WOLFSSL_DH* dh, int prime_len, int generator, void (*callback) (int, int, void *)) { (void)prime_len; (void)generator; (void)callback; (void)dh; WOLFSSL_ENTER("wolfSSL_DH_generate_parameters_ex"); WOLFSSL_STUB("DH_generate_parameters_ex"); return -1; } #endif void wolfSSL_ERR_load_crypto_strings(void) { WOLFSSL_ENTER("wolfSSL_ERR_load_crypto_strings"); /* Do nothing */ return; } #ifndef NO_WOLFSSL_STUB int wolfSSL_FIPS_mode(void) { WOLFSSL_ENTER("wolfSSL_FIPS_mode"); WOLFSSL_STUB("FIPS_mode"); return WOLFSSL_FAILURE; } #endif #ifndef NO_WOLFSSL_STUB int wolfSSL_FIPS_mode_set(int r) { (void)r; WOLFSSL_ENTER("wolfSSL_FIPS_mode_set"); WOLFSSL_STUB("FIPS_mode_set"); return WOLFSSL_FAILURE; } #endif #ifndef NO_WOLFSSL_STUB int wolfSSL_RAND_set_rand_method(const void *meth) { (void) meth; WOLFSSL_ENTER("wolfSSL_RAND_set_rand_method"); WOLFSSL_STUB("RAND_set_rand_method"); /* if implemented RAND_bytes and RAND_pseudo_bytes need updated * those two functions will call the respective functions from meth */ return SSL_FAILURE; } #endif int wolfSSL_CIPHER_get_bits(const WOLFSSL_CIPHER *c, int *alg_bits) { int ret = WOLFSSL_FAILURE; WOLFSSL_ENTER("wolfSSL_CIPHER_get_bits"); #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) (void)alg_bits; if (c!= NULL) ret = c->bits; #else if (c != NULL && c->ssl != NULL) { ret = 8 * c->ssl->specs.key_size; if (alg_bits != NULL) { *alg_bits = ret; } } #endif return ret; } #if defined(OPENSSL_ALL) WOLFSSL_X509_INFO* wolfSSL_X509_INFO_new(void) { WOLFSSL_X509_INFO* info; info = (WOLFSSL_X509_INFO*)XMALLOC(sizeof(WOLFSSL_X509_INFO), NULL, DYNAMIC_TYPE_X509); if (info) { XMEMSET(info, 0, sizeof(*info)); } return info; } void wolfSSL_X509_INFO_free(WOLFSSL_X509_INFO* info) { if (info == NULL) return; if (info->x509) { wolfSSL_X509_free(info->x509); info->x509 = NULL; } #ifdef HAVE_CRL if (info->crl) { wolfSSL_X509_CRL_free(info->crl); info->crl = NULL; } #endif wolfSSL_X509_PKEY_free(info->x_pkey); info->x_pkey = NULL; XFREE(info, NULL, DYNAMIC_TYPE_X509); } #endif WOLFSSL_STACK* wolfSSL_sk_X509_INFO_new_null(void) { WOLFSSL_STACK* sk = wolfSSL_sk_new_node(NULL); if (sk) { sk->type = STACK_TYPE_X509_INFO; } return sk; } /* returns value less than 0 on fail to match * On a successful match the priority level found is returned */ int wolfSSL_sk_SSL_CIPHER_find( WOLF_STACK_OF(WOLFSSL_CIPHER)* sk, const WOLFSSL_CIPHER* toFind) { WOLFSSL_STACK* next; int i, sz; if (sk == NULL || toFind == NULL) { return WOLFSSL_FATAL_ERROR; } sz = wolfSSL_sk_SSL_CIPHER_num(sk); next = sk; for (i = 0; i < sz && next != NULL; i++) { if (next->data.cipher.cipherSuite0 == toFind->cipherSuite0 && next->data.cipher.cipherSuite == toFind->cipherSuite) { return sz - i; /* reverse because stack pushed highest on first */ } next = next->next; } return WOLFSSL_FATAL_ERROR; } /* copies over data of "in" to "out" */ static void wolfSSL_CIPHER_copy(WOLFSSL_CIPHER* in, WOLFSSL_CIPHER* out) { if (in == NULL || out == NULL) return; out->cipherSuite = in->cipherSuite; out->cipherSuite0 = in->cipherSuite0; } /* create duplicate of stack and return the new stack * returns null on failure */ WOLF_STACK_OF(WOLFSSL_CIPHER)* wolfSSL_sk_SSL_CIPHER_dup( WOLF_STACK_OF(WOLFSSL_CIPHER)* in) { WOLFSSL_STACK* current; WOLF_STACK_OF(WOLFSSL_CIPHER)* ret = NULL; int i, sz; sz = wolfSSL_sk_SSL_CIPHER_num(in); current = in; for (i = 0; i < sz && current != NULL; i++) { WOLFSSL_STACK* add = wolfSSL_sk_new_node(in->heap); if (add != NULL) { add->type = STACK_TYPE_CIPHER; wolfSSL_CIPHER_copy(&(current->data.cipher), &(add->data.cipher)); add->num = i+1; add->next = ret; ret = add; current = current->next; } } return ret; } /* nothing to do yet */ static void wolfSSL_CIPHER_free(WOLFSSL_CIPHER* in) { (void)in; } /* free's all nodes in the stack and there data */ void wolfSSL_sk_SSL_CIPHER_free(WOLF_STACK_OF(WOLFSSL_CIPHER)* sk) { WOLFSSL_STACK* current = sk; while (current != NULL) { WOLFSSL_STACK* toFree = current; current = current->next; wolfSSL_CIPHER_free(&(toFree->data.cipher)); wolfSSL_sk_free_node(toFree); } } int wolfSSL_sk_X509_INFO_num(const WOLF_STACK_OF(WOLFSSL_X509_INFO) *sk) { WOLFSSL_ENTER("wolfSSL_sk_X509_INFO_num"); if (sk == NULL) return -1; return (int)sk->num; } WOLFSSL_X509_INFO* wolfSSL_sk_X509_INFO_value(const WOLF_STACK_OF(WOLFSSL_X509_INFO) *sk, int i) { WOLFSSL_ENTER("wolfSSL_sk_X509_INFO_value"); for (; sk != NULL && i > 0; i--) sk = sk->next; if (i != 0 || sk == NULL) return NULL; return sk->data.info; } WOLFSSL_X509_INFO* wolfSSL_sk_X509_INFO_pop(WOLF_STACK_OF(WOLFSSL_X509_INFO)* sk) { WOLFSSL_STACK* node; WOLFSSL_X509_INFO* info; if (sk == NULL) { return NULL; } node = sk->next; info = sk->data.info; if (node != NULL) { /* update sk and remove node from stack */ sk->data.info = node->data.info; sk->next = node->next; XFREE(node, NULL, DYNAMIC_TYPE_OPENSSL); } else { /* last x509 in stack */ sk->data.info = NULL; } if (sk->num > 0) { sk->num -= 1; } return info; } #if defined(OPENSSL_ALL) void wolfSSL_sk_X509_INFO_pop_free(WOLF_STACK_OF(WOLFSSL_X509_INFO)* sk, void (*f) (WOLFSSL_X509_INFO*)) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_X509_INFO_pop_free"); if (sk == NULL) { return; } /* parse through stack freeing each node */ node = sk->next; while (node && sk->num > 1) { WOLFSSL_STACK* tmp = node; node = node->next; if (f) f(tmp->data.info); else wolfSSL_X509_INFO_free(tmp->data.info); tmp->data.info = NULL; XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL); sk->num -= 1; } /* free head of stack */ if (sk->num == 1) { if (f) f(sk->data.info); else wolfSSL_X509_INFO_free(sk->data.info); sk->data.info = NULL; } XFREE(sk, NULL, DYNAMIC_TYPE_OPENSSL); } void wolfSSL_sk_X509_INFO_free(WOLF_STACK_OF(WOLFSSL_X509_INFO) *sk) { wolfSSL_sk_X509_INFO_pop_free(sk, NULL); } /* Adds the WOLFSSL_X509_INFO to the stack "sk". "sk" takes control of "in" and * tries to free it when the stack is free'd. * * return 1 on success 0 on fail */ int wolfSSL_sk_X509_INFO_push(WOLF_STACK_OF(WOLFSSL_X509_INFO)* sk, WOLFSSL_X509_INFO* in) { WOLFSSL_STACK* node; if (sk == NULL || in == NULL) { return WOLFSSL_FAILURE; } /* no previous values in stack */ if (sk->data.info == NULL) { sk->data.info = in; sk->num += 1; return WOLFSSL_SUCCESS; } /* stack already has value(s) create a new node and add more */ node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_X509); if (node == NULL) { WOLFSSL_MSG("Memory error"); return WOLFSSL_FAILURE; } XMEMSET(node, 0, sizeof(WOLFSSL_STACK)); /* push new obj onto head of stack */ node->data.info = sk->data.info; node->next = sk->next; node->type = sk->type; sk->next = node; sk->data.info = in; sk->num += 1; return WOLFSSL_SUCCESS; } WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_sk_X509_NAME_new(wolf_sk_compare_cb cb) { WOLFSSL_STACK* sk; WOLFSSL_ENTER("wolfSSL_sk_X509_NAME_new"); sk = wolfSSL_sk_new_node(NULL); if (sk != NULL) { sk->type = STACK_TYPE_X509_NAME; sk->comp = cb; } return sk; } int wolfSSL_sk_X509_NAME_push(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk, WOLFSSL_X509_NAME* name) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_X509_NAME_push"); if (sk == NULL || name == NULL) { return BAD_FUNC_ARG; } /* no previous values in stack */ if (sk->data.name == NULL) { sk->data.name = name; sk->num += 1; return 0; } /* stack already has value(s) create a new node and add more */ node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_OPENSSL); if (node == NULL) { WOLFSSL_MSG("Memory error"); return MEMORY_E; } XMEMSET(node, 0, sizeof(WOLFSSL_STACK)); /* push new obj onto head of stack */ node->data.name = sk->data.name; node->next = sk->next; sk->type = STACK_TYPE_X509_NAME; sk->next = node; sk->data.name = name; sk->num += 1; return 0; } /* return index of found, or negative to indicate not found */ int wolfSSL_sk_X509_NAME_find(const WOLF_STACK_OF(WOLFSSL_X509_NAME) *sk, WOLFSSL_X509_NAME *name) { int i; WOLFSSL_ENTER("wolfSSL_sk_X509_NAME_find"); if (sk == NULL) return BAD_FUNC_ARG; for (i = 0; sk; i++, sk = sk->next) { if (wolfSSL_X509_NAME_cmp(sk->data.name, name) == 0) { return i; } } return -1; } int wolfSSL_sk_X509_OBJECT_num(const WOLF_STACK_OF(WOLFSSL_X509_OBJECT) *s) { WOLFSSL_ENTER("wolfSSL_sk_X509_OBJECT_num"); if (s) { return (int)s->num; } else { return 0; } } int wolfSSL_sk_X509_NAME_set_cmp_func(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk, wolf_sk_compare_cb cb) { WOLFSSL_ENTER("wolfSSL_sk_X509_NAME_set_cmp_func"); if (sk == NULL) return BAD_FUNC_ARG; sk->comp = cb; return 0; } #endif /* OPENSSL_ALL */ int wolfSSL_sk_X509_NAME_num(const WOLF_STACK_OF(WOLFSSL_X509_NAME) *sk) { WOLFSSL_ENTER("wolfSSL_sk_X509_NAME_num"); if (sk == NULL) return BAD_FUNC_ARG; return (int)sk->num; } /* Getter function for WOLFSSL_X509_NAME pointer * * sk is the stack to retrieve pointer from * i is the index value in stack * * returns a pointer to a WOLFSSL_X509_NAME structure on success and NULL on * fail */ WOLFSSL_X509_NAME* wolfSSL_sk_X509_NAME_value(const STACK_OF(WOLFSSL_X509_NAME)* sk, int i) { WOLFSSL_ENTER("wolfSSL_sk_X509_NAME_value"); for (; sk != NULL && i > 0; i--) { sk = sk->next; } if (i != 0 || sk == NULL) return NULL; return sk->data.name; } WOLFSSL_X509_NAME* wolfSSL_sk_X509_NAME_pop(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk) { WOLFSSL_STACK* node; WOLFSSL_X509_NAME* name; if (sk == NULL) { return NULL; } node = sk->next; name = sk->data.name; if (node != NULL) { /* update sk and remove node from stack */ sk->data.name = node->data.name; sk->next = node->next; XFREE(node, NULL, DYNAMIC_TYPE_OPENSSL); } else { /* last x509 in stack */ sk->data.name = NULL; } if (sk->num > 0) { sk->num -= 1; } return name; } void wolfSSL_sk_X509_NAME_pop_free(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk, void (*f) (WOLFSSL_X509_NAME*)) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_X509_NAME_pop_free"); if (sk == NULL) return; node = sk->next; while (node && sk->num > 1) { WOLFSSL_STACK* tmp = node; node = node->next; if (f) f(tmp->data.name); else wolfSSL_X509_NAME_free(tmp->data.name); tmp->data.name = NULL; XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL); sk->num -= 1; } /* free head of stack */ if (sk->num == 1) { if (f) f(sk->data.name); else wolfSSL_X509_NAME_free(sk->data.name); sk->data.name = NULL; } XFREE(sk, sk->heap, DYNAMIC_TYPE_OPENSSL); } /* Free only the sk structure, NOT X509_NAME members */ void wolfSSL_sk_X509_NAME_free(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk) { WOLFSSL_STACK* node; WOLFSSL_ENTER("wolfSSL_sk_X509_NAME_free"); if (sk == NULL) return; node = sk->next; while (sk->num > 1) { WOLFSSL_STACK* tmp = node; node = node->next; XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL); sk->num -= 1; } XFREE(sk, sk->heap, DYNAMIC_TYPE_OPENSSL); } #if defined(WOLFSSL_APACHE_HTTPD) || defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) /* Helper function for X509_NAME_print_ex. Sets *buf to string for domain name attribute based on NID. Returns size of buf */ static int get_dn_attr_by_nid(int n, const char** buf) { int len = 0; const char *str; switch(n) { case NID_commonName : str = "CN"; len = 2; break; case NID_countryName: str = "C"; len = 1; break; case NID_localityName: str = "L"; len = 1; break; case NID_stateOrProvinceName: str = "ST"; len = 2; break; case NID_organizationName: str = "O"; len = 1; break; case NID_organizationalUnitName: str = "OU"; len = 2; break; case NID_emailAddress: str = "emailAddress"; len = 12; break; default: WOLFSSL_MSG("Attribute type not found"); str = NULL; } if (buf != NULL) *buf = str; return len; } #endif /* * The BIO output of wolfSSL_X509_NAME_print_ex does NOT include the null terminator */ int wolfSSL_X509_NAME_print_ex(WOLFSSL_BIO* bio, WOLFSSL_X509_NAME* name, int indent, unsigned long flags) { #if defined(WOLFSSL_APACHE_HTTPD) || defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) int count = 0, len = 0, totalSz = 0, tmpSz = 0; char tmp[ASN_NAME_MAX]; char fullName[ASN_NAME_MAX]; const char *buf = NULL; WOLFSSL_X509_NAME_ENTRY* ne; WOLFSSL_ASN1_STRING* str; #endif int i; (void)flags; WOLFSSL_ENTER("wolfSSL_X509_NAME_print_ex"); for (i = 0; i < indent; i++) { if (wolfSSL_BIO_write(bio, " ", 1) != 1) return WOLFSSL_FAILURE; } #if defined(WOLFSSL_APACHE_HTTPD) || defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) /* If XN_FLAG_DN_REV is present, print X509_NAME in reverse order */ if (flags == (XN_FLAG_RFC2253 & ~XN_FLAG_DN_REV)) { fullName[0] = '\0'; count = wolfSSL_X509_NAME_entry_count(name); for (i = 0; i < count; i++) { ne = wolfSSL_X509_NAME_get_entry(name, count - i - 1); if (ne == NULL) return WOLFSSL_FAILURE; str = wolfSSL_X509_NAME_ENTRY_get_data(ne); if (str == NULL) return WOLFSSL_FAILURE; len = get_dn_attr_by_nid(ne->nid, &buf); if (len == 0 || buf == NULL) return WOLFSSL_FAILURE; tmpSz = str->length + len + 2; /* + 2 for '=' and comma */ if (tmpSz > ASN_NAME_MAX) { WOLFSSL_MSG("Size greater than ASN_NAME_MAX"); return WOLFSSL_FAILURE; } if (i < count - 1) { /* tmpSz+1 for last null char */ XSNPRINTF(tmp, tmpSz+1, "%s=%s,", buf, str->data); XSTRNCAT(fullName, tmp, tmpSz); } else { XSNPRINTF(tmp, tmpSz, "%s=%s", buf, str->data); XSTRNCAT(fullName, tmp, tmpSz-1); tmpSz--; /* Don't include null char in tmpSz */ } totalSz += tmpSz; } if (wolfSSL_BIO_write(bio, fullName, totalSz) != totalSz) return WOLFSSL_FAILURE; return WOLFSSL_SUCCESS; } #else if (flags == XN_FLAG_RFC2253) { if (wolfSSL_BIO_write(bio, name->name + 1, name->sz - 2) != name->sz - 2) return WOLFSSL_FAILURE; } #endif /* WOLFSSL_APACHE_HTTPD || OPENSSL_ALL || WOLFSSL_NGINX */ else if (wolfSSL_BIO_write(bio, name->name, name->sz - 1) != name->sz - 1) return WOLFSSL_FAILURE; return WOLFSSL_SUCCESS; } #ifndef NO_WOLFSSL_STUB WOLFSSL_ASN1_BIT_STRING* wolfSSL_X509_get0_pubkey_bitstr(const WOLFSSL_X509* x) { (void)x; WOLFSSL_ENTER("wolfSSL_X509_get0_pubkey_bitstr"); WOLFSSL_STUB("X509_get0_pubkey_bitstr"); return NULL; } #endif #ifndef NO_WOLFSSL_STUB int wolfSSL_CTX_add_session(WOLFSSL_CTX* ctx, WOLFSSL_SESSION* session) { (void)ctx; (void)session; WOLFSSL_ENTER("wolfSSL_CTX_add_session"); WOLFSSL_STUB("SSL_CTX_add_session"); return WOLFSSL_SUCCESS; } #endif int wolfSSL_version(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_version"); if (ssl->version.major == SSLv3_MAJOR) { switch (ssl->version.minor) { case SSLv3_MINOR : return SSL3_VERSION; case TLSv1_MINOR : return TLS1_VERSION; case TLSv1_1_MINOR : return TLS1_1_VERSION; case TLSv1_2_MINOR : return TLS1_2_VERSION; case TLSv1_3_MINOR : return TLS1_3_VERSION; default: return WOLFSSL_FAILURE; } } else if (ssl->version.major == DTLS_MAJOR) { switch (ssl->version.minor) { case DTLS_MINOR : return DTLS1_VERSION; case DTLSv1_2_MINOR : return DTLS1_2_VERSION; default: return WOLFSSL_FAILURE; } } return WOLFSSL_FAILURE; } int wolfSSL_X509_NAME_get_sz(WOLFSSL_X509_NAME* name) { WOLFSSL_ENTER("wolfSSL_X509_NAME_get_sz"); if(!name) return -1; return name->sz; } #ifdef HAVE_SNI int wolfSSL_set_tlsext_host_name(WOLFSSL* ssl, const char* host_name) { int ret; WOLFSSL_ENTER("wolfSSL_set_tlsext_host_name"); ret = wolfSSL_UseSNI(ssl, WOLFSSL_SNI_HOST_NAME, host_name, (word16)XSTRLEN(host_name)); WOLFSSL_LEAVE("wolfSSL_set_tlsext_host_name", ret); return ret; } #ifndef NO_WOLFSSL_SERVER const char * wolfSSL_get_servername(WOLFSSL* ssl, byte type) { void * serverName = NULL; if (ssl == NULL) return NULL; TLSX_SNI_GetRequest(ssl->extensions, type, &serverName); return (const char *)serverName; } #endif /* NO_WOLFSSL_SERVER */ #endif /* HAVE_SNI */ WOLFSSL_CTX* wolfSSL_set_SSL_CTX(WOLFSSL* ssl, WOLFSSL_CTX* ctx) { if (ssl && ctx && SetSSL_CTX(ssl, ctx, 0) == WOLFSSL_SUCCESS) return ssl->ctx; return NULL; } VerifyCallback wolfSSL_CTX_get_verify_callback(WOLFSSL_CTX* ctx) { WOLFSSL_ENTER("wolfSSL_CTX_get_verify_callback"); if(ctx) return ctx->verifyCallback; return NULL; } void wolfSSL_CTX_set_servername_callback(WOLFSSL_CTX* ctx, CallbackSniRecv cb) { WOLFSSL_ENTER("wolfSSL_CTX_set_servername_callback"); if (ctx) ctx->sniRecvCb = cb; } int wolfSSL_CTX_set_tlsext_servername_callback(WOLFSSL_CTX* ctx, CallbackSniRecv cb) { WOLFSSL_ENTER("wolfSSL_CTX_set_tlsext_servername_callback"); if (ctx) { ctx->sniRecvCb = cb; return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } int wolfSSL_CTX_set_servername_arg(WOLFSSL_CTX* ctx, void* arg) { WOLFSSL_ENTER("wolfSSL_CTX_set_servername_arg"); if (ctx) { ctx->sniRecvCbArg = arg; return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } void wolfSSL_ERR_load_BIO_strings(void) { WOLFSSL_ENTER("ERR_load_BIO_strings"); /* do nothing */ } #ifndef NO_WOLFSSL_STUB void wolfSSL_THREADID_set_callback(void(*threadid_func)(void*)) { WOLFSSL_ENTER("wolfSSL_THREADID_set_callback"); WOLFSSL_STUB("CRYPTO_THREADID_set_callback"); (void)threadid_func; return; } #endif #ifndef NO_WOLFSSL_STUB void wolfSSL_THREADID_set_numeric(void* id, unsigned long val) { WOLFSSL_ENTER("wolfSSL_THREADID_set_numeric"); WOLFSSL_STUB("CRYPTO_THREADID_set_numeric"); (void)id; (void)val; return; } #endif #ifndef NO_WOLFSSL_STUB WOLF_STACK_OF(WOLFSSL_X509)* wolfSSL_X509_STORE_get1_certs( WOLFSSL_X509_STORE_CTX* ctx, WOLFSSL_X509_NAME* name) { WOLFSSL_ENTER("wolfSSL_X509_STORE_get1_certs"); WOLFSSL_STUB("X509_STORE_get1_certs"); (void)ctx; (void)name; return NULL; } WOLF_STACK_OF(WOLFSSL_X509_OBJECT)* wolfSSL_X509_STORE_get0_objects( WOLFSSL_X509_STORE* store) { WOLFSSL_ENTER("wolfSSL_X509_STORE_get0_objects"); WOLFSSL_STUB("wolfSSL_X509_STORE_get0_objects"); (void)store; return NULL; } WOLFSSL_X509_OBJECT* wolfSSL_sk_X509_OBJECT_delete( WOLF_STACK_OF(WOLFSSL_X509_OBJECT)* sk, int i) { WOLFSSL_ENTER("wolfSSL_sk_X509_OBJECT_delete"); WOLFSSL_STUB("wolfSSL_sk_X509_OBJECT_delete"); (void)sk; (void)i; return NULL; } void wolfSSL_X509_OBJECT_free(WOLFSSL_X509_OBJECT *a) { WOLFSSL_ENTER("wolfSSL_X509_OBJECT_free"); WOLFSSL_STUB("wolfSSL_X509_OBJECT_free"); (void)a; } #endif #endif /* OPENSSL_ALL || (OPENSSL_EXTRA && (HAVE_STUNNEL || WOLFSSL_NGINX || HAVE_LIGHTY)) */ #if defined(OPENSSL_EXTRA) int wolfSSL_sk_X509_num(const WOLF_STACK_OF(WOLFSSL_X509) *s) { WOLFSSL_ENTER("wolfSSL_sk_X509_num"); if (s == NULL) return -1; return (int)s->num; } unsigned long wolfSSL_ERR_peek_last_error(void) { WOLFSSL_ENTER("wolfSSL_ERR_peek_last_error"); #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_NGINX) { int ret; if ((ret = wc_PeekErrorNode(-1, NULL, NULL, NULL)) < 0) { WOLFSSL_MSG("Issue peeking at error node in queue"); return 0; } if (ret == -ASN_NO_PEM_HEADER) return (ERR_LIB_PEM << 24) | PEM_R_NO_START_LINE; return (unsigned long)ret; } #else return (unsigned long)(0 - NOT_COMPILED_IN); #endif } #endif /* OPENSSL_EXTRA */ WOLFSSL_CTX* wolfSSL_get_SSL_CTX(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_SSL_CTX"); return ssl->ctx; } #if defined(OPENSSL_ALL) || \ defined(OPENSSL_EXTRA) || defined(HAVE_STUNNEL) || \ defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) const byte* wolfSSL_SESSION_get_id(WOLFSSL_SESSION* sess, unsigned int* idLen) { WOLFSSL_ENTER("wolfSSL_SESSION_get_id"); if(!sess || !idLen) { WOLFSSL_MSG("Bad func args. Please provide idLen"); return NULL; } *idLen = sess->sessionIDSz; return sess->sessionID; } #if (defined(HAVE_SESSION_TICKET) || defined(SESSION_CERTS)) && \ !defined(NO_FILESYSTEM) #if defined(SESSION_CERTS) || \ (defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)) /* returns a pointer to the protocol used by the session */ static const char* wolfSSL_SESSION_get_protocol(const WOLFSSL_SESSION* in) { return wolfSSL_internal_get_version((ProtocolVersion*)&in->version); } #endif /* returns true (non 0) if the session has EMS (extended master secret) */ static int wolfSSL_SESSION_haveEMS(const WOLFSSL_SESSION* in) { if (in == NULL) return 0; return in->haveEMS; } #if defined(HAVE_SESSION_TICKET) /* prints out the ticket to bio passed in * return WOLFSSL_SUCCESS on success */ static int wolfSSL_SESSION_print_ticket(WOLFSSL_BIO* bio, const WOLFSSL_SESSION* in, const char* tab) { unsigned short i, j, z, sz; short tag = 0; byte* pt; if (in == NULL || bio == NULL) { return BAD_FUNC_ARG; } sz = in->ticketLen; pt = in->ticket; if (wolfSSL_BIO_printf(bio, "%s\n", (sz == 0)? " NONE": "") <= 0) return WOLFSSL_FAILURE; for (i = 0; i < sz;) { char asc[16]; if (sz - i < 16) { if (wolfSSL_BIO_printf(bio, "%s%04X -", tab, tag + (sz - i)) <= 0) return WOLFSSL_FAILURE; } else { if (wolfSSL_BIO_printf(bio, "%s%04X -", tab, tag) <= 0) return WOLFSSL_FAILURE; } for (j = 0; i < sz && j < 8; j++,i++) { asc[j] = ((pt[i])&0x6f)>='A'?((pt[i])&0x6f):'.'; if (wolfSSL_BIO_printf(bio, " %02X", pt[i]) <= 0) return WOLFSSL_FAILURE; } if (i < sz) { asc[j] = ((pt[i])&0x6f)>='A'?((pt[i])&0x6f):'.'; if (wolfSSL_BIO_printf(bio, "-%02X", pt[i]) <= 0) return WOLFSSL_FAILURE; j++; i++; } for (; i < sz && j < 16; j++,i++) { asc[j] = ((pt[i])&0x6f)>='A'?((pt[i])&0x6f):'.'; if (wolfSSL_BIO_printf(bio, " %02X", pt[i]) <= 0) return WOLFSSL_FAILURE; } /* pad out spacing */ for (z = j; z < 17; z++) { if (wolfSSL_BIO_printf(bio, " ") <= 0) return WOLFSSL_FAILURE; } for (z = 0; z < j; z++) { if (wolfSSL_BIO_printf(bio, "%c", asc[z]) <= 0) return WOLFSSL_FAILURE; } if (wolfSSL_BIO_printf(bio, "\n") <= 0) return WOLFSSL_FAILURE; tag += 16; } return WOLFSSL_SUCCESS; } #endif /* HAVE_SESSION_TICKET */ /* prints out the session information in human readable form * return WOLFSSL_SUCCESS on success */ int wolfSSL_SESSION_print(WOLFSSL_BIO *bp, const WOLFSSL_SESSION *x) { const unsigned char* pt; unsigned char buf[SECRET_LEN]; unsigned int sz = 0, i; int ret; WOLFSSL_SESSION* session = (WOLFSSL_SESSION*)x; if (session == NULL) { WOLFSSL_MSG("Bad NULL argument"); return WOLFSSL_FAILURE; } if (wolfSSL_BIO_printf(bp, "%s\n", "SSL-Session:") <= 0) return WOLFSSL_FAILURE; #if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \ defined(HAVE_SESSION_TICKET)) if (wolfSSL_BIO_printf(bp, " Protocol : %s\n", wolfSSL_SESSION_get_protocol(session)) <= 0) return WOLFSSL_FAILURE; #endif if (wolfSSL_BIO_printf(bp, " Cipher : %s\n", wolfSSL_SESSION_CIPHER_get_name(session)) <= 0) return WOLFSSL_FAILURE; pt = wolfSSL_SESSION_get_id(session, &sz); if (wolfSSL_BIO_printf(bp, " Session-ID: ") <= 0) return WOLFSSL_FAILURE; for (i = 0; i < sz; i++) { if (wolfSSL_BIO_printf(bp, "%02X", pt[i]) <= 0) return WOLFSSL_FAILURE; } if (wolfSSL_BIO_printf(bp, "\n") <= 0) return WOLFSSL_FAILURE; if (wolfSSL_BIO_printf(bp, " Session-ID-ctx: \n") <= 0) return WOLFSSL_FAILURE; ret = wolfSSL_SESSION_get_master_key(x, buf, sizeof(buf)); if (wolfSSL_BIO_printf(bp, " Master-Key: ") <= 0) return WOLFSSL_FAILURE; if (ret > 0) { sz = (unsigned int)ret; for (i = 0; i < sz; i++) { if (wolfSSL_BIO_printf(bp, "%02X", buf[i]) <= 0) return WOLFSSL_FAILURE; } } if (wolfSSL_BIO_printf(bp, "\n") <= 0) return WOLFSSL_FAILURE; /* @TODO PSK identity hint and SRP */ if (wolfSSL_BIO_printf(bp, " TLS session ticket:") <= 0) return WOLFSSL_FAILURE; #ifdef HAVE_SESSION_TICKET if (wolfSSL_SESSION_print_ticket(bp, x, " ") != WOLFSSL_SUCCESS) return WOLFSSL_FAILURE; #endif if (wolfSSL_BIO_printf(bp, " Start Time: %ld\n", wolfSSL_SESSION_get_time(x)) <= 0) return WOLFSSL_FAILURE; if (wolfSSL_BIO_printf(bp, " Timeout : %ld (sec)\n", wolfSSL_SESSION_get_timeout(x)) <= 0) return WOLFSSL_FAILURE; /* @TODO verify return code print */ if (wolfSSL_BIO_printf(bp, " Extended master secret: %s\n", (wolfSSL_SESSION_haveEMS(session) == 0)? "no" : "yes") <= 0) return WOLFSSL_FAILURE; return WOLFSSL_SUCCESS; } #endif /* (HAVE_SESSION_TICKET || SESSION_CERTS) && !NO_FILESYSTEM */ #endif /* OPENSSL_ALL || OPENSSL_EXTRA || HAVE_STUNNEL || WOLFSSL_NGINX || WOLFSSL_HAPROXY */ #if defined(OPENSSL_ALL) || (defined(OPENSSL_EXTRA) && defined(HAVE_STUNNEL)) \ || defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(WOLFSSL_NGINX) int wolfSSL_CTX_get_verify_mode(WOLFSSL_CTX* ctx) { int mode = 0; WOLFSSL_ENTER("wolfSSL_CTX_get_verify_mode"); if(!ctx) return WOLFSSL_FATAL_ERROR; if (ctx->verifyPeer) mode |= WOLFSSL_VERIFY_PEER; else if (ctx->verifyNone) mode |= WOLFSSL_VERIFY_NONE; if (ctx->failNoCert) mode |= WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT; if (ctx->failNoCertxPSK) mode |= WOLFSSL_VERIFY_FAIL_EXCEPT_PSK; WOLFSSL_LEAVE("wolfSSL_CTX_get_verify_mode", mode); return mode; } #endif #if defined(OPENSSL_EXTRA) && defined(HAVE_CURVE25519) /* return 1 if success, 0 if error * output keys are little endian format */ int wolfSSL_EC25519_generate_key(unsigned char *priv, unsigned int *privSz, unsigned char *pub, unsigned int *pubSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) priv; (void) privSz; (void) pub; (void) pubSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ int ret = WOLFSSL_FAILURE; int initTmpRng = 0; WC_RNG *rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG *tmpRNG = NULL; #else WC_RNG tmpRNG[1]; #endif WOLFSSL_ENTER("wolfSSL_EC25519_generate_key"); if (priv == NULL || privSz == NULL || *privSz < CURVE25519_KEYSIZE || pub == NULL || pubSz == NULL || *pubSz < CURVE25519_KEYSIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return WOLFSSL_FAILURE; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng) { curve25519_key key; if (wc_curve25519_init(&key) != MP_OKAY) WOLFSSL_MSG("wc_curve25519_init failed"); else if (wc_curve25519_make_key(rng, CURVE25519_KEYSIZE, &key)!=MP_OKAY) WOLFSSL_MSG("wc_curve25519_make_key failed"); /* export key pair */ else if (wc_curve25519_export_key_raw_ex(&key, priv, privSz, pub, pubSz, EC25519_LITTLE_ENDIAN) != MP_OKAY) WOLFSSL_MSG("wc_curve25519_export_key_raw_ex failed"); else ret = WOLFSSL_SUCCESS; wc_curve25519_free(&key); } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return ret; #endif /* WOLFSSL_KEY_GEN */ } /* return 1 if success, 0 if error * input and output keys are little endian format */ int wolfSSL_EC25519_shared_key(unsigned char *shared, unsigned int *sharedSz, const unsigned char *priv, unsigned int privSz, const unsigned char *pub, unsigned int pubSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) shared; (void) sharedSz; (void) priv; (void) privSz; (void) pub; (void) pubSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ int ret = WOLFSSL_FAILURE; curve25519_key privkey, pubkey; WOLFSSL_ENTER("wolfSSL_EC25519_shared_key"); if (shared == NULL || sharedSz == NULL || *sharedSz < CURVE25519_KEYSIZE || priv == NULL || privSz < CURVE25519_KEYSIZE || pub == NULL || pubSz < CURVE25519_KEYSIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } /* import private key */ if (wc_curve25519_init(&privkey) != MP_OKAY) { WOLFSSL_MSG("wc_curve25519_init privkey failed"); return ret; } if (wc_curve25519_import_private_ex(priv, privSz, &privkey, EC25519_LITTLE_ENDIAN) != MP_OKAY) { WOLFSSL_MSG("wc_curve25519_import_private_ex failed"); wc_curve25519_free(&privkey); return ret; } /* import public key */ if (wc_curve25519_init(&pubkey) != MP_OKAY) { WOLFSSL_MSG("wc_curve25519_init pubkey failed"); wc_curve25519_free(&privkey); return ret; } if (wc_curve25519_import_public_ex(pub, pubSz, &pubkey, EC25519_LITTLE_ENDIAN) != MP_OKAY) { WOLFSSL_MSG("wc_curve25519_import_public_ex failed"); wc_curve25519_free(&privkey); wc_curve25519_free(&pubkey); return ret; } if (wc_curve25519_shared_secret_ex(&privkey, &pubkey, shared, sharedSz, EC25519_LITTLE_ENDIAN) != MP_OKAY) WOLFSSL_MSG("wc_curve25519_shared_secret_ex failed"); else ret = WOLFSSL_SUCCESS; wc_curve25519_free(&privkey); wc_curve25519_free(&pubkey); return ret; #endif /* WOLFSSL_KEY_GEN */ } #endif /* OPENSSL_EXTRA && HAVE_CURVE25519 */ #if defined(OPENSSL_EXTRA) && defined(HAVE_ED25519) /* return 1 if success, 0 if error * output keys are little endian format */ int wolfSSL_ED25519_generate_key(unsigned char *priv, unsigned int *privSz, unsigned char *pub, unsigned int *pubSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) priv; (void) privSz; (void) pub; (void) pubSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ int ret = WOLFSSL_FAILURE; int initTmpRng = 0; WC_RNG *rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG *tmpRNG = NULL; #else WC_RNG tmpRNG[1]; #endif WOLFSSL_ENTER("wolfSSL_ED25519_generate_key"); if (priv == NULL || privSz == NULL || *privSz < ED25519_PRV_KEY_SIZE || pub == NULL || pubSz == NULL || *pubSz < ED25519_PUB_KEY_SIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return WOLFSSL_FATAL_ERROR; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng) { ed25519_key key; if (wc_ed25519_init(&key) != MP_OKAY) WOLFSSL_MSG("wc_ed25519_init failed"); else if (wc_ed25519_make_key(rng, ED25519_KEY_SIZE, &key)!=MP_OKAY) WOLFSSL_MSG("wc_ed25519_make_key failed"); /* export private key */ else if (wc_ed25519_export_key(&key, priv, privSz, pub, pubSz)!=MP_OKAY) WOLFSSL_MSG("wc_ed25519_export_key failed"); else ret = WOLFSSL_SUCCESS; wc_ed25519_free(&key); } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return ret; #endif /* WOLFSSL_KEY_GEN */ } /* return 1 if success, 0 if error * input and output keys are little endian format * priv is a buffer containing private and public part of key */ int wolfSSL_ED25519_sign(const unsigned char *msg, unsigned int msgSz, const unsigned char *priv, unsigned int privSz, unsigned char *sig, unsigned int *sigSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) msg; (void) msgSz; (void) priv; (void) privSz; (void) sig; (void) sigSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ ed25519_key key; int ret = WOLFSSL_FAILURE; WOLFSSL_ENTER("wolfSSL_ED25519_sign"); if (priv == NULL || privSz != ED25519_PRV_KEY_SIZE || msg == NULL || sig == NULL || *sigSz < ED25519_SIG_SIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } /* import key */ if (wc_ed25519_init(&key) != MP_OKAY) { WOLFSSL_MSG("wc_curve25519_init failed"); return ret; } if (wc_ed25519_import_private_key(priv, privSz/2, priv+(privSz/2), ED25519_PUB_KEY_SIZE, &key) != MP_OKAY){ WOLFSSL_MSG("wc_ed25519_import_private failed"); wc_ed25519_free(&key); return ret; } if (wc_ed25519_sign_msg(msg, msgSz, sig, sigSz, &key) != MP_OKAY) WOLFSSL_MSG("wc_curve25519_shared_secret_ex failed"); else ret = WOLFSSL_SUCCESS; wc_ed25519_free(&key); return ret; #endif /* WOLFSSL_KEY_GEN */ } /* return 1 if success, 0 if error * input and output keys are little endian format * pub is a buffer containing public part of key */ int wolfSSL_ED25519_verify(const unsigned char *msg, unsigned int msgSz, const unsigned char *pub, unsigned int pubSz, const unsigned char *sig, unsigned int sigSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) msg; (void) msgSz; (void) pub; (void) pubSz; (void) sig; (void) sigSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ ed25519_key key; int ret = WOLFSSL_FAILURE, check = 0; WOLFSSL_ENTER("wolfSSL_ED25519_verify"); if (pub == NULL || pubSz != ED25519_PUB_KEY_SIZE || msg == NULL || sig == NULL || sigSz != ED25519_SIG_SIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } /* import key */ if (wc_ed25519_init(&key) != MP_OKAY) { WOLFSSL_MSG("wc_curve25519_init failed"); return ret; } if (wc_ed25519_import_public(pub, pubSz, &key) != MP_OKAY){ WOLFSSL_MSG("wc_ed25519_import_public failed"); wc_ed25519_free(&key); return ret; } if ((ret = wc_ed25519_verify_msg((byte*)sig, sigSz, msg, msgSz, &check, &key)) != MP_OKAY) { WOLFSSL_MSG("wc_ed25519_verify_msg failed"); } else if (!check) WOLFSSL_MSG("wc_ed25519_verify_msg failed (signature invalid)"); else ret = WOLFSSL_SUCCESS; wc_ed25519_free(&key); return ret; #endif /* WOLFSSL_KEY_GEN */ } #endif /* OPENSSL_EXTRA && HAVE_ED25519 */ #if defined(OPENSSL_EXTRA) && defined(HAVE_CURVE448) /* return 1 if success, 0 if error * output keys are little endian format */ int wolfSSL_EC448_generate_key(unsigned char *priv, unsigned int *privSz, unsigned char *pub, unsigned int *pubSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) priv; (void) privSz; (void) pub; (void) pubSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ int ret = WOLFSSL_FAILURE; int initTmpRng = 0; WC_RNG *rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG *tmpRNG = NULL; #else WC_RNG tmpRNG[1]; #endif WOLFSSL_ENTER("wolfSSL_EC448_generate_key"); if (priv == NULL || privSz == NULL || *privSz < CURVE448_KEY_SIZE || pub == NULL || pubSz == NULL || *pubSz < CURVE448_KEY_SIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return WOLFSSL_FAILURE; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng) { curve448_key key; if (wc_curve448_init(&key) != MP_OKAY) WOLFSSL_MSG("wc_curve448_init failed"); else if (wc_curve448_make_key(rng, CURVE448_KEY_SIZE, &key)!=MP_OKAY) WOLFSSL_MSG("wc_curve448_make_key failed"); /* export key pair */ else if (wc_curve448_export_key_raw_ex(&key, priv, privSz, pub, pubSz, EC448_LITTLE_ENDIAN) != MP_OKAY) WOLFSSL_MSG("wc_curve448_export_key_raw_ex failed"); else ret = WOLFSSL_SUCCESS; wc_curve448_free(&key); } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return ret; #endif /* WOLFSSL_KEY_GEN */ } /* return 1 if success, 0 if error * input and output keys are little endian format */ int wolfSSL_EC448_shared_key(unsigned char *shared, unsigned int *sharedSz, const unsigned char *priv, unsigned int privSz, const unsigned char *pub, unsigned int pubSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) shared; (void) sharedSz; (void) priv; (void) privSz; (void) pub; (void) pubSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ int ret = WOLFSSL_FAILURE; curve448_key privkey, pubkey; WOLFSSL_ENTER("wolfSSL_EC448_shared_key"); if (shared == NULL || sharedSz == NULL || *sharedSz < CURVE448_KEY_SIZE || priv == NULL || privSz < CURVE448_KEY_SIZE || pub == NULL || pubSz < CURVE448_KEY_SIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } /* import private key */ if (wc_curve448_init(&privkey) != MP_OKAY) { WOLFSSL_MSG("wc_curve448_init privkey failed"); return ret; } if (wc_curve448_import_private_ex(priv, privSz, &privkey, EC448_LITTLE_ENDIAN) != MP_OKAY) { WOLFSSL_MSG("wc_curve448_import_private_ex failed"); wc_curve448_free(&privkey); return ret; } /* import public key */ if (wc_curve448_init(&pubkey) != MP_OKAY) { WOLFSSL_MSG("wc_curve448_init pubkey failed"); wc_curve448_free(&privkey); return ret; } if (wc_curve448_import_public_ex(pub, pubSz, &pubkey, EC448_LITTLE_ENDIAN) != MP_OKAY) { WOLFSSL_MSG("wc_curve448_import_public_ex failed"); wc_curve448_free(&privkey); wc_curve448_free(&pubkey); return ret; } if (wc_curve448_shared_secret_ex(&privkey, &pubkey, shared, sharedSz, EC448_LITTLE_ENDIAN) != MP_OKAY) WOLFSSL_MSG("wc_curve448_shared_secret_ex failed"); else ret = WOLFSSL_SUCCESS; wc_curve448_free(&privkey); wc_curve448_free(&pubkey); return ret; #endif /* WOLFSSL_KEY_GEN */ } #endif /* OPENSSL_EXTRA && HAVE_CURVE448 */ #if defined(OPENSSL_EXTRA) && defined(HAVE_ED448) /* return 1 if success, 0 if error * output keys are little endian format */ int wolfSSL_ED448_generate_key(unsigned char *priv, unsigned int *privSz, unsigned char *pub, unsigned int *pubSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) priv; (void) privSz; (void) pub; (void) pubSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ int ret = WOLFSSL_FAILURE; int initTmpRng = 0; WC_RNG *rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG *tmpRNG = NULL; #else WC_RNG tmpRNG[1]; #endif WOLFSSL_ENTER("wolfSSL_ED448_generate_key"); if (priv == NULL || privSz == NULL || *privSz < ED448_PRV_KEY_SIZE || pub == NULL || pubSz == NULL || *pubSz < ED448_PUB_KEY_SIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return WOLFSSL_FATAL_ERROR; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) WOLFSSL_MSG("Global RNG no Init"); else rng = &globalRNG; } if (rng) { ed448_key key; if (wc_ed448_init(&key) != MP_OKAY) WOLFSSL_MSG("wc_ed448_init failed"); else if (wc_ed448_make_key(rng, ED448_KEY_SIZE, &key) != MP_OKAY) WOLFSSL_MSG("wc_ed448_make_key failed"); /* export private key */ else if (wc_ed448_export_key(&key, priv, privSz, pub, pubSz) != MP_OKAY) WOLFSSL_MSG("wc_ed448_export_key failed"); else ret = WOLFSSL_SUCCESS; wc_ed448_free(&key); } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return ret; #endif /* WOLFSSL_KEY_GEN */ } /* return 1 if success, 0 if error * input and output keys are little endian format * priv is a buffer containing private and public part of key */ int wolfSSL_ED448_sign(const unsigned char *msg, unsigned int msgSz, const unsigned char *priv, unsigned int privSz, unsigned char *sig, unsigned int *sigSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) msg; (void) msgSz; (void) priv; (void) privSz; (void) sig; (void) sigSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ ed448_key key; int ret = WOLFSSL_FAILURE; WOLFSSL_ENTER("wolfSSL_ED448_sign"); if (priv == NULL || privSz != ED448_PRV_KEY_SIZE || msg == NULL || sig == NULL || *sigSz < ED448_SIG_SIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } /* import key */ if (wc_ed448_init(&key) != MP_OKAY) { WOLFSSL_MSG("wc_curve448_init failed"); return ret; } if (wc_ed448_import_private_key(priv, privSz/2, priv+(privSz/2), ED448_PUB_KEY_SIZE, &key) != MP_OKAY){ WOLFSSL_MSG("wc_ed448_import_private failed"); wc_ed448_free(&key); return ret; } if (wc_ed448_sign_msg(msg, msgSz, sig, sigSz, &key) != MP_OKAY) WOLFSSL_MSG("wc_curve448_shared_secret_ex failed"); else ret = WOLFSSL_SUCCESS; wc_ed448_free(&key); return ret; #endif /* WOLFSSL_KEY_GEN */ } /* return 1 if success, 0 if error * input and output keys are little endian format * pub is a buffer containing public part of key */ int wolfSSL_ED448_verify(const unsigned char *msg, unsigned int msgSz, const unsigned char *pub, unsigned int pubSz, const unsigned char *sig, unsigned int sigSz) { #ifndef WOLFSSL_KEY_GEN WOLFSSL_MSG("No Key Gen built in"); (void) msg; (void) msgSz; (void) pub; (void) pubSz; (void) sig; (void) sigSz; return WOLFSSL_FAILURE; #else /* WOLFSSL_KEY_GEN */ ed448_key key; int ret = WOLFSSL_FAILURE, check = 0; WOLFSSL_ENTER("wolfSSL_ED448_verify"); if (pub == NULL || pubSz != ED448_PUB_KEY_SIZE || msg == NULL || sig == NULL || sigSz != ED448_SIG_SIZE) { WOLFSSL_MSG("Bad arguments"); return WOLFSSL_FAILURE; } /* import key */ if (wc_ed448_init(&key) != MP_OKAY) { WOLFSSL_MSG("wc_curve448_init failed"); return ret; } if (wc_ed448_import_public(pub, pubSz, &key) != MP_OKAY){ WOLFSSL_MSG("wc_ed448_import_public failed"); wc_ed448_free(&key); return ret; } if ((ret = wc_ed448_verify_msg((byte*)sig, sigSz, msg, msgSz, &check, &key)) != MP_OKAY) { WOLFSSL_MSG("wc_ed448_verify_msg failed"); } else if (!check) WOLFSSL_MSG("wc_ed448_verify_msg failed (signature invalid)"); else ret = WOLFSSL_SUCCESS; wc_ed448_free(&key); return ret; #endif /* WOLFSSL_KEY_GEN */ } #endif /* OPENSSL_EXTRA && HAVE_ED448 */ #ifdef WOLFSSL_JNI int wolfSSL_set_jobject(WOLFSSL* ssl, void* objPtr) { WOLFSSL_ENTER("wolfSSL_set_jobject"); if (ssl != NULL) { ssl->jObjectRef = objPtr; return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } void* wolfSSL_get_jobject(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_jobject"); if (ssl != NULL) return ssl->jObjectRef; return NULL; } #endif /* WOLFSSL_JNI */ #ifdef WOLFSSL_ASYNC_CRYPT int wolfSSL_CTX_AsyncPoll(WOLFSSL_CTX* ctx, WOLF_EVENT** events, int maxEvents, WOLF_EVENT_FLAG flags, int* eventCount) { if (ctx == NULL) { return BAD_FUNC_ARG; } return wolfAsync_EventQueuePoll(&ctx->event_queue, NULL, events, maxEvents, flags, eventCount); } int wolfSSL_AsyncPoll(WOLFSSL* ssl, WOLF_EVENT_FLAG flags) { int ret, eventCount = 0; WOLF_EVENT* events[1]; if (ssl == NULL) { return BAD_FUNC_ARG; } ret = wolfAsync_EventQueuePoll(&ssl->ctx->event_queue, ssl, events, sizeof(events)/sizeof(*events), flags, &eventCount); if (ret == 0) { ret = eventCount; } return ret; } #endif /* WOLFSSL_ASYNC_CRYPT */ #ifdef OPENSSL_EXTRA unsigned long wolfSSL_ERR_peek_error_line_data(const char **file, int *line, const char **data, int *flags) { WOLFSSL_ENTER("wolfSSL_ERR_peek_error_line_data"); (void)line; (void)file; /* No data or flags stored - error display only in Nginx. */ if (data != NULL) { *data = ""; } if (flags != NULL) { *flags = 0; } #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || \ defined(WOLFSSL_OPENSSH) || defined(WOLFSSL_HAPROXY) || \ defined(WOLFSSL_MYSQL_COMPATIBLE) { int ret = 0; while (1) { if ((ret = wc_PeekErrorNode(-1, file, NULL, line)) < 0) { WOLFSSL_MSG("Issue peeking at error node in queue"); return 0; } /* OpenSSL uses positive error codes */ if (ret < 0) { ret = -ret; } if (ret == -ASN_NO_PEM_HEADER) return (ERR_LIB_PEM << 24) | PEM_R_NO_START_LINE; if (ret != WANT_READ && ret != WANT_WRITE && ret != ZERO_RETURN && ret != WOLFSSL_ERROR_ZERO_RETURN && ret != SOCKET_PEER_CLOSED_E && ret != SOCKET_ERROR_E) break; wc_RemoveErrorNode(-1); } return (unsigned long)ret; } #else return (unsigned long)(0 - NOT_COMPILED_IN); #endif } #endif #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) /* returns a pointer to internal cipher suite list. Should not be free'd by * caller. */ WOLF_STACK_OF(WOLFSSL_CIPHER) *wolfSSL_get_ciphers_compat(const WOLFSSL *ssl) { WOLF_STACK_OF(WOLFSSL_CIPHER)* ret = NULL; Suites* suites; WOLFSSL_ENTER("wolfSSL_get_ciphers_compat"); if (ssl == NULL || (ssl->suites == NULL && ssl->ctx->suites == NULL)) { return NULL; } if (ssl->suites != NULL) { suites = ssl->suites; } else { suites = ssl->ctx->suites; } /* check if stack needs populated */ if (suites->stack == NULL) { int i; for (i = 0; i < suites->suiteSz; i+=2) { WOLFSSL_STACK* add = wolfSSL_sk_new_node(ssl->heap); if (add != NULL) { add->type = STACK_TYPE_CIPHER; add->data.cipher.cipherSuite0 = suites->suites[i]; add->data.cipher.cipherSuite = suites->suites[i+1]; #if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) /* in_stack is checked in wolfSSL_CIPHER_description */ add->data.cipher.in_stack = 1; #endif add->next = ret; if (ret != NULL) { add->num = ret->num + 1; } else { add->num = 1; } ret = add; } } suites->stack = ret; } return suites->stack; } #ifndef NO_WOLFSSL_STUB void wolfSSL_OPENSSL_config(char *config_name) { (void)config_name; WOLFSSL_STUB("OPENSSL_config"); } #endif /* !NO_WOLFSSL_STUB */ #endif /* OPENSSL_ALL || WOLFSSL_NGINX || WOLFSSL_HAPROXY */ #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) \ || defined(OPENSSL_EXTRA) || defined(HAVE_LIGHTY) int wolfSSL_X509_get_ex_new_index(int idx, void *arg, void *a, void *b, void *c) { static int x509_idx = 0; WOLFSSL_ENTER("wolfSSL_X509_get_ex_new_index"); (void)idx; (void)arg; (void)a; (void)b; (void)c; return x509_idx++; } #if defined(HAVE_EX_DATA) || defined(FORTRESS) void* wolfSSL_CRYPTO_get_ex_data(const WOLFSSL_CRYPTO_EX_DATA* ex_data, int idx) { WOLFSSL_ENTER("wolfSSL_CTX_get_ex_data"); #ifdef MAX_EX_DATA if(ex_data && idx < MAX_EX_DATA && idx >= 0) { return ex_data->ex_data[idx]; } #else (void)ex_data; (void)idx; #endif return NULL; } int wolfSSL_CRYPTO_set_ex_data(WOLFSSL_CRYPTO_EX_DATA* ex_data, int idx, void *data) { WOLFSSL_ENTER("wolfSSL_CRYPTO_set_ex_data"); #ifdef MAX_EX_DATA if (ex_data && idx < MAX_EX_DATA && idx >= 0) { ex_data->ex_data[idx] = data; return WOLFSSL_SUCCESS; } #else (void)ex_data; (void)idx; (void)data; #endif return WOLFSSL_FAILURE; } #endif /* defined(HAVE_EX_DATA) || defined(FORTRESS) */ void *wolfSSL_X509_get_ex_data(X509 *x509, int idx) { WOLFSSL_ENTER("wolfSSL_X509_get_ex_data"); #ifdef HAVE_EX_DATA if (x509 != NULL) { return wolfSSL_CRYPTO_get_ex_data(&x509->ex_data, idx); } #else (void)x509; (void)idx; #endif return NULL; } int wolfSSL_X509_set_ex_data(X509 *x509, int idx, void *data) { WOLFSSL_ENTER("wolfSSL_X509_set_ex_data"); #ifdef HAVE_EX_DATA if (x509 != NULL) { return wolfSSL_CRYPTO_set_ex_data(&x509->ex_data, idx, data); } #else (void)x509; (void)idx; (void)data; #endif return WOLFSSL_FAILURE; } int wolfSSL_X509_NAME_digest(const WOLFSSL_X509_NAME *name, const WOLFSSL_EVP_MD *type, unsigned char *md, unsigned int *len) { WOLFSSL_ENTER("wolfSSL_X509_NAME_digest"); if (name == NULL || type == NULL) return WOLFSSL_FAILURE; #if !defined(NO_FILESYSTEM) && !defined(NO_PWDBASED) return wolfSSL_EVP_Digest((unsigned char*)name->fullName.fullName, name->fullName.fullNameLen, md, len, type, NULL); #else (void)md; (void)len; return NOT_COMPILED_IN; #endif } long wolfSSL_SSL_CTX_get_timeout(const WOLFSSL_CTX *ctx) { WOLFSSL_ENTER("wolfSSL_SSL_CTX_get_timeout"); if (ctx == NULL) return 0; return ctx->timeout; } /* returns the time in seconds of the current timeout */ long wolfSSL_get_timeout(WOLFSSL* ssl) { WOLFSSL_ENTER("wolfSSL_get_timeout"); if (ssl == NULL) return 0; return ssl->timeout; } #ifdef HAVE_ECC int wolfSSL_SSL_CTX_set_tmp_ecdh(WOLFSSL_CTX *ctx, WOLFSSL_EC_KEY *ecdh) { WOLFSSL_ENTER("wolfSSL_SSL_CTX_set_tmp_ecdh"); if (ctx == NULL || ecdh == NULL) return BAD_FUNC_ARG; ctx->ecdhCurveOID = ecdh->group->curve_oid; return WOLFSSL_SUCCESS; } #endif /* Assumes that the session passed in is from the cache. */ int wolfSSL_SSL_CTX_remove_session(WOLFSSL_CTX *ctx, WOLFSSL_SESSION *s) { WOLFSSL_ENTER("wolfSSL_SSL_CTX_remove_session"); if (ctx == NULL || s == NULL) return BAD_FUNC_ARG; #ifdef HAVE_EXT_CACHE if (!ctx->internalCacheOff) #endif { /* Don't remove session just timeout session. */ s->timeout = 0; } #ifdef HAVE_EXT_CACHE if (ctx->rem_sess_cb != NULL) ctx->rem_sess_cb(ctx, s); #endif return 0; } BIO *wolfSSL_SSL_get_rbio(const WOLFSSL *s) { WOLFSSL_ENTER("wolfSSL_SSL_get_rbio"); /* Nginx sets the buffer size if the read BIO is different to write BIO. * The setting buffer size doesn't do anything so return NULL for both. */ if (s == NULL) return NULL; return s->biord; } BIO *wolfSSL_SSL_get_wbio(const WOLFSSL *s) { WOLFSSL_ENTER("wolfSSL_SSL_get_wbio"); (void)s; /* Nginx sets the buffer size if the read BIO is different to write BIO. * The setting buffer size doesn't do anything so return NULL for both. */ if (s == NULL) return NULL; return s->biowr; } int wolfSSL_SSL_do_handshake(WOLFSSL *s) { WOLFSSL_ENTER("wolfSSL_SSL_do_handshake"); if (s == NULL) return WOLFSSL_FAILURE; if (s->options.side == WOLFSSL_CLIENT_END) { #ifndef NO_WOLFSSL_CLIENT return wolfSSL_connect(s); #else WOLFSSL_MSG("Client not compiled in"); return WOLFSSL_FAILURE; #endif } #ifndef NO_WOLFSSL_SERVER return wolfSSL_accept(s); #else WOLFSSL_MSG("Server not compiled in"); return WOLFSSL_FAILURE; #endif } int wolfSSL_SSL_in_init(WOLFSSL *ssl) { WOLFSSL_ENTER("SSL_in_init"); if (ssl == NULL) return WOLFSSL_FAILURE; if (ssl->options.side == WOLFSSL_CLIENT_END) { return ssl->options.connectState < SECOND_REPLY_DONE; } return ssl->options.acceptState < ACCEPT_THIRD_REPLY_DONE; } int wolfSSL_SSL_in_connect_init(WOLFSSL* ssl) { WOLFSSL_ENTER("SSL_connect_init"); if (ssl == NULL) return WOLFSSL_FAILURE; if (ssl->options.side == WOLFSSL_CLIENT_END) { return ssl->options.connectState > CONNECT_BEGIN && ssl->options.connectState < SECOND_REPLY_DONE; } return ssl->options.acceptState > ACCEPT_BEGIN && ssl->options.acceptState < ACCEPT_THIRD_REPLY_DONE; } #ifndef NO_SESSION_CACHE WOLFSSL_SESSION *wolfSSL_SSL_get0_session(const WOLFSSL *ssl) { WOLFSSL_SESSION *session; WOLFSSL_ENTER("wolfSSL_SSL_get0_session"); if (ssl == NULL) { return NULL; } session = wolfSSL_get_session((WOLFSSL*)ssl); #ifdef HAVE_EXT_CACHE ((WOLFSSL*)ssl)->extSession = session; #endif return session; } #endif /* NO_SESSION_CACHE */ int wolfSSL_X509_check_host(X509 *x, const char *chk, size_t chklen, unsigned int flags, char **peername) { int ret; DecodedCert dCert; WOLFSSL_ENTER("wolfSSL_X509_check_host"); /* flags and peername not needed for Nginx. */ (void)flags; (void)peername; if (flags == WOLFSSL_NO_WILDCARDS) { WOLFSSL_MSG("X509_CHECK_FLAG_NO_WILDCARDS not yet implemented"); return WOLFSSL_FAILURE; } InitDecodedCert(&dCert, x->derCert->buffer, x->derCert->length, NULL); ret = ParseCertRelative(&dCert, CERT_TYPE, 0, NULL); if (ret != 0) { FreeDecodedCert(&dCert); return WOLFSSL_FAILURE; } ret = CheckHostName(&dCert, (char *)chk, chklen); FreeDecodedCert(&dCert); if (ret != 0) return WOLFSSL_FAILURE; return WOLFSSL_SUCCESS; } int wolfSSL_i2a_ASN1_INTEGER(BIO *bp, const WOLFSSL_ASN1_INTEGER *a) { static char num[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; int i; word32 j; word32 len = 0; WOLFSSL_ENTER("wolfSSL_i2a_ASN1_INTEGER"); if (bp == NULL || a == NULL) return WOLFSSL_FAILURE; /* Skip ASN.1 INTEGER (type) byte. */ i = 1; /* When indefinite length, can't determine length with data available. */ if (a->data[i] == 0x80) return 0; /* One length byte if less than 0x80. */ if (a->data[i] < 0x80) len = a->data[i++]; /* Multiple length byte if greater than 0x80. */ else if (a->data[i] > 0x80) { switch (a->data[i++] - 0x80) { case 4: len |= a->data[i++] << 24; FALL_THROUGH; case 3: len |= a->data[i++] << 16; FALL_THROUGH; case 2: len |= a->data[i++] << 8; FALL_THROUGH; case 1: len |= a->data[i++]; break; default: /* Not supporting greater than 4 bytes of length. */ return 0; } } /* Zero length integer is the value zero. */ if (len == 0) { wolfSSL_BIO_write(bp, "00", 2); return 2; } /* Don't do negative - just write out every byte. */ for (j = 0; j < len; i++,j++) { wolfSSL_BIO_write(bp, &num[a->data[i] >> 4], 1); wolfSSL_BIO_write(bp, &num[a->data[i] & 0xf], 1); } /* Two nibbles written for each byte. */ return len * 2; } #if defined(HAVE_SESSION_TICKET) && !defined(NO_WOLFSSL_SERVER) /* Expected return values from implementations of OpenSSL ticket key callback. */ #define TICKET_KEY_CB_RET_FAILURE -1 #define TICKET_KEY_CB_RET_NOT_FOUND 0 #define TICKET_KEY_CB_RET_OK 1 #define TICKET_KEY_CB_RET_RENEW 2 /* The ticket key callback as used in OpenSSL is stored here. */ static int (*ticketKeyCb)(WOLFSSL *ssl, unsigned char *name, unsigned char *iv, WOLFSSL_EVP_CIPHER_CTX *ectx, WOLFSSL_HMAC_CTX *hctx, int enc) = NULL; /* Implementation of session ticket encryption/decryption using OpenSSL * callback to initialize the cipher and HMAC. * * ssl The SSL/TLS object. * keyName The key name - used to identify the key to be used. * iv The IV to use. * mac The MAC of the encrypted data. * enc Encrypt ticket. * encTicket The ticket data. * encTicketLen The length of the ticket data. * encLen The encrypted/decrypted ticket length - output length. * ctx Ignored. Application specific data. * returns WOLFSSL_TICKET_RET_OK to indicate success, * WOLFSSL_TICKET_RET_CREATE if a new ticket is required and * WOLFSSL_TICKET_RET_FATAL on error. */ static int wolfSSL_TicketKeyCb(WOLFSSL* ssl, unsigned char keyName[WOLFSSL_TICKET_NAME_SZ], unsigned char iv[WOLFSSL_TICKET_IV_SZ], unsigned char mac[WOLFSSL_TICKET_MAC_SZ], int enc, unsigned char* encTicket, int encTicketLen, int* encLen, void* ctx) { byte digest[WC_MAX_DIGEST_SIZE]; WOLFSSL_EVP_CIPHER_CTX evpCtx; WOLFSSL_HMAC_CTX hmacCtx; unsigned int mdSz = 0; int len = 0; int ret = WOLFSSL_TICKET_RET_FATAL; int res; (void)ctx; if (ticketKeyCb == NULL) return WOLFSSL_TICKET_RET_FATAL; wolfSSL_EVP_CIPHER_CTX_init(&evpCtx); /* Initialize the cipher and HMAC. */ res = ticketKeyCb(ssl, keyName, iv, &evpCtx, &hmacCtx, enc); if (res != TICKET_KEY_CB_RET_OK && res != TICKET_KEY_CB_RET_RENEW) return WOLFSSL_TICKET_RET_FATAL; if (enc) { /* Encrypt in place. */ if (!wolfSSL_EVP_CipherUpdate(&evpCtx, encTicket, &len, encTicket, encTicketLen)) goto end; encTicketLen = len; if (!wolfSSL_EVP_EncryptFinal(&evpCtx, &encTicket[encTicketLen], &len)) goto end; /* Total length of encrypted data. */ encTicketLen += len; *encLen = encTicketLen; /* HMAC the encrypted data into the parameter 'mac'. */ if (!wolfSSL_HMAC_Update(&hmacCtx, encTicket, encTicketLen)) goto end; #ifdef WOLFSSL_SHA512 /* Check for SHA512, which would overrun the mac buffer */ if (hmacCtx.hmac.macType == WC_SHA512) goto end; #endif if (!wolfSSL_HMAC_Final(&hmacCtx, mac, &mdSz)) goto end; } else { /* HMAC the encrypted data and compare it to the passed in data. */ if (!wolfSSL_HMAC_Update(&hmacCtx, encTicket, encTicketLen)) goto end; if (!wolfSSL_HMAC_Final(&hmacCtx, digest, &mdSz)) goto end; if (XMEMCMP(mac, digest, mdSz) != 0) goto end; /* Decrypt the ticket data in place. */ if (!wolfSSL_EVP_CipherUpdate(&evpCtx, encTicket, &len, encTicket, encTicketLen)) goto end; encTicketLen = len; if (!wolfSSL_EVP_DecryptFinal(&evpCtx, &encTicket[encTicketLen], &len)) goto end; /* Total length of decrypted data. */ *encLen = encTicketLen + len; } ret = (res == TICKET_KEY_CB_RET_RENEW) ? WOLFSSL_TICKET_RET_CREATE : WOLFSSL_TICKET_RET_OK; end: return ret; } /* Set the callback to use when encrypting/decrypting tickets. * * ctx The SSL/TLS context object. * cb The OpenSSL session ticket callback. * returns WOLFSSL_SUCCESS to indicate success. */ int wolfSSL_CTX_set_tlsext_ticket_key_cb(WOLFSSL_CTX *ctx, int (*cb)( WOLFSSL *ssl, unsigned char *name, unsigned char *iv, WOLFSSL_EVP_CIPHER_CTX *ectx, WOLFSSL_HMAC_CTX *hctx, int enc)) { /* Store callback in a global. */ ticketKeyCb = cb; /* Set the ticket encryption callback to be a wrapper around OpenSSL * callback. */ ctx->ticketEncCb = wolfSSL_TicketKeyCb; return WOLFSSL_SUCCESS; } #endif /* HAVE_SESSION_TICKET */ #endif /* OPENSSL_ALL || WOLFSSL_NGINX || WOLFSSL_HAPROXY || OPENSSL_EXTRA || HAVE_LIGHTY */ #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) #ifdef HAVE_OCSP /* Not an OpenSSL API. */ int wolfSSL_get_ocsp_response(WOLFSSL* ssl, byte** response) { *response = ssl->ocspResp; return ssl->ocspRespSz; } /* Not an OpenSSL API. */ char* wolfSSL_get_ocsp_url(WOLFSSL* ssl) { return ssl->url; } /* Not an OpenSSL API. */ int wolfSSL_set_ocsp_url(WOLFSSL* ssl, char* url) { if (ssl == NULL) return WOLFSSL_FAILURE; ssl->url = url; return WOLFSSL_SUCCESS; } #endif /* OCSP */ #endif /* OPENSSL_ALL / WOLFSSL_NGINX / WOLFSSL_HAPROXY */ #if defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) || \ defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL) int wolfSSL_CTX_get_extra_chain_certs(WOLFSSL_CTX* ctx, WOLF_STACK_OF(X509)** chain) { word32 idx; word32 length; WOLFSSL_STACK* node; WOLFSSL_STACK* last = NULL; if (ctx == NULL || chain == NULL) { chain = NULL; return WOLFSSL_FAILURE; } if (ctx->x509Chain != NULL) { *chain = ctx->x509Chain; return WOLFSSL_SUCCESS; } /* If there are no chains then success! */ *chain = NULL; if (ctx->certChain == NULL || ctx->certChain->length == 0) { return WOLFSSL_SUCCESS; } /* Create a new stack of WOLFSSL_X509 object from chain buffer. */ for (idx = 0; idx < ctx->certChain->length; ) { node = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_OPENSSL); if (node == NULL) return WOLFSSL_FAILURE; node->next = NULL; /* 3 byte length | X509 DER data */ ato24(ctx->certChain->buffer + idx, &length); idx += 3; /* Create a new X509 from DER encoded data. */ node->data.x509 = wolfSSL_X509_d2i(NULL, ctx->certChain->buffer + idx, length); if (node->data.x509 == NULL) { XFREE(node, NULL, DYNAMIC_TYPE_OPENSSL); /* Return as much of the chain as we created. */ ctx->x509Chain = *chain; return WOLFSSL_FAILURE; } idx += length; /* Add object to the end of the stack. */ if (last == NULL) { node->num = 1; *chain = node; } else { (*chain)->num++; last->next = node; } last = node; } ctx->x509Chain = *chain; return WOLFSSL_SUCCESS; } int wolfSSL_CTX_set_tlsext_status_cb(WOLFSSL_CTX* ctx, int(*cb)(WOLFSSL*, void*)) { if (ctx == NULL || ctx->cm == NULL) return WOLFSSL_FAILURE; #if !defined(NO_WOLFSSL_SERVER) && (defined(HAVE_CERTIFICATE_STATUS_REQUEST) \ || defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)) /* Ensure stapling is on for callback to be used. */ wolfSSL_CTX_EnableOCSPStapling(ctx); if (ctx->cm->ocsp_stapling == NULL) return WOLFSSL_FAILURE; ctx->cm->ocsp_stapling->statusCb = cb; #else (void)cb; #endif return WOLFSSL_SUCCESS; } int wolfSSL_X509_STORE_CTX_get1_issuer(WOLFSSL_X509 **issuer, WOLFSSL_X509_STORE_CTX *ctx, WOLFSSL_X509 *x) { WOLFSSL_STACK* node; Signer* ca = NULL; #ifdef WOLFSSL_SMALL_STACK DecodedCert* cert = NULL; #else DecodedCert cert[1]; #endif if (issuer == NULL || ctx == NULL || x == NULL) return WOLFSSL_FATAL_ERROR; if (ctx->chain != NULL) { for (node = ctx->chain; node != NULL; node = node->next) { if (wolfSSL_X509_check_issued(node->data.x509, x) == X509_V_OK) { *issuer = x; return WOLFSSL_SUCCESS; } } } #ifdef WOLFSSL_SMALL_STACK cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT); if (cert == NULL) return WOLFSSL_FAILURE; #endif /* Use existing CA retrieval APIs that use DecodedCert. */ InitDecodedCert(cert, x->derCert->buffer, x->derCert->length, NULL); if (ParseCertRelative(cert, CERT_TYPE, 0, NULL) == 0) { #ifndef NO_SKID if (cert->extAuthKeyIdSet) ca = GetCA(ctx->store->cm, cert->extAuthKeyId); if (ca == NULL) ca = GetCAByName(ctx->store->cm, cert->issuerHash); #else /* NO_SKID */ ca = GetCA(ctx->store->cm, cert->issuerHash); #endif /* NO SKID */ } FreeDecodedCert(cert); #ifdef WOLFSSL_SMALL_STACK XFREE(cert, NULL, DYNAMIC_TYPE_DCERT); #endif if (ca == NULL) return WOLFSSL_FAILURE; #ifdef WOLFSSL_SIGNER_DER_CERT /* populate issuer with Signer DER */ *issuer = wolfSSL_X509_d2i(issuer, ca->derCert->buffer, ca->derCert->length); if (*issuer == NULL) return WOLFSSL_FAILURE; #else /* Create an empty certificate as CA doesn't have a certificate. */ *issuer = (WOLFSSL_X509 *)XMALLOC(sizeof(WOLFSSL_X509), 0, DYNAMIC_TYPE_OPENSSL); if (*issuer == NULL) return WOLFSSL_FAILURE; InitX509((*issuer), 1, NULL); #endif /* Result is ignored when passed to wolfSSL_OCSP_cert_to_id(). */ return WOLFSSL_SUCCESS; } void wolfSSL_X509_email_free(WOLF_STACK_OF(WOLFSSL_STRING) *sk) { WOLFSSL_STACK *curr; while (sk != NULL) { curr = sk; sk = sk->next; XFREE(curr, NULL, DYNAMIC_TYPE_OPENSSL); } } WOLF_STACK_OF(WOLFSSL_STRING) *wolfSSL_X509_get1_ocsp(WOLFSSL_X509 *x) { WOLFSSL_STACK* list = NULL; char* url; if (x->authInfoSz == 0) return NULL; list = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK) + x->authInfoSz + 1, NULL, DYNAMIC_TYPE_OPENSSL); if (list == NULL) return NULL; url = (char*)list; url += sizeof(WOLFSSL_STACK); XMEMCPY(url, x->authInfo, x->authInfoSz); url[x->authInfoSz] = '\0'; list->data.string = url; list->next = NULL; return list; } int wolfSSL_X509_check_issued(WOLFSSL_X509 *issuer, WOLFSSL_X509 *subject) { WOLFSSL_X509_NAME *issuerName = wolfSSL_X509_get_issuer_name(subject); WOLFSSL_X509_NAME *subjectName = wolfSSL_X509_get_subject_name(issuer); if (issuerName == NULL || subjectName == NULL) return X509_V_ERR_SUBJECT_ISSUER_MISMATCH; /* Literal matching of encoded names and key ids. */ if (issuerName->sz != subjectName->sz || XMEMCMP(issuerName->name, subjectName->name, subjectName->sz) != 0) { return X509_V_ERR_SUBJECT_ISSUER_MISMATCH; } if (subject->authKeyId != NULL && issuer->subjKeyId != NULL) { if (subject->authKeyIdSz != issuer->subjKeyIdSz || XMEMCMP(subject->authKeyId, issuer->subjKeyId, issuer->subjKeyIdSz) != 0) { return X509_V_ERR_SUBJECT_ISSUER_MISMATCH; } } return X509_V_OK; } WOLFSSL_X509* wolfSSL_X509_dup(WOLFSSL_X509 *x) { return wolfSSL_X509_d2i(NULL, x->derCert->buffer, x->derCert->length); } char* wolfSSL_sk_WOLFSSL_STRING_value(WOLF_STACK_OF(WOLFSSL_STRING)* strings, int idx) { for (; idx > 0 && strings != NULL; idx--) strings = strings->next; if (strings == NULL) return NULL; return strings->data.string; } #endif /* WOLFSSL_NGINX || WOLFSSL_HAPROXY || OPENSSL_EXTRA || OPENSSL_ALL */ #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) #ifdef HAVE_ALPN void wolfSSL_get0_alpn_selected(const WOLFSSL *ssl, const unsigned char **data, unsigned int *len) { word16 nameLen; if (ssl != NULL && data != NULL && len != NULL) { TLSX_ALPN_GetRequest(ssl->extensions, (void **)data, &nameLen); *len = nameLen; } } int wolfSSL_select_next_proto(unsigned char **out, unsigned char *outLen, const unsigned char *in, unsigned int inLen, const unsigned char *clientNames, unsigned int clientLen) { unsigned int i, j; byte lenIn, lenClient; if (out == NULL || outLen == NULL || in == NULL || clientNames == NULL) return OPENSSL_NPN_UNSUPPORTED; for (i = 0; i < inLen; i += lenIn) { lenIn = in[i++]; for (j = 0; j < clientLen; j += lenClient) { lenClient = clientNames[j++]; if (lenIn != lenClient) continue; if (XMEMCMP(in + i, clientNames + j, lenIn) == 0) { *out = (unsigned char *)(in + i); *outLen = lenIn; return OPENSSL_NPN_NEGOTIATED; } } } *out = (unsigned char *)clientNames + 1; *outLen = clientNames[0]; return OPENSSL_NPN_NO_OVERLAP; } void wolfSSL_CTX_set_alpn_select_cb(WOLFSSL_CTX *ctx, int (*cb) (WOLFSSL *ssl, const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg), void *arg) { if (ctx != NULL) { ctx->alpnSelect = cb; ctx->alpnSelectArg = arg; } } void wolfSSL_CTX_set_next_protos_advertised_cb(WOLFSSL_CTX *s, int (*cb) (WOLFSSL *ssl, const unsigned char **out, unsigned int *outlen, void *arg), void *arg) { (void)s; (void)cb; (void)arg; WOLFSSL_STUB("wolfSSL_CTX_set_next_protos_advertised_cb"); } void wolfSSL_CTX_set_next_proto_select_cb(WOLFSSL_CTX *s, int (*cb) (WOLFSSL *ssl, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg), void *arg) { (void)s; (void)cb; (void)arg; WOLFSSL_STUB("wolfSSL_CTX_set_next_proto_select_cb"); } void wolfSSL_get0_next_proto_negotiated(const WOLFSSL *s, const unsigned char **data, unsigned *len) { (void)s; (void)data; (void)len; WOLFSSL_STUB("wolfSSL_get0_next_proto_negotiated"); } #endif /* HAVE_ALPN */ #endif /* WOLFSSL_NGINX / WOLFSSL_HAPROXY */ #if defined(OPENSSL_EXTRA) && defined(HAVE_ECC) int wolfSSL_CTX_set1_curves_list(WOLFSSL_CTX* ctx, const char* names) { int idx, start = 0, len; word16 curve; char name[MAX_CURVE_NAME_SZ]; /* Disable all curves so that only the ones the user wants are enabled. */ ctx->disabledCurves = 0xFFFFFFFFUL; for (idx = 1; names[idx-1] != '\0'; idx++) { if (names[idx] != ':' && names[idx] != '\0') continue; len = idx - 1 - start; if (len > MAX_CURVE_NAME_SZ - 1) return WOLFSSL_FAILURE; XMEMCPY(name, names + start, len); name[len] = 0; if ((XSTRNCMP(name, "prime256v1", len) == 0) || (XSTRNCMP(name, "secp256r1", len) == 0) || (XSTRNCMP(name, "P-256", len) == 0)) { curve = WOLFSSL_ECC_SECP256R1; } else if ((XSTRNCMP(name, "secp384r1", len) == 0) || (XSTRNCMP(name, "P-384", len) == 0)) { curve = WOLFSSL_ECC_SECP384R1; } else if ((XSTRNCMP(name, "secp521r1", len) == 0) || (XSTRNCMP(name, "P-521", len) == 0)) { curve = WOLFSSL_ECC_SECP521R1; } else if (XSTRNCMP(name, "X25519", len) == 0) { curve = WOLFSSL_ECC_X25519; } else if (XSTRNCMP(name, "X448", len) == 0) { curve = WOLFSSL_ECC_X448; } else { #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) int ret; const ecc_set_type *eccSet; ret = wc_ecc_get_curve_idx_from_name(name); if (ret < 0) { WOLFSSL_MSG("Could not find name in set"); return WOLFSSL_FAILURE; } eccSet = wc_ecc_get_curve_params(ret); if (eccSet == NULL) { WOLFSSL_MSG("NULL set returned"); return WOLFSSL_FAILURE; } curve = GetCurveByOID(eccSet->oidSum); #else WOLFSSL_MSG("API not present to search farther using name"); return WOLFSSL_FAILURE; #endif } if (curve > (sizeof(word32) * WOLFSSL_BIT_SIZE)) { /* shift left more than size of ctx->disabledCurves causes static * analysis report */ WOLFSSL_MSG("curve value is too large for upcoming shift"); return WOLFSSL_FAILURE; } #if defined(HAVE_SUPPORTED_CURVES) && !defined(NO_WOLFSSL_CLIENT) /* set the supported curve so client TLS extension contains only the * desired curves */ if (wolfSSL_CTX_UseSupportedCurve(ctx, curve) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("Unable to set supported curve"); return WOLFSSL_FAILURE; } #endif /* Switch the bit to off and therefore is enabled. */ ctx->disabledCurves &= ~(1U << curve); start = idx + 1; } return WOLFSSL_SUCCESS; } int wolfSSL_set1_curves_list(WOLFSSL* ssl, const char* names) { if (ssl == NULL) { return WOLFSSL_FAILURE; } return wolfSSL_CTX_set1_curves_list(ssl->ctx, names); } #endif /* OPENSSL_EXTRA && HAVE_ECC */ #ifdef OPENSSL_EXTRA #ifndef NO_WOLFSSL_STUB int wolfSSL_CTX_set_msg_callback(WOLFSSL_CTX *ctx, SSL_Msg_Cb cb) { WOLFSSL_STUB("SSL_CTX_set_msg_callback"); (void)ctx; (void)cb; return WOLFSSL_FAILURE; } #endif /* Sets a callback for when sending and receiving protocol messages. * * ssl WOLFSSL structure to set callback in * cb callback to use * * return SSL_SUCCESS on success and SSL_FAILURE with error case */ int wolfSSL_set_msg_callback(WOLFSSL *ssl, SSL_Msg_Cb cb) { WOLFSSL_ENTER("wolfSSL_set_msg_callback"); if (ssl == NULL) { return SSL_FAILURE; } if (cb != NULL) { ssl->toInfoOn = 1; } ssl->protoMsgCb = cb; return SSL_SUCCESS; } #ifndef NO_WOLFSSL_STUB int wolfSSL_CTX_set_msg_callback_arg(WOLFSSL_CTX *ctx, void* arg) { WOLFSSL_STUB("SSL_CTX_set_msg_callback_arg"); (void)ctx; (void)arg; return WOLFSSL_FAILURE; } #endif int wolfSSL_set_msg_callback_arg(WOLFSSL *ssl, void* arg) { WOLFSSL_ENTER("wolfSSL_set_msg_callback_arg"); if (ssl == NULL) return WOLFSSL_FAILURE; ssl->protoMsgCtx = arg; return WOLFSSL_SUCCESS; } void *wolfSSL_OPENSSL_memdup(const void *data, size_t siz, const char* file, int line) { void *ret; (void)file; (void)line; if (data == NULL || siz >= INT_MAX) return NULL; ret = OPENSSL_malloc(siz); if (ret == NULL) { return NULL; } return XMEMCPY(ret, data, siz); } int wolfSSL_CTX_set_alpn_protos(WOLFSSL_CTX *ctx, const unsigned char *p, unsigned int p_len) { WOLFSSL_ENTER("wolfSSL_CTX_set_alpn_protos"); if(ctx == NULL) return BAD_FUNC_ARG; if((void *)ctx->alpn_cli_protos != NULL) wolfSSL_OPENSSL_free((void *)ctx->alpn_cli_protos); ctx->alpn_cli_protos = (const unsigned char *)wolfSSL_OPENSSL_memdup(p, p_len, NULL, 0); if (ctx->alpn_cli_protos == NULL) { return SSL_FAILURE; } ctx->alpn_cli_protos_len = p_len; return SSL_SUCCESS; } #ifdef HAVE_ALPN /* Sets the ALPN extension protos * * example format is * unsigned char p[] = { * 8, 'h', 't', 't', 'p', '/', '1', '.', '1' * }; * * returns WOLFSSL_SUCCESS on success */ int wolfSSL_set_alpn_protos(WOLFSSL* ssl, const unsigned char* p, unsigned int p_len) { WOLFSSL_BIO* bio; char* pt; unsigned int sz; unsigned int idx = 0; int alpn_opt = WOLFSSL_ALPN_CONTINUE_ON_MISMATCH; WOLFSSL_ENTER("wolfSSL_set_alpn_protos"); if (ssl == NULL || p_len <= 1) { return WOLFSSL_FAILURE; } bio = wolfSSL_BIO_new(wolfSSL_BIO_s_mem()); if (bio == NULL) { return WOLFSSL_FAILURE; } /* convert into comma separated list */ while (idx < p_len - 1) { unsigned int i; sz = p[idx++]; if (idx + sz > p_len) { WOLFSSL_MSG("Bad list format"); wolfSSL_BIO_free(bio); return WOLFSSL_FAILURE; } if (sz > 0) { for (i = 0; i < sz; i++) { wolfSSL_BIO_write(bio, &p[idx++], 1); } if (idx < p_len - 1) wolfSSL_BIO_write(bio, ",", 1); } } wolfSSL_BIO_write(bio, "\0", 1); /* clears out all current ALPN extensions set */ TLSX_Remove(&ssl->extensions, TLSX_APPLICATION_LAYER_PROTOCOL, ssl->heap); if ((sz = wolfSSL_BIO_get_mem_data(bio, &pt)) > 0) { wolfSSL_UseALPN(ssl, pt, sz, alpn_opt); } wolfSSL_BIO_free(bio); return WOLFSSL_SUCCESS; } #endif /* HAVE_ALPN */ #endif #endif /* WOLFCRYPT_ONLY */ #if defined(OPENSSL_EXTRA) #define WOLFSSL_BIO_INCLUDED #include "src/bio.c" int oid2nid(word32 oid, int grp) { /* get OID type */ switch (grp) { /* oidHashType */ case oidHashType: switch (oid) { #ifdef WOLFSSL_MD2 case MD2h: return NID_md2; #endif #ifndef NO_MD5 case MD5h: return NID_md5; #endif #ifndef NO_SHA case SHAh: return NID_sha1; #endif case SHA224h: return NID_sha224; #ifndef NO_SHA256 case SHA256h: return NID_sha256; #endif #ifdef WOLFSSL_SHA384 case SHA384h: return NID_sha384; #endif #ifdef WOLFSSL_SHA512 case SHA512h: return NID_sha512; #endif } break; /* oidSigType */ case oidSigType: switch (oid) { #ifndef NO_DSA case CTC_SHAwDSA: return CTC_SHAwDSA; #endif /* NO_DSA */ #ifndef NO_RSA case CTC_MD2wRSA: return CTC_MD2wRSA; case CTC_MD5wRSA: return CTC_MD5wRSA; case CTC_SHAwRSA: return CTC_SHAwRSA; case CTC_SHA224wRSA: return CTC_SHA224wRSA; case CTC_SHA256wRSA: return CTC_SHA256wRSA; case CTC_SHA384wRSA: return CTC_SHA384wRSA; case CTC_SHA512wRSA: return CTC_SHA512wRSA; #endif /* NO_RSA */ #ifdef HAVE_ECC case CTC_SHAwECDSA: return CTC_SHAwECDSA; case CTC_SHA224wECDSA: return CTC_SHA224wECDSA; case CTC_SHA256wECDSA: return CTC_SHA256wECDSA; case CTC_SHA384wECDSA: return CTC_SHA384wECDSA; case CTC_SHA512wECDSA: return CTC_SHA512wECDSA; #endif /* HAVE_ECC */ } break; /* oidKeyType */ case oidKeyType: switch (oid) { #ifndef NO_DSA case DSAk: return DSAk; #endif /* NO_DSA */ #ifndef NO_RSA case RSAk: return RSAk; #endif /* NO_RSA */ #ifdef HAVE_NTRU case NTRUk: return NTRUk; #endif /* HAVE_NTRU */ #ifdef HAVE_ECC case ECDSAk: return ECDSAk; #endif /* HAVE_ECC */ } break; #ifdef HAVE_ECC case oidCurveType: switch (oid) { case ECC_SECP192R1_OID: return NID_X9_62_prime192v1; case ECC_PRIME192V2_OID: return NID_X9_62_prime192v2; case ECC_PRIME192V3_OID: return NID_X9_62_prime192v3; case ECC_PRIME239V1_OID: return NID_X9_62_prime239v1; case ECC_PRIME239V2_OID: return NID_X9_62_prime239v2; case ECC_PRIME239V3_OID: return NID_X9_62_prime239v3; case ECC_SECP256R1_OID: return NID_X9_62_prime256v1; case ECC_SECP112R1_OID: return NID_secp112r1; case ECC_SECP112R2_OID: return NID_secp112r2; case ECC_SECP128R1_OID: return NID_secp128r1; case ECC_SECP128R2_OID: return NID_secp128r2; case ECC_SECP160R1_OID: return NID_secp160r1; case ECC_SECP160R2_OID: return NID_secp160r2; case ECC_SECP224R1_OID: return NID_secp224r1; case ECC_SECP384R1_OID: return NID_secp384r1; case ECC_SECP521R1_OID: return NID_secp521r1; case ECC_SECP160K1_OID: return NID_secp160k1; case ECC_SECP192K1_OID: return NID_secp192k1; case ECC_SECP224K1_OID: return NID_secp224k1; case ECC_SECP256K1_OID: return NID_secp256k1; case ECC_BRAINPOOLP160R1_OID: return NID_brainpoolP160r1; case ECC_BRAINPOOLP192R1_OID: return NID_brainpoolP192r1; case ECC_BRAINPOOLP224R1_OID: return NID_brainpoolP224r1; case ECC_BRAINPOOLP256R1_OID: return NID_brainpoolP256r1; case ECC_BRAINPOOLP320R1_OID: return NID_brainpoolP320r1; case ECC_BRAINPOOLP384R1_OID: return NID_brainpoolP384r1; case ECC_BRAINPOOLP512R1_OID: return NID_brainpoolP512r1; } break; #endif /* HAVE_ECC */ /* oidBlkType */ case oidBlkType: switch (oid) { #ifdef WOLFSSL_AES_128 case AES128CBCb: return AES128CBCb; #endif #ifdef WOLFSSL_AES_192 case AES192CBCb: return AES192CBCb; #endif #ifdef WOLFSSL_AES_256 case AES256CBCb: return AES256CBCb; #endif #ifndef NO_DES3 case DESb: return NID_des; case DES3b: return NID_des3; #endif } break; #ifdef HAVE_OCSP case oidOcspType: switch (oid) { case OCSP_BASIC_OID: return NID_id_pkix_OCSP_basic; case OCSP_NONCE_OID: return OCSP_NONCE_OID; } break; #endif /* HAVE_OCSP */ /* oidCertExtType */ case oidCertExtType: switch (oid) { case BASIC_CA_OID: return BASIC_CA_OID; case ALT_NAMES_OID: return ALT_NAMES_OID; case CRL_DIST_OID: return CRL_DIST_OID; case AUTH_INFO_OID: return AUTH_INFO_OID; case AUTH_KEY_OID: return AUTH_KEY_OID; case SUBJ_KEY_OID: return SUBJ_KEY_OID; case INHIBIT_ANY_OID: return INHIBIT_ANY_OID; case KEY_USAGE_OID: return NID_key_usage; case NAME_CONS_OID: return NID_name_constraints; case CERT_POLICY_OID: return NID_certificate_policies; } break; /* oidCertAuthInfoType */ case oidCertAuthInfoType: switch (oid) { case AIA_OCSP_OID: return AIA_OCSP_OID; case AIA_CA_ISSUER_OID: return AIA_CA_ISSUER_OID; } break; /* oidCertPolicyType */ case oidCertPolicyType: switch (oid) { case CP_ANY_OID: return NID_any_policy; } break; /* oidCertAltNameType */ case oidCertAltNameType: switch (oid) { case HW_NAME_OID: return NID_hw_name_oid; } break; /* oidCertKeyUseType */ case oidCertKeyUseType: switch (oid) { case EKU_ANY_OID: return NID_anyExtendedKeyUsage; case EKU_SERVER_AUTH_OID: return EKU_SERVER_AUTH_OID; case EKU_CLIENT_AUTH_OID: return EKU_CLIENT_AUTH_OID; case EKU_OCSP_SIGN_OID: return EKU_OCSP_SIGN_OID; } break; /* oidKdfType */ case oidKdfType: switch (oid) { case PBKDF2_OID: return PBKDF2_OID; } break; /* oidPBEType */ case oidPBEType: switch (oid) { case PBE_SHA1_RC4_128: return PBE_SHA1_RC4_128; case PBE_SHA1_DES: return PBE_SHA1_DES; case PBE_SHA1_DES3: return PBE_SHA1_DES3; } break; /* oidKeyWrapType */ case oidKeyWrapType: switch (oid) { #ifdef WOLFSSL_AES_128 case AES128_WRAP: return AES128_WRAP; #endif #ifdef WOLFSSL_AES_192 case AES192_WRAP: return AES192_WRAP; #endif #ifdef WOLFSSL_AES_256 case AES256_WRAP: return AES256_WRAP; #endif } break; /* oidCmsKeyAgreeType */ case oidCmsKeyAgreeType: switch (oid) { #ifndef NO_SHA case dhSinglePass_stdDH_sha1kdf_scheme: return dhSinglePass_stdDH_sha1kdf_scheme; #endif #ifdef WOLFSSL_SHA224 case dhSinglePass_stdDH_sha224kdf_scheme: return dhSinglePass_stdDH_sha224kdf_scheme; #endif #ifndef NO_SHA256 case dhSinglePass_stdDH_sha256kdf_scheme: return dhSinglePass_stdDH_sha256kdf_scheme; #endif #ifdef WOLFSSL_SHA384 case dhSinglePass_stdDH_sha384kdf_scheme: return dhSinglePass_stdDH_sha384kdf_scheme; #endif #ifdef WOLFSSL_SHA512 case dhSinglePass_stdDH_sha512kdf_scheme: return dhSinglePass_stdDH_sha512kdf_scheme; #endif } break; default: WOLFSSL_MSG("NID not in table"); return -1; } return -1; } /* when calling SetIndividualInternal, mpi should be cleared by caller if no * longer used. ie mp_free(mpi). This is to free data when fastmath is * disabled since a copy of mpi is made by this function and placed into bn. */ int SetIndividualInternal(WOLFSSL_BIGNUM* bn, mp_int* mpi) { WOLFSSL_MSG("Entering SetIndividualInternal"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FATAL_ERROR; } if (mpi == NULL || (mp_init(mpi) != MP_OKAY)) { WOLFSSL_MSG("mpi NULL error"); return WOLFSSL_FATAL_ERROR; } if (mp_copy((mp_int*)bn->internal, mpi) != MP_OKAY) { WOLFSSL_MSG("mp_copy error"); return WOLFSSL_FATAL_ERROR; } return WOLFSSL_SUCCESS; } #ifndef NO_ASN WOLFSSL_BIGNUM *wolfSSL_ASN1_INTEGER_to_BN(const WOLFSSL_ASN1_INTEGER *ai, WOLFSSL_BIGNUM *bn) { mp_int mpi; word32 idx = 0; int ret; WOLFSSL_ENTER("wolfSSL_ASN1_INTEGER_to_BN"); if (ai == NULL) { return NULL; } ret = GetInt(&mpi, ai->data, &idx, ai->dataMax); if (ret != 0) { #ifdef WOLFSSL_QT mp_init(&mpi); /* must init mpi */ /* Serial number in QT starts at index 0 of data */ if (mp_read_unsigned_bin(&mpi, (byte*)ai->data, ai->length) != 0) { mp_clear(&mpi); return NULL; } #else /* expecting ASN1 format for INTEGER */ WOLFSSL_LEAVE("wolfSSL_ASN1_INTEGER_to_BN", ret); return NULL; #endif } /* mp_clear needs called because mpi is copied and causes memory leak with * --disable-fastmath */ ret = SetIndividualExternal(&bn, &mpi); mp_clear(&mpi); if (ret != WOLFSSL_SUCCESS) { return NULL; } return bn; } #endif /* !NO_ASN */ #if !defined(NO_DSA) && !defined(NO_DH) WOLFSSL_DH *wolfSSL_DSA_dup_DH(const WOLFSSL_DSA *dsa) { WOLFSSL_DH* dh; DhKey* key; WOLFSSL_ENTER("wolfSSL_DSA_dup_DH"); if (dsa == NULL) { return NULL; } dh = wolfSSL_DH_new(); if (dh == NULL) { return NULL; } key = (DhKey*)dh->internal; if (dsa->p != NULL && SetIndividualInternal(((WOLFSSL_DSA*)dsa)->p, &key->p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa p key error"); wolfSSL_DH_free(dh); return NULL; } if (dsa->g != NULL && SetIndividualInternal(((WOLFSSL_DSA*)dsa)->g, &key->g) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa g key error"); wolfSSL_DH_free(dh); return NULL; } if (SetIndividualExternal(&dh->p, &key->p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa p key error"); wolfSSL_DH_free(dh); return NULL; } if (SetIndividualExternal(&dh->g, &key->g) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("dsa g key error"); wolfSSL_DH_free(dh); return NULL; } return dh; } #endif /* !NO_DSA && !NO_DH */ #ifndef NO_RSA #if !defined(HAVE_USER_RSA) && !defined(HAVE_FAST_RSA) /* Openssl -> WolfSSL */ int SetRsaInternal(WOLFSSL_RSA* rsa) { RsaKey* key; WOLFSSL_MSG("Entering SetRsaInternal"); if (rsa == NULL || rsa->internal == NULL) { WOLFSSL_MSG("rsa key NULL error"); return WOLFSSL_FATAL_ERROR; } key = (RsaKey*)rsa->internal; if (SetIndividualInternal(rsa->n, &key->n) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa n key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualInternal(rsa->e, &key->e) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa e key error"); return WOLFSSL_FATAL_ERROR; } /* public key */ key->type = RSA_PUBLIC; if (rsa->d != NULL) { if (SetIndividualInternal(rsa->d, &key->d) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa d key error"); return WOLFSSL_FATAL_ERROR; } /* private key */ key->type = RSA_PRIVATE; } if (rsa->p != NULL && SetIndividualInternal(rsa->p, &key->p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa p key error"); return WOLFSSL_FATAL_ERROR; } if (rsa->q != NULL && SetIndividualInternal(rsa->q, &key->q) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa q key error"); return WOLFSSL_FATAL_ERROR; } #ifndef RSA_LOW_MEM if (rsa->dmp1 != NULL && SetIndividualInternal(rsa->dmp1, &key->dP) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa dP key error"); return WOLFSSL_FATAL_ERROR; } if (rsa->dmq1 != NULL && SetIndividualInternal(rsa->dmq1, &key->dQ) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa dQ key error"); return WOLFSSL_FATAL_ERROR; } if (rsa->iqmp != NULL && SetIndividualInternal(rsa->iqmp, &key->u) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa u key error"); return WOLFSSL_FATAL_ERROR; } #endif /* !RSA_LOW_MEM */ rsa->inSet = 1; return WOLFSSL_SUCCESS; } /* SSL_SUCCESS on ok */ #ifndef NO_WOLFSSL_STUB int wolfSSL_RSA_blinding_on(WOLFSSL_RSA* rsa, WOLFSSL_BN_CTX* bn) { (void)rsa; (void)bn; WOLFSSL_STUB("RSA_blinding_on"); WOLFSSL_MSG("wolfSSL_RSA_blinding_on"); return WOLFSSL_SUCCESS; /* on by default */ } #endif /* return compliant with OpenSSL * size of encrypted data if success , -1 if error */ int wolfSSL_RSA_public_encrypt(int len, const unsigned char* fr, unsigned char* to, WOLFSSL_RSA* rsa, int padding) { int initTmpRng = 0; WC_RNG *rng = NULL; int outLen; int ret = 0; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; #else WC_RNG _tmpRNG[1]; WC_RNG* tmpRNG = _tmpRNG; #endif #if !defined(HAVE_FIPS) && !defined(HAVE_USER_RSA) && !defined(HAVE_FAST_RSA) int mgf = WC_MGF1NONE; enum wc_HashType hash = WC_HASH_TYPE_NONE; #endif WOLFSSL_MSG("wolfSSL_RSA_public_encrypt"); /* Check and remap the padding to internal values, if needed. */ #if !defined(HAVE_FIPS) && !defined(HAVE_USER_RSA) && !defined(HAVE_FAST_RSA) if (padding == RSA_PKCS1_PADDING) padding = WC_RSA_PKCSV15_PAD; else if (padding == RSA_PKCS1_OAEP_PADDING) { padding = WC_RSA_OAEP_PAD; hash = WC_HASH_TYPE_SHA; mgf = WC_MGF1SHA1; } else if (padding == RSA_PKCS1_PSS_PADDING) { padding = WC_RSA_PSS_PAD; hash = WC_HASH_TYPE_SHA256; mgf = WC_MGF1SHA256; } else if (padding == RSA_NO_PADDING) { padding = WC_RSA_NO_PAD; } #else if (padding == RSA_PKCS1_PADDING) ; #endif else { WOLFSSL_MSG("wolfSSL_RSA_public_encrypt unsupported padding"); return 0; } if (rsa->inSet == 0) { if (SetRsaInternal(rsa) != SSL_SUCCESS) { WOLFSSL_MSG("SetRsaInternal failed"); return 0; } } outLen = wolfSSL_RSA_size(rsa); rng = WOLFSSL_RSA_GetRNG(rsa, (WC_RNG**)&tmpRNG, &initTmpRng); if (outLen == 0) { WOLFSSL_MSG("Bad RSA size"); } if (rng) { #if !defined(HAVE_FIPS) && !defined(HAVE_USER_RSA) && !defined(HAVE_FAST_RSA) ret = wc_RsaPublicEncrypt_ex(fr, len, to, outLen, (RsaKey*)rsa->internal, rng, padding, hash, mgf, NULL, 0); #else ret = wc_RsaPublicEncrypt(fr, len, to, outLen, (RsaKey*)rsa->internal, rng); #endif if (ret <= 0) { WOLFSSL_MSG("Bad Rsa Encrypt"); } if (len <= 0) { WOLFSSL_MSG("Bad Rsa Encrypt"); } } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK if (tmpRNG) XFREE(tmpRNG, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif if (ret >= 0) WOLFSSL_MSG("wolfSSL_RSA_public_encrypt success"); else { WOLFSSL_MSG("wolfSSL_RSA_public_encrypt failed"); ret = WOLFSSL_FATAL_ERROR; /* return -1 on error case */ } return ret; } /* return compliant with OpenSSL * size of plain recovered data if success , -1 if error */ int wolfSSL_RSA_private_decrypt(int len, const unsigned char* fr, unsigned char* to, WOLFSSL_RSA* rsa, int padding) { int outLen; int ret = 0; #if !defined(HAVE_FIPS) && !defined(HAVE_USER_RSA) && !defined(HAVE_FAST_RSA) int mgf = WC_MGF1NONE; enum wc_HashType hash = WC_HASH_TYPE_NONE; #endif WOLFSSL_MSG("wolfSSL_RSA_private_decrypt"); #if !defined(HAVE_FIPS) && !defined(HAVE_USER_RSA) && !defined(HAVE_FAST_RSA) if (padding == RSA_PKCS1_PADDING) padding = WC_RSA_PKCSV15_PAD; else if (padding == RSA_PKCS1_OAEP_PADDING) { padding = WC_RSA_OAEP_PAD; hash = WC_HASH_TYPE_SHA; mgf = WC_MGF1SHA1; } else if (padding == RSA_PKCS1_PSS_PADDING) { padding = WC_RSA_PSS_PAD; hash = WC_HASH_TYPE_SHA256; mgf = WC_MGF1SHA256; } else if (padding == RSA_NO_PADDING) { padding = WC_RSA_NO_PAD; } #else if (padding == RSA_PKCS1_PADDING) ; #endif else { WOLFSSL_MSG("wolfSSL_RSA_private_decrypt unsupported padding"); return 0; } if (rsa->inSet == 0) { if (SetRsaInternal(rsa) != SSL_SUCCESS) { WOLFSSL_MSG("SetRsaInternal failed"); return 0; } } outLen = wolfSSL_RSA_size(rsa); if (outLen == 0) { WOLFSSL_MSG("Bad RSA size"); } /* size of 'to' buffer must be size of RSA key */ #if !defined(HAVE_FIPS) && !defined(HAVE_USER_RSA) && !defined(HAVE_FAST_RSA) ret = wc_RsaPrivateDecrypt_ex(fr, len, to, outLen, (RsaKey*)rsa->internal, padding, hash, mgf, NULL, 0); #else ret = wc_RsaPrivateDecrypt(fr, len, to, outLen, (RsaKey*)rsa->internal); #endif if (len <= 0) { WOLFSSL_MSG("Bad Rsa Decrypt"); } if (ret > 0) WOLFSSL_MSG("wolfSSL_RSA_private_decrypt success"); else { WOLFSSL_MSG("wolfSSL_RSA_private_decrypt failed"); ret = WOLFSSL_FATAL_ERROR; } return ret; } #if !defined(_WIN32) && !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) int wolfSSL_RSA_public_decrypt(int flen, const unsigned char* from, unsigned char* to, WOLFSSL_RSA* rsa, int padding) { int tlen = 0; int pad_type; WOLFSSL_ENTER("wolfSSL_RSA_public_decrypt"); if (rsa == NULL || rsa->internal == NULL || from == NULL) { WOLFSSL_MSG("Bad function arguments"); return WOLFSSL_FAILURE; } switch (padding) { case RSA_PKCS1_PADDING: pad_type = WC_RSA_PKCSV15_PAD; break; case RSA_PKCS1_OAEP_PADDING: pad_type = WC_RSA_OAEP_PAD; break; case RSA_PKCS1_PSS_PADDING: pad_type = WC_RSA_PSS_PAD; break; case RSA_NO_PADDING: pad_type = WC_RSA_NO_PAD; break; default: WOLFSSL_MSG("wolfSSL_RSA_public_decrypt unsupported padding"); return WOLFSSL_FAILURE; } if (rsa->inSet == 0) { WOLFSSL_MSG("No RSA internal set, do it"); if (SetRsaInternal(rsa) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("SetRsaInternal failed"); return WOLFSSL_FAILURE; } } /* size of 'to' buffer must be size of RSA key */ tlen = wc_RsaSSL_Verify_ex(from, flen, to, wolfSSL_RSA_size(rsa), (RsaKey*)rsa->internal, pad_type); if (tlen <= 0) WOLFSSL_MSG("wolfSSL_RSA_public_decrypt failed"); else { WOLFSSL_MSG("wolfSSL_RSA_public_decrypt success"); } return tlen; } #endif /* !defined(_WIN32) && !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) */ /* RSA private encrypt calls wc_RsaSSL_Sign. Similar function set up as RSA * public decrypt. * * len Length of input buffer * in Input buffer to sign * out Output buffer (expected to be greater than or equal to RSA key size) * rsa Key to use for encryption * padding Type of RSA padding to use. */ int wolfSSL_RSA_private_encrypt(int len, unsigned char* in, unsigned char* out, WOLFSSL_RSA* rsa, int padding) { int sz = 0; WC_RNG* rng = NULL; #if !defined(WC_RSA_BLINDING) || defined(HAVE_USER_RSA) WC_RNG rng_lcl; #endif RsaKey* key; WOLFSSL_MSG("wolfSSL_RSA_private_encrypt"); if (len < 0 || rsa == NULL || rsa->internal == NULL || in == NULL) { WOLFSSL_MSG("Bad function arguments"); return 0; } if (padding != RSA_PKCS1_PADDING && padding != RSA_PKCS1_PSS_PADDING) { WOLFSSL_MSG("wolfSSL_RSA_private_encrypt unsupported padding"); return 0; } if (rsa->inSet == 0) { WOLFSSL_MSG("Setting internal RSA structure"); if (SetRsaInternal(rsa) != SSL_SUCCESS) { WOLFSSL_MSG("SetRsaInternal failed"); return 0; } } key = (RsaKey*)rsa->internal; #if defined(WC_RSA_BLINDING) && !defined(HAVE_USER_RSA) rng = key->rng; #else rng = &rng_lcl; #ifndef HAVE_FIPS if (wc_InitRng_ex(rng, key->heap, INVALID_DEVID) != 0) #else if (wc_InitRng(rng) != 0) #endif { WOLFSSL_MSG("Error with random number"); return SSL_FATAL_ERROR; } #endif /* size of output buffer must be size of RSA key */ sz = wc_RsaSSL_Sign(in, (word32)len, out, wolfSSL_RSA_size(rsa), key, rng); #if !defined(WC_RSA_BLINDING) || defined(HAVE_USER_RSA) if (wc_FreeRng(rng) != 0) { WOLFSSL_MSG("Error freeing random number generator"); return SSL_FATAL_ERROR; } #endif if (sz <= 0) { WOLFSSL_LEAVE("wolfSSL_RSA_private_encrypt", sz); return 0; } return sz; } #endif /* HAVE_USER_RSA */ #endif /* frees all nodes in the current threads error queue * * id thread id. ERR_remove_state is depreciated and id is ignored. The * current threads queue will be free'd. */ void wolfSSL_ERR_remove_state(unsigned long id) { WOLFSSL_ENTER("wolfSSL_ERR_remove_state"); (void)id; if (wc_ERR_remove_state() != 0) { WOLFSSL_MSG("Error with removing the state"); } } WOLFSSL_BN_CTX* wolfSSL_BN_CTX_new(void) { static int ctx; /* wolfcrypt doesn't now need ctx */ WOLFSSL_MSG("wolfSSL_BN_CTX_new"); return (WOLFSSL_BN_CTX*)&ctx; } void wolfSSL_BN_CTX_init(WOLFSSL_BN_CTX* ctx) { (void)ctx; WOLFSSL_MSG("wolfSSL_BN_CTX_init"); } void wolfSSL_BN_CTX_free(WOLFSSL_BN_CTX* ctx) { (void)ctx; WOLFSSL_MSG("wolfSSL_BN_CTX_free"); /* do free since static ctx that does nothing */ } /* WOLFSSL_SUCCESS on ok */ int wolfSSL_BN_sub(WOLFSSL_BIGNUM* r, const WOLFSSL_BIGNUM* a, const WOLFSSL_BIGNUM* b) { WOLFSSL_MSG("wolfSSL_BN_sub"); if (r == NULL || a == NULL || b == NULL) return 0; if (mp_sub((mp_int*)a->internal,(mp_int*)b->internal, (mp_int*)r->internal) == MP_OKAY) return WOLFSSL_SUCCESS; WOLFSSL_MSG("wolfSSL_BN_sub mp_sub failed"); return 0; } /* WOLFSSL_SUCCESS on ok */ int wolfSSL_BN_mod(WOLFSSL_BIGNUM* r, const WOLFSSL_BIGNUM* a, const WOLFSSL_BIGNUM* b, const WOLFSSL_BN_CTX* c) { (void)c; WOLFSSL_MSG("wolfSSL_BN_mod"); if (r == NULL || a == NULL || b == NULL) return 0; if (mp_mod((mp_int*)a->internal,(mp_int*)b->internal, (mp_int*)r->internal) == MP_OKAY) return WOLFSSL_SUCCESS; WOLFSSL_MSG("wolfSSL_BN_mod mp_mod failed"); return 0; } /* r = (a^p) % m */ int wolfSSL_BN_mod_exp(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *a, const WOLFSSL_BIGNUM *p, const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx) { int ret; WOLFSSL_ENTER("wolfSSL_BN_mod_exp"); (void) ctx; if (r == NULL || a == NULL || p == NULL || m == NULL) { WOLFSSL_MSG("Bad Argument"); return WOLFSSL_FAILURE; } if ((ret = mp_exptmod((mp_int*)a->internal,(mp_int*)p->internal, (mp_int*)m->internal, (mp_int*)r->internal)) == MP_OKAY) { return WOLFSSL_SUCCESS; } WOLFSSL_LEAVE("wolfSSL_BN_mod_exp", ret); (void)ret; return WOLFSSL_FAILURE; } /* r = (a * p) % m */ int wolfSSL_BN_mod_mul(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *a, const WOLFSSL_BIGNUM *p, const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx) { int ret; WOLFSSL_ENTER("wolfSSL_BN_mod_mul"); (void) ctx; if (r == NULL || a == NULL || p == NULL || m == NULL) { WOLFSSL_MSG("Bad Argument"); return SSL_FAILURE; } if ((ret = mp_mulmod((mp_int*)a->internal,(mp_int*)p->internal, (mp_int*)m->internal, (mp_int*)r->internal)) == MP_OKAY) { return SSL_SUCCESS; } WOLFSSL_LEAVE("wolfSSL_BN_mod_mul", ret); (void)ret; return SSL_FAILURE; } #ifdef OPENSSL_EXTRA const WOLFSSL_BIGNUM* wolfSSL_BN_value_one(void) { WOLFSSL_MSG("wolfSSL_BN_value_one"); if (bn_one == NULL) { bn_one = wolfSSL_BN_new(); if (bn_one) { if (mp_set_int((mp_int*)bn_one->internal, 1) != MP_OKAY) { /* handle error by freeing BN and returning NULL */ wolfSSL_BN_free(bn_one); bn_one = NULL; } } } return bn_one; } #endif /* return compliant with OpenSSL * size of BIGNUM in bytes, 0 if error */ int wolfSSL_BN_num_bytes(const WOLFSSL_BIGNUM* bn) { WOLFSSL_ENTER("wolfSSL_BN_num_bytes"); if (bn == NULL || bn->internal == NULL) return WOLFSSL_FAILURE; return mp_unsigned_bin_size((mp_int*)bn->internal); } /* return compliant with OpenSSL * size of BIGNUM in bits, 0 if error */ int wolfSSL_BN_num_bits(const WOLFSSL_BIGNUM* bn) { WOLFSSL_ENTER("wolfSSL_BN_num_bits"); if (bn == NULL || bn->internal == NULL) return WOLFSSL_FAILURE; return mp_count_bits((mp_int*)bn->internal); } int wolfSSL_BN_is_negative(const WOLFSSL_BIGNUM* bn) { if (bn == NULL) return WOLFSSL_FAILURE; return mp_isneg((mp_int*)bn->internal); } /* return compliant with OpenSSL * 1 if BIGNUM is zero, 0 else */ int wolfSSL_BN_is_zero(const WOLFSSL_BIGNUM* bn) { WOLFSSL_MSG("wolfSSL_BN_is_zero"); if (bn == NULL || bn->internal == NULL) return WOLFSSL_FAILURE; if (mp_iszero((mp_int*)bn->internal) == MP_YES) return WOLFSSL_SUCCESS; return WOLFSSL_FAILURE; } /* return compliant with OpenSSL * 1 if BIGNUM is one, 0 else */ int wolfSSL_BN_is_one(const WOLFSSL_BIGNUM* bn) { WOLFSSL_MSG("wolfSSL_BN_is_one"); if (bn == NULL || bn->internal == NULL) return WOLFSSL_FAILURE; if (mp_cmp_d((mp_int*)bn->internal, 1) == MP_EQ) return WOLFSSL_SUCCESS; return WOLFSSL_FAILURE; } /* return compliant with OpenSSL * 1 if BIGNUM is odd, 0 else */ int wolfSSL_BN_is_odd(const WOLFSSL_BIGNUM* bn) { WOLFSSL_MSG("wolfSSL_BN_is_odd"); if (bn == NULL || bn->internal == NULL) return WOLFSSL_FAILURE; if (mp_isodd((mp_int*)bn->internal) == MP_YES) return WOLFSSL_SUCCESS; return WOLFSSL_FAILURE; } /* return compliant with OpenSSL * 1 if BIGNUM is word, 0 else */ int wolfSSL_BN_is_word(const WOLFSSL_BIGNUM* bn, WOLFSSL_BN_ULONG w) { WOLFSSL_ENTER("wolfSSL_BN_is_word"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } if (mp_isword((mp_int*)bn->internal, w) == MP_YES) { return WOLFSSL_SUCCESS; } return WOLFSSL_FAILURE; } /* return compliant with OpenSSL * -1 if a < b, 0 if a == b and 1 if a > b */ int wolfSSL_BN_cmp(const WOLFSSL_BIGNUM* a, const WOLFSSL_BIGNUM* b) { int ret; WOLFSSL_MSG("wolfSSL_BN_cmp"); if (a == NULL || a->internal == NULL || b == NULL || b->internal == NULL) return WOLFSSL_FATAL_ERROR; ret = mp_cmp((mp_int*)a->internal, (mp_int*)b->internal); return (ret == MP_EQ ? 0 : (ret == MP_GT ? 1 : -1)); } /* return compliant with OpenSSL * length of BIGNUM in bytes, -1 if error */ int wolfSSL_BN_bn2bin(const WOLFSSL_BIGNUM* bn, unsigned char* r) { WOLFSSL_MSG("wolfSSL_BN_bn2bin"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("NULL bn error"); return WOLFSSL_FATAL_ERROR; } if (r == NULL) return mp_unsigned_bin_size((mp_int*)bn->internal); if (mp_to_unsigned_bin((mp_int*)bn->internal, r) != MP_OKAY) { WOLFSSL_MSG("mp_to_unsigned_bin error"); return WOLFSSL_FATAL_ERROR; } return mp_unsigned_bin_size((mp_int*)bn->internal); } WOLFSSL_BIGNUM* wolfSSL_BN_bin2bn(const unsigned char* str, int len, WOLFSSL_BIGNUM* ret) { int weOwn = 0; WOLFSSL_MSG("wolfSSL_BN_bin2bn"); /* if ret is null create a BN */ if (ret == NULL) { ret = wolfSSL_BN_new(); weOwn = 1; if (ret == NULL) return NULL; } /* check ret and ret->internal then read in value */ if (ret && ret->internal) { if (mp_read_unsigned_bin((mp_int*)ret->internal, str, len) != 0) { WOLFSSL_MSG("mp_read_unsigned_bin failure"); if (weOwn) wolfSSL_BN_free(ret); return NULL; } } else { return NULL; } return ret; } /* return compliant with OpenSSL * 1 if success, 0 if error */ #ifndef NO_WOLFSSL_STUB int wolfSSL_mask_bits(WOLFSSL_BIGNUM* bn, int n) { (void)bn; (void)n; WOLFSSL_ENTER("wolfSSL_BN_mask_bits"); WOLFSSL_STUB("BN_mask_bits"); return SSL_FAILURE; } #endif /* WOLFSSL_SUCCESS on ok */ int wolfSSL_BN_rand(WOLFSSL_BIGNUM* bn, int bits, int top, int bottom) { int ret = 0; int len = bits / 8; int initTmpRng = 0; WC_RNG* rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; byte* buff = NULL; #else WC_RNG tmpRNG[1]; byte buff[1024]; #endif (void)top; (void)bottom; WOLFSSL_MSG("wolfSSL_BN_rand"); if (bits % 8) len++; #ifdef WOLFSSL_SMALL_STACK buff = (byte*)XMALLOC(1024, NULL, DYNAMIC_TYPE_TMP_BUFFER); tmpRNG = (WC_RNG*) XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (buff == NULL || tmpRNG == NULL) { XFREE(buff, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); return ret; } #endif if (bn == NULL || bn->internal == NULL) WOLFSSL_MSG("Bad function arguments"); else if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else if (initGlobalRNG) rng = &globalRNG; if (rng) { if (wc_RNG_GenerateBlock(rng, buff, len) != 0) WOLFSSL_MSG("Bad wc_RNG_GenerateBlock"); else { buff[0] |= 0x80 | 0x40; buff[len-1] |= 0x01; if (mp_read_unsigned_bin((mp_int*)bn->internal,buff,len) != MP_OKAY) WOLFSSL_MSG("mp read bin failed"); else ret = WOLFSSL_SUCCESS; } } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(buff, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif return ret; } /* WOLFSSL_SUCCESS on ok * code is same as wolfSSL_BN_rand except for how top and bottom is handled. * top -1 then leave most sig bit alone * top 0 then most sig is set to 1 * top is 1 then first two most sig bits are 1 * * bottom is hot then odd number */ int wolfSSL_BN_pseudo_rand(WOLFSSL_BIGNUM* bn, int bits, int top, int bottom) { int ret = 0; int len = bits / 8; int initTmpRng = 0; WC_RNG* rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; byte* buff = NULL; #else WC_RNG tmpRNG[1]; byte buff[1024]; #endif WOLFSSL_MSG("wolfSSL_BN_rand"); if (bits % 8) len++; #ifdef WOLFSSL_SMALL_STACK buff = (byte*)XMALLOC(1024, NULL, DYNAMIC_TYPE_TMP_BUFFER); tmpRNG = (WC_RNG*) XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_TMP_BUFFER); if (buff == NULL || tmpRNG == NULL) { XFREE(buff, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(tmpRNG, NULL, DYNAMIC_TYPE_TMP_BUFFER); return ret; } #endif if (bn == NULL || bn->internal == NULL) WOLFSSL_MSG("Bad function arguments"); else if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else if (initGlobalRNG) rng = &globalRNG; if (rng) { if (wc_RNG_GenerateBlock(rng, buff, len) != 0) WOLFSSL_MSG("Bad wc_RNG_GenerateBlock"); else { switch (top) { case -1: break; case 0: buff[0] |= 0x80; break; case 1: buff[0] |= 0x80 | 0x40; break; } if (bottom == 1) { buff[len-1] |= 0x01; } if (mp_read_unsigned_bin((mp_int*)bn->internal,buff,len) != MP_OKAY) WOLFSSL_MSG("mp read bin failed"); else ret = WOLFSSL_SUCCESS; } } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(buff, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(tmpRNG, NULL, DYNAMIC_TYPE_TMP_BUFFER); #endif return ret; } /* return code compliant with OpenSSL : * 1 if bit set, 0 else */ int wolfSSL_BN_is_bit_set(const WOLFSSL_BIGNUM* bn, int n) { if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } return mp_is_bit_set((mp_int*)bn->internal, (mp_digit)n); } /* return code compliant with OpenSSL : * 1 if success, 0 else */ int wolfSSL_BN_set_bit(WOLFSSL_BIGNUM* bn, int n) { if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } if (mp_set_bit((mp_int*)bn->internal, n) != MP_OKAY) { WOLFSSL_MSG("mp_set_bit error"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } int wolfSSL_BN_clear_bit(WOLFSSL_BIGNUM* bn, int n) { int ret = WOLFSSL_FAILURE; #ifndef WOLFSSL_SMALL_STACK mp_int tmp[1]; #else mp_int* tmp = NULL; #endif if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); goto cleanup; } if (mp_is_bit_set((mp_int*)bn->internal, n)) { #ifdef WOLFSSL_SMALL_STACK tmp = (mp_int*)XMALLOC(sizeof(mp_int), NULL, DYNAMIC_TYPE_BIGINT); if (tmp == NULL) { goto cleanup; } #endif if (mp_init(tmp) != MP_OKAY) { goto cleanup; } if (mp_set_bit(tmp, n) != MP_OKAY) { goto cleanup; } if (mp_sub((mp_int*)bn->internal, tmp, (mp_int*)bn->internal) != MP_OKAY) { goto cleanup; } } ret = WOLFSSL_SUCCESS; cleanup: mp_clear(tmp); #ifdef WOLFSSL_SMALL_STACK if (tmp) XFREE(tmp, NULL, DYNAMIC_TYPE_BIGINT); #endif return ret; } /* WOLFSSL_SUCCESS on ok */ /* Note on use: this function expects str to be an even length. It is * converting pairs of bytes into 8-bit values. As an example, the RSA * public exponent is commonly 0x010001. To get it to convert, you need * to pass in the string "010001", it will fail if you use "10001". This * is an affect of how Base16_Decode() works. */ int wolfSSL_BN_hex2bn(WOLFSSL_BIGNUM** bn, const char* str) { int ret = 0; word32 decSz = 1024; #ifdef WOLFSSL_SMALL_STACK byte* decoded; #else byte decoded[1024]; #endif int weOwn = 0; int strLen; WOLFSSL_MSG("wolfSSL_BN_hex2bn"); #ifdef WOLFSSL_SMALL_STACK decoded = (byte*)XMALLOC(decSz, NULL, DYNAMIC_TYPE_DER); if (decoded == NULL) return ret; #endif if (str == NULL || str[0] == '\0') { WOLFSSL_MSG("Bad function argument"); ret = WOLFSSL_FAILURE; } else { strLen = (int)XSTRLEN(str); /* ignore trailing new lines */ while (str[strLen-1] == '\n' && strLen > 0) strLen--; if (Base16_Decode((byte*)str, strLen, decoded, &decSz) < 0) WOLFSSL_MSG("Bad Base16_Decode error"); else if (bn == NULL) ret = decSz; else { if (*bn == NULL) { *bn = wolfSSL_BN_new(); if (*bn != NULL) { weOwn = 1; } } if (*bn == NULL) WOLFSSL_MSG("BN new failed"); else if (wolfSSL_BN_bin2bn(decoded, decSz, *bn) == NULL) { WOLFSSL_MSG("Bad bin2bn error"); if (weOwn == 1) { wolfSSL_BN_free(*bn); /* Free new BN */ } } else ret = WOLFSSL_SUCCESS; } } #ifdef WOLFSSL_SMALL_STACK XFREE(decoded, NULL, DYNAMIC_TYPE_DER); #endif return ret; } WOLFSSL_BIGNUM* wolfSSL_BN_dup(const WOLFSSL_BIGNUM* bn) { WOLFSSL_BIGNUM* ret; WOLFSSL_MSG("wolfSSL_BN_dup"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return NULL; } ret = wolfSSL_BN_new(); if (ret == NULL) { WOLFSSL_MSG("bn new error"); return NULL; } if (mp_copy((mp_int*)bn->internal, (mp_int*)ret->internal) != MP_OKAY) { WOLFSSL_MSG("mp_copy error"); wolfSSL_BN_free(ret); return NULL; } ret->neg = bn->neg; return ret; } WOLFSSL_BIGNUM* wolfSSL_BN_copy(WOLFSSL_BIGNUM* r, const WOLFSSL_BIGNUM* bn) { WOLFSSL_MSG("wolfSSL_BN_copy"); if (r == NULL || bn == NULL) { WOLFSSL_MSG("r or bn NULL error"); return NULL; } if (mp_copy((mp_int*)bn->internal, (mp_int*)r->internal) != MP_OKAY) { WOLFSSL_MSG("mp_copy error"); return NULL; } r->neg = bn->neg; return r; } /* return code compliant with OpenSSL : * 1 if success, 0 else */ int wolfSSL_BN_set_word(WOLFSSL_BIGNUM* bn, WOLFSSL_BN_ULONG w) { WOLFSSL_MSG("wolfSSL_BN_set_word"); if (bn == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } if (mp_set_int((mp_int*)bn->internal, w) != MP_OKAY) { WOLFSSL_MSG("mp_init_set_int error"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* Returns the big number as an unsigned long if possible. * * bn big number structure to get value from * * Returns value or 0xFFFFFFFFL if bigger than unsigned long. */ unsigned long wolfSSL_BN_get_word(const WOLFSSL_BIGNUM* bn) { mp_int* mp; WOLFSSL_MSG("wolfSSL_BN_get_word"); if (bn == NULL) { WOLFSSL_MSG("Invalid argument"); return 0; } if (wolfSSL_BN_num_bytes(bn) > (int)sizeof(unsigned long)) { WOLFSSL_MSG("bignum is larger than unsigned long"); return 0xFFFFFFFFL; } mp = (mp_int*)bn->internal; return (unsigned long)(mp->dp[0]); } /* return code compliant with OpenSSL : * number length in decimal if success, 0 if error */ #ifndef NO_WOLFSSL_STUB int wolfSSL_BN_dec2bn(WOLFSSL_BIGNUM** bn, const char* str) { (void)bn; (void)str; WOLFSSL_MSG("wolfSSL_BN_dec2bn"); WOLFSSL_STUB("BN_dec2bn"); return SSL_FAILURE; } #endif #if defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY) char *wolfSSL_BN_bn2dec(const WOLFSSL_BIGNUM *bn) { int len = 0; char *buf; WOLFSSL_MSG("wolfSSL_BN_bn2dec"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return NULL; } if (mp_radix_size((mp_int*)bn->internal, MP_RADIX_DEC, &len) != MP_OKAY) { WOLFSSL_MSG("mp_radix_size failure"); return NULL; } buf = (char*) XMALLOC(len, NULL, DYNAMIC_TYPE_OPENSSL); if (buf == NULL) { WOLFSSL_MSG("BN_bn2dec malloc buffer failure"); return NULL; } if (mp_todecimal((mp_int*)bn->internal, buf) != MP_OKAY) { XFREE(buf, NULL, DYNAMIC_TYPE_ECC); return NULL; } return buf; } #else char* wolfSSL_BN_bn2dec(const WOLFSSL_BIGNUM* bn) { (void)bn; WOLFSSL_MSG("wolfSSL_BN_bn2dec"); return NULL; } #endif /* defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY) */ /* return code compliant with OpenSSL : * 1 if success, 0 else */ int wolfSSL_BN_lshift(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *bn, int n) { WOLFSSL_MSG("wolfSSL_BN_lshift"); if (r == NULL || r->internal == NULL || bn == NULL || bn->internal == NULL){ WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } if (mp_mul_2d((mp_int*)bn->internal, n, (mp_int*)r->internal) != MP_OKAY) { WOLFSSL_MSG("mp_mul_2d error"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* return code compliant with OpenSSL : * 1 if success, 0 else */ int wolfSSL_BN_rshift(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *bn, int n) { WOLFSSL_MSG("wolfSSL_BN_rshift"); if (r == NULL || r->internal == NULL || bn == NULL || bn->internal == NULL){ WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } if (mp_div_2d((mp_int*)bn->internal, n, (mp_int*)r->internal, NULL) != MP_OKAY) { WOLFSSL_MSG("mp_mul_2d error"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* return code compliant with OpenSSL : * 1 if success, 0 else */ int wolfSSL_BN_add_word(WOLFSSL_BIGNUM *bn, WOLFSSL_BN_ULONG w) { WOLFSSL_MSG("wolfSSL_BN_add_word"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } if (mp_add_d((mp_int*)bn->internal, w, (mp_int*)bn->internal) != MP_OKAY) { WOLFSSL_MSG("mp_add_d error"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* return code compliant with OpenSSL : * 1 if success, 0 else */ int wolfSSL_BN_add(WOLFSSL_BIGNUM *r, WOLFSSL_BIGNUM *a, WOLFSSL_BIGNUM *b) { WOLFSSL_MSG("wolfSSL_BN_add"); if (r == NULL || r->internal == NULL || a == NULL || a->internal == NULL || b == NULL || b->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } if (mp_add((mp_int*)a->internal, (mp_int*)b->internal, (mp_int*)r->internal) != MP_OKAY) { WOLFSSL_MSG("mp_add_d error"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* r = a + b (mod m) */ int wolfSSL_BN_mod_add(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *a, const WOLFSSL_BIGNUM *b, const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx) { (void)ctx; WOLFSSL_MSG("wolfSSL_BN_add"); if (r == NULL || r->internal == NULL || a == NULL || a->internal == NULL || b == NULL || b->internal == NULL || m == NULL || m->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } if (mp_addmod((mp_int*)a->internal, (mp_int*)b->internal, (mp_int*)m->internal, (mp_int*)r->internal) != MP_OKAY) { WOLFSSL_MSG("mp_add_d error"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #ifdef WOLFSSL_KEY_GEN /* return code compliant with OpenSSL : * 1 if prime, 0 if not, -1 if error */ int wolfSSL_BN_is_prime_ex(const WOLFSSL_BIGNUM *bn, int nbchecks, WOLFSSL_BN_CTX *ctx, WOLFSSL_BN_GENCB *cb) { WC_RNG* rng = NULL; #ifdef WOLFSSL_SMALL_STACK WC_RNG* tmpRNG = NULL; #else WC_RNG tmpRNG[1]; #endif int initTmpRng = 0; int res = MP_NO; (void)ctx; (void)cb; WOLFSSL_MSG("wolfSSL_BN_is_prime_ex"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FATAL_ERROR; } #ifdef WOLFSSL_SMALL_STACK tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (tmpRNG == NULL) return WOLFSSL_FAILURE; #endif if (wc_InitRng(tmpRNG) == 0) { rng = tmpRNG; initTmpRng = 1; } else { WOLFSSL_MSG("Bad RNG Init, trying global"); if (initGlobalRNG == 0) { WOLFSSL_MSG("Global RNG no Init"); } else rng = &globalRNG; } if (rng) { if (mp_prime_is_prime_ex((mp_int*)bn->internal, nbchecks, &res, rng) != MP_OKAY) { WOLFSSL_MSG("mp_prime_is_prime_ex error"); res = MP_NO; } } if (initTmpRng) wc_FreeRng(tmpRNG); #ifdef WOLFSSL_SMALL_STACK XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG); #endif if (res != MP_YES) { WOLFSSL_MSG("mp_prime_is_prime_ex not prime"); return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } /* return code compliant with OpenSSL : * (bn mod w) if success, -1 if error */ WOLFSSL_BN_ULONG wolfSSL_BN_mod_word(const WOLFSSL_BIGNUM *bn, WOLFSSL_BN_ULONG w) { WOLFSSL_BN_ULONG ret = 0; WOLFSSL_MSG("wolfSSL_BN_mod_word"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return (WOLFSSL_BN_ULONG)WOLFSSL_FATAL_ERROR; } if (mp_mod_d((mp_int*)bn->internal, w, &ret) != MP_OKAY) { WOLFSSL_MSG("mp_add_d error"); return (WOLFSSL_BN_ULONG)WOLFSSL_FATAL_ERROR; } return ret; } #endif /* #ifdef WOLFSSL_KEY_GEN */ char *wolfSSL_BN_bn2hex(const WOLFSSL_BIGNUM *bn) { int len = 0; char *buf; WOLFSSL_ENTER("wolfSSL_BN_bn2hex"); if (bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return NULL; } if (mp_radix_size((mp_int*)bn->internal, MP_RADIX_HEX, &len) != MP_OKAY) { WOLFSSL_MSG("mp_radix_size failure"); return NULL; } len += 1; /* add one for null terminator */ buf = (char*)XMALLOC(len, NULL, DYNAMIC_TYPE_OPENSSL); if (buf == NULL) { WOLFSSL_MSG("BN_bn2hex malloc buffer failure"); return NULL; } if (mp_tohex((mp_int*)bn->internal, buf) != MP_OKAY) { XFREE(buf, NULL, DYNAMIC_TYPE_OPENSSL); return NULL; } return buf; } #ifndef NO_FILESYSTEM /* return code compliant with OpenSSL : * 1 if success, 0 if error */ int wolfSSL_BN_print_fp(XFILE fp, const WOLFSSL_BIGNUM *bn) { char *buf; WOLFSSL_ENTER("wolfSSL_BN_print_fp"); if (fp == XBADFILE || bn == NULL || bn->internal == NULL) { WOLFSSL_MSG("bn NULL error"); return WOLFSSL_FAILURE; } buf = wolfSSL_BN_bn2hex(bn); if (buf == NULL) { WOLFSSL_MSG("wolfSSL_BN_bn2hex failure"); return WOLFSSL_FAILURE; } fprintf(fp, "%s", buf); XFREE(buf, NULL, DYNAMIC_TYPE_OPENSSL); return WOLFSSL_SUCCESS; } #endif /* !NO_FILESYSTEM */ WOLFSSL_BIGNUM *wolfSSL_BN_CTX_get(WOLFSSL_BN_CTX *ctx) { /* ctx is not used, return new Bignum */ (void)ctx; WOLFSSL_ENTER("wolfSSL_BN_CTX_get"); return wolfSSL_BN_new(); } #ifndef NO_WOLFSSL_STUB void wolfSSL_BN_CTX_start(WOLFSSL_BN_CTX *ctx) { (void)ctx; WOLFSSL_ENTER("wolfSSL_BN_CTX_start"); WOLFSSL_STUB("BN_CTX_start"); WOLFSSL_MSG("wolfSSL_BN_CTX_start TBD"); } #endif WOLFSSL_BIGNUM *wolfSSL_BN_mod_inverse(WOLFSSL_BIGNUM *r, WOLFSSL_BIGNUM *a, const WOLFSSL_BIGNUM *n, WOLFSSL_BN_CTX *ctx) { int dynamic = 0; /* ctx is not used */ (void)ctx; WOLFSSL_ENTER("wolfSSL_BN_mod_inverse"); /* check parameter */ if (r == NULL) { r = wolfSSL_BN_new(); if (r == NULL){ WOLFSSL_MSG("WolfSSL_BN_new() failed"); return NULL; } dynamic = 1; } if (a == NULL) { WOLFSSL_MSG("a NULL error"); if (dynamic == 1) { wolfSSL_BN_free(r); } return NULL; } if (n == NULL) { WOLFSSL_MSG("n NULL error"); if (dynamic == 1) { wolfSSL_BN_free(r); } return NULL; } /* Compute inverse of a modulo n and return r */ if (mp_invmod((mp_int *)a->internal,(mp_int *)n->internal, (mp_int*)r->internal) == MP_VAL){ WOLFSSL_MSG("mp_invmod() error"); if (dynamic == 1) { wolfSSL_BN_free(r); } return NULL; } return r; } #endif /* OPENSSL_EXTRA */ #if (defined(WOLFSSL_QT) || defined(OPENSSL_ALL)) && !defined(NO_ASN) static int unprintable_char(char c) { const unsigned char last_unprintable = 31; const unsigned char LF = 10; const unsigned char CR = 13; if (c <= last_unprintable && c != LF && c != CR) { return 1; } return 0; } int wolfSSL_ASN1_STRING_print(WOLFSSL_BIO *out, WOLFSSL_ASN1_STRING *str) { int i; WOLFSSL_ENTER("wolfSSL_ASN1_STRING_print"); if (out == NULL || str == NULL) return WOLFSSL_FAILURE; for (i=0; i < str->length; i++) { if (unprintable_char(str->data[i])) { str->data[i] = '.'; } } if (wolfSSL_BIO_write(out, str->data, str->length) != str->length){ return WOLFSSL_FAILURE; } return str->length; } #endif /* (WOLFSSL_QT || OPENSSL_ALL) && !NO_ASN */ #if defined(OPENSSL_EXTRA) int wolfSSL_X509_check_ca(WOLFSSL_X509 *x509) { WOLFSSL_ENTER("X509_check_ca"); if (x509 == NULL) return WOLFSSL_FAILURE; if (x509->isCa) return 1; if (x509->extKeyUsageCrit) return 4; return 0; } const char *wolfSSL_ASN1_tag2str(int tag) { static const char *const tag_label[31] = { "EOC", "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING", "NULL", "OBJECT", "OBJECT DESCRIPTOR", "EXTERNAL", "REAL", "ENUMERATED", "", "UTF8STRING", "", "", "", "SEQUENCE", "SET", "NUMERICSTRING", "PRINTABLESTRING", "T61STRING", "VIDEOTEXTSTRING", "IA5STRING", "UTCTIME", "GENERALIZEDTIME", "GRAPHICSTRING", "VISIBLESTRING", "GENERALSTRING", "UNIVERSALSTRING", "", "BMPSTRING" }; if ((tag == V_ASN1_NEG_INTEGER) || (tag == V_ASN1_NEG_ENUMERATED)) tag &= ~0x100; if (tag < 0 || tag > 30) return "(unknown)"; return tag_label[tag]; } static int check_esc_char(char c, char *esc) { char *ptr; ptr = esc; while(*ptr != 0){ if (c == *ptr) return 1; ptr++; } return 0; } int wolfSSL_ASN1_STRING_print_ex(WOLFSSL_BIO *out, WOLFSSL_ASN1_STRING *str, unsigned long flags) { size_t str_len = 0, type_len = 0; unsigned char *typebuf = NULL; const char *hash="#"; WOLFSSL_ENTER("wolfSSL_ASN1_STRING_PRINT_ex"); if (out == NULL || str == NULL) return WOLFSSL_FAILURE; /* add ASN1 type tag */ if (flags & ASN1_STRFLGS_SHOW_TYPE){ const char *tag = wolfSSL_ASN1_tag2str(str->type); /* colon len + tag len + null*/ type_len = XSTRLEN(tag) + 2; typebuf = (unsigned char *)XMALLOC(type_len , NULL, DYNAMIC_TYPE_TMP_BUFFER); if (typebuf == NULL){ WOLFSSL_MSG("memory alloc failed."); return WOLFSSL_FAILURE; } XMEMSET(typebuf, 0, type_len); XSNPRINTF((char*)typebuf, (size_t)type_len , "%s:", tag); type_len--; } /* dump hex */ if (flags & ASN1_STRFLGS_DUMP_ALL){ static const char hex_char[] = { '0', '1', '2', '3', '4', '5', '6', '7','8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; char hex_tmp[4]; char *str_ptr, *str_end; if (type_len > 0){ if (wolfSSL_BIO_write(out, typebuf, (int)type_len) != (int)type_len){ XFREE(typebuf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } str_len += type_len; } if (wolfSSL_BIO_write(out, hash, 1) != 1){ goto err_exit; } str_len++; if (flags & ASN1_STRFLGS_DUMP_DER){ hex_tmp[0] = hex_char[str->type >> 4]; hex_tmp[1] = hex_char[str->type & 0xf]; hex_tmp[2] = hex_char[str->length >> 4]; hex_tmp[3] = hex_char[str->length & 0xf]; if (wolfSSL_BIO_write(out, hex_tmp, 4) != 4){ goto err_exit; } str_len += 4; XMEMSET(hex_tmp, 0, 4); } str_ptr = str->data; str_end = str->data + str->length; while (str_ptr < str_end){ hex_tmp[0] = hex_char[*str_ptr >> 4]; hex_tmp[1] = hex_char[*str_ptr & 0xf]; if (wolfSSL_BIO_write(out, hex_tmp, 2) != 2){ goto err_exit; } str_ptr++; str_len += 2; } if (type_len > 0) XFREE(typebuf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return (int)str_len; } if (type_len > 0){ if (wolfSSL_BIO_write(out, typebuf, (int)type_len) != (int)type_len){ XFREE(typebuf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } str_len += type_len; } if (flags & ASN1_STRFLGS_ESC_2253){ char esc_ch[] = "+;<>\\"; char* esc_ptr; esc_ptr = str->data; while (*esc_ptr != 0){ if (check_esc_char(*esc_ptr, esc_ch)){ if (wolfSSL_BIO_write(out,"\\", 1) != 1) goto err_exit; str_len++; } if (wolfSSL_BIO_write(out, esc_ptr, 1) != 1) goto err_exit; str_len++; esc_ptr++; } if (type_len > 0) XFREE(typebuf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return (int)str_len; } if (wolfSSL_BIO_write(out, str->data, str->length) != str->length){ goto err_exit; } str_len += str->length; if (type_len > 0) XFREE(typebuf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return (int)str_len; err_exit: if (type_len > 0) XFREE(typebuf, NULL, DYNAMIC_TYPE_TMP_BUFFER); return WOLFSSL_FAILURE; } #if !defined(NO_ASN_TIME) && !defined(USER_TIME) && !defined(TIME_OVERRIDES) WOLFSSL_ASN1_TIME* wolfSSL_ASN1_TIME_new(void) { WOLFSSL_ASN1_TIME* ret = (WOLFSSL_ASN1_TIME*) XMALLOC(sizeof(WOLFSSL_ASN1_TIME), NULL, DYNAMIC_TYPE_OPENSSL); if (!ret) return NULL; XMEMSET(ret, 0, sizeof(WOLFSSL_ASN1_TIME)); return ret; } void wolfSSL_ASN1_TIME_free(WOLFSSL_ASN1_TIME* t) { if (t) { XFREE(t, NULL, DYNAMIC_TYPE_OPENSSL); } } WOLFSSL_ASN1_TIME* wolfSSL_ASN1_TIME_adj(WOLFSSL_ASN1_TIME *s, time_t t, int offset_day, long offset_sec) { const time_t sec_per_day = 24*60*60; struct tm* ts = NULL; struct tm* tmpTime; time_t t_adj = 0; time_t offset_day_sec = 0; #if defined(NEED_TMP_TIME) struct tm tmpTimeStorage; tmpTime = &tmpTimeStorage; #else tmpTime = NULL; #endif (void)tmpTime; WOLFSSL_ENTER("wolfSSL_ASN1_TIME_adj"); if (s == NULL){ s = wolfSSL_ASN1_TIME_new(); if (s == NULL){ return NULL; } } /* compute GMT time with offset */ offset_day_sec = offset_day * sec_per_day; t_adj = t + offset_day_sec + offset_sec; ts = (struct tm *)XGMTIME(&t_adj, tmpTime); if (ts == NULL){ WOLFSSL_MSG("failed to get time data."); XFREE(s, NULL, DYNAMIC_TYPE_OPENSSL); return NULL; } /* create ASN1 time notation */ /* UTC Time */ if (ts->tm_year >= 50 && ts->tm_year < 150){ char utc_str[ASN_UTC_TIME_SIZE]; int utc_year = 0,utc_mon,utc_day,utc_hour,utc_min,utc_sec; s->type = V_ASN1_UTCTIME; s->length = ASN_UTC_TIME_SIZE; if (ts->tm_year >= 50 && ts->tm_year < 100){ utc_year = ts->tm_year; } else if (ts->tm_year >= 100 && ts->tm_year < 150){ utc_year = ts->tm_year - 100; } utc_mon = ts->tm_mon + 1; utc_day = ts->tm_mday; utc_hour = ts->tm_hour; utc_min = ts->tm_min; utc_sec = ts->tm_sec; XSNPRINTF((char *)utc_str, sizeof(utc_str), "%02d%02d%02d%02d%02d%02dZ", utc_year, utc_mon, utc_day, utc_hour, utc_min, utc_sec); XMEMCPY(s->data, (byte *)utc_str, s->length); /* GeneralizedTime */ } else { char gt_str[ASN_GENERALIZED_TIME_MAX]; int gt_year,gt_mon,gt_day,gt_hour,gt_min,gt_sec; s->type = V_ASN1_GENERALIZEDTIME; s->length = ASN_GENERALIZED_TIME_SIZE; gt_year = ts->tm_year + 1900; gt_mon = ts->tm_mon + 1; gt_day = ts->tm_mday; gt_hour = ts->tm_hour; gt_min = ts->tm_min; gt_sec = ts->tm_sec; XSNPRINTF((char *)gt_str, sizeof(gt_str), "%4d%02d%02d%02d%02d%02dZ", gt_year, gt_mon, gt_day, gt_hour, gt_min,gt_sec); XMEMCPY(s->data, (byte *)gt_str, s->length); } return s; } #endif /* !NO_ASN_TIME && !USER_TIME && !TIME_OVERRIDES */ #ifndef NO_ASN_TIME /* not a compatibility function - length getter for opaque type */ int wolfSSL_ASN1_TIME_get_length(WOLFSSL_ASN1_TIME *t) { WOLFSSL_ENTER("wolfSSL_ASN1_TIME_get_length"); if (t == NULL) return WOLFSSL_FAILURE; return t->length; } /* not a compatibility function - data getter for opaque type */ unsigned char* wolfSSL_ASN1_TIME_get_data(WOLFSSL_ASN1_TIME *t) { WOLFSSL_ENTER("wolfSSL_ASN1_TIME_get_data"); if (t == NULL) return NULL; return t->data; } WOLFSSL_ASN1_TIME* wolfSSL_ASN1_TIME_to_generalizedtime(WOLFSSL_ASN1_TIME *t, WOLFSSL_ASN1_TIME **out) { int time_type = 0; WOLFSSL_ASN1_TIME *ret = NULL; WOLFSSL_ENTER("wolfSSL_ASN1_TIME_to_generalizedtime"); if (t == NULL) { WOLFSSL_MSG("Invalid ASN_TIME value"); } else { time_type = t->type; if (time_type != ASN_UTC_TIME && time_type != ASN_GENERALIZED_TIME){ WOLFSSL_MSG("Invalid ASN_TIME type."); } else { if (out == NULL || *out == NULL) { ret = wolfSSL_ASN1_TIME_new(); if (ret == NULL){ WOLFSSL_MSG("memory alloc failed."); } } else { ret = *out; } } } if (ret != NULL) { if (time_type == ASN_GENERALIZED_TIME){ XMEMCPY(ret->data, t->data, ASN_GENERALIZED_TIME_SIZE); } else { /* ASN_UTC_TIME */ /* convert UTC to generalized time */ ret->type = ASN_GENERALIZED_TIME; ret->length = ASN_GENERALIZED_TIME_SIZE; if (t->data[0] >= '5') { ret->data[0] = '1'; ret->data[1] = '9'; } else { ret->data[0] = '2'; ret->data[1] = '0'; } XMEMCPY(&ret->data[2], t->data, ASN_UTC_TIME_SIZE); } } return ret; } #endif /* !NO_ASN_TIME */ #ifndef NO_ASN int wolfSSL_i2c_ASN1_INTEGER(WOLFSSL_ASN1_INTEGER *a, unsigned char **pp) { unsigned char *pptr = NULL; char pad = 0 ; unsigned char pad_val = 0; int ret_size = 0; unsigned char data1 = 0; unsigned char neg = 0; int i = 0; WOLFSSL_ENTER("wolfSSL_i2c_ASN1_INTEGER"); if (a == NULL) return WOLFSSL_FAILURE; ret_size = a->intData[1]; if (ret_size == 0) ret_size = 1; else{ ret_size = (int)a->intData[1]; neg = a->negative; data1 = a->intData[2]; if (ret_size == 1 && data1 == 0) neg = 0; /* 0x80 or greater positive number in first byte */ if (!neg && (data1 > 127)){ pad = 1; pad_val = 0; } else if (neg){ /* negative number */ if (data1 > 128){ pad = 1; pad_val = 0xff; } else if (data1 == 128){ for (i = 3; i < a->intData[1] + 2; i++){ if (a->intData[i]){ pad = 1; pad_val = 0xff; break; } } } } ret_size += (int)pad; } if (pp == NULL) return ret_size; pptr = *pp; if (pad) *(pptr++) = pad_val; if (a->intData[1] == 0) *(pptr++) = 0; else if (!neg){ /* positive number */ for (i=0; i < a->intData[1]; i++){ *pptr = a->intData[i+2]; pptr++; } } else { /* negative number */ int str_len = 0; /* 0 padding from end of buffer */ str_len = (int)a->intData[1]; pptr += a->intData[1] - 1; while (!a->intData[str_len + 2] && str_len > 1){ *(pptr--) = 0; str_len--; } /* 2's complement next octet */ *(pptr--) = ((a->intData[str_len + 1]) ^ 0xff) + 1; str_len--; /* Complement any octets left */ while (str_len > 0){ *(pptr--) = a->intData[str_len + 1] ^ 0xff; str_len--; } } *pp += ret_size; return ret_size; } #endif /* !NO_ASN */ #ifndef NO_CERTS int wolfSSL_X509_CA_num(WOLFSSL_X509_STORE* store) { int i = 0; int cnt_ret = 0; Signer **table; WOLFSSL_ENTER("wolfSSL_X509_CA_num"); if (store == NULL || store->cm == NULL){ WOLFSSL_MSG("invalid parameter"); return WOLFSSL_FAILURE; } table = store->cm->caTable; if (table){ if (wc_LockMutex(&store->cm->caLock) == 0){ for (i = 0; i < CA_TABLE_SIZE; i++) { Signer* signer = table[i]; while (signer) { Signer* next = signer->next; cnt_ret++; signer = next; } } wc_UnLockMutex(&store->cm->caLock); } } return cnt_ret; } #endif /* !NO_CERTS */ long wolfSSL_X509_get_version(const WOLFSSL_X509 *x509) { int version = 0; WOLFSSL_ENTER("wolfSSL_X509_get_version"); if (x509 == NULL){ WOLFSSL_MSG("invalid parameter"); return 0L; } version = x509->version; if (version != 0) return (long)version - 1L; return 0L; } int wolfSSL_X509_get_signature_nid(const WOLFSSL_X509 *x) { if (x == NULL) return 0; return oid2nid(x->sigOID, oidSigType); } #endif /* OPENSSL_EXTRA */ #if defined(OPENSSL_EXTRA) && !defined(NO_RSA) /* return compliant with OpenSSL * RSA modulus size in bytes, -1 if error */ int wolfSSL_RSA_size(const WOLFSSL_RSA* rsa) { WOLFSSL_ENTER("wolfSSL_RSA_size"); if (rsa == NULL) return WOLFSSL_FATAL_ERROR; if (rsa->inSet == 0) { if (SetRsaInternal((WOLFSSL_RSA*)rsa) != SSL_SUCCESS) { WOLFSSL_MSG("SetRsaInternal failed"); return 0; } } return wc_RsaEncryptSize((RsaKey*)rsa->internal); } #endif #if !defined(HAVE_USER_RSA) && !defined(HAVE_FAST_RSA) && \ !defined(NO_RSA) && (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) /* WolfSSL -> OpenSSL */ int SetRsaExternal(WOLFSSL_RSA* rsa) { RsaKey* key; WOLFSSL_MSG("Entering SetRsaExternal"); if (rsa == NULL || rsa->internal == NULL) { WOLFSSL_MSG("rsa key NULL error"); return WOLFSSL_FATAL_ERROR; } key = (RsaKey*)rsa->internal; if (SetIndividualExternal(&rsa->n, &key->n) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa n key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&rsa->e, &key->e) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa e key error"); return WOLFSSL_FATAL_ERROR; } if (key->type == RSA_PRIVATE) { if (SetIndividualExternal(&rsa->d, &key->d) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa d key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&rsa->p, &key->p) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa p key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&rsa->q, &key->q) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa q key error"); return WOLFSSL_FATAL_ERROR; } #ifndef RSA_LOW_MEM if (SetIndividualExternal(&rsa->dmp1, &key->dP) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa dP key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&rsa->dmq1, &key->dQ) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa dQ key error"); return WOLFSSL_FATAL_ERROR; } if (SetIndividualExternal(&rsa->iqmp, &key->u) != WOLFSSL_SUCCESS) { WOLFSSL_MSG("rsa u key error"); return WOLFSSL_FATAL_ERROR; } #endif /* !RSA_LOW_MEM */ } rsa->exSet = 1; return WOLFSSL_SUCCESS; } #endif #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) /* when calling SetIndividualExternal, mpi should be cleared by caller if no * longer used. ie mp_free(mpi). This is to free data when fastmath is * disabled since a copy of mpi is made by this function and placed into bn. */ int SetIndividualExternal(WOLFSSL_BIGNUM** bn, mp_int* mpi) { byte dynamic = 0; WOLFSSL_MSG("Entering SetIndividualExternal"); if (mpi == NULL || bn == NULL) { WOLFSSL_MSG("mpi NULL error"); return WOLFSSL_FATAL_ERROR; } if (*bn == NULL) { *bn = wolfSSL_BN_new(); if (*bn == NULL) { WOLFSSL_MSG("SetIndividualExternal alloc failed"); return WOLFSSL_FATAL_ERROR; } dynamic = 1; } if (mp_copy(mpi, (mp_int*)((*bn)->internal)) != MP_OKAY) { WOLFSSL_MSG("mp_copy error"); if (dynamic == 1) { wolfSSL_BN_free(*bn); } return WOLFSSL_FATAL_ERROR; } return WOLFSSL_SUCCESS; } static void InitwolfSSL_BigNum(WOLFSSL_BIGNUM* bn) { if (bn) { XMEMSET(bn, 0, sizeof(WOLFSSL_BIGNUM)); bn->neg = 0; bn->internal = NULL; } } WOLFSSL_BIGNUM* wolfSSL_BN_new(void) { WOLFSSL_BIGNUM* external; mp_int* mpi; WOLFSSL_MSG("wolfSSL_BN_new"); #if !defined(USE_FAST_MATH) || defined(HAVE_WOLF_BIGINT) mpi = (mp_int*) XMALLOC(sizeof(mp_int), NULL, DYNAMIC_TYPE_BIGINT); if (mpi == NULL) { WOLFSSL_MSG("wolfSSL_BN_new malloc mpi failure"); return NULL; } #endif external = (WOLFSSL_BIGNUM*) XMALLOC(sizeof(WOLFSSL_BIGNUM), NULL, DYNAMIC_TYPE_BIGINT); if (external == NULL) { WOLFSSL_MSG("wolfSSL_BN_new malloc WOLFSSL_BIGNUM failure"); #if !defined(USE_FAST_MATH) || defined(HAVE_WOLF_BIGINT) XFREE(mpi, NULL, DYNAMIC_TYPE_BIGINT); #endif return NULL; } #if defined(USE_FAST_MATH) && !defined(HAVE_WOLF_BIGINT) mpi = &external->fp; #endif InitwolfSSL_BigNum(external); if (mp_init(mpi) != MP_OKAY) { wolfSSL_BN_free(external); return NULL; } external->internal = mpi; return external; } #if defined(USE_FAST_MATH) && !defined(HAVE_WOLF_BIGINT) /* This function works without BN_free only with TFM */ void wolfSSL_BN_init(WOLFSSL_BIGNUM* bn) { if(bn == NULL)return; WOLFSSL_MSG("wolfSSL_BN_init"); InitwolfSSL_BigNum(bn); if (mp_init(&bn->fp) != MP_OKAY) return; bn->internal = (void *)&bn->fp; } #endif void wolfSSL_BN_free(WOLFSSL_BIGNUM* bn) { WOLFSSL_MSG("wolfSSL_BN_free"); if (bn) { if (bn->internal) { mp_int* bni = (mp_int*)bn->internal; mp_free(bni); #if !defined(USE_FAST_MATH) || defined(HAVE_WOLF_BIGINT) XFREE(bn->internal, NULL, DYNAMIC_TYPE_BIGINT); #endif bn->internal = NULL; } XFREE(bn, NULL, DYNAMIC_TYPE_BIGINT); /* bn = NULL, don't try to access or double free it */ } } void wolfSSL_BN_clear_free(WOLFSSL_BIGNUM* bn) { WOLFSSL_MSG("wolfSSL_BN_clear_free"); if (bn) { if (bn->internal) { mp_int* bni = (mp_int*)bn->internal; mp_forcezero(bni); } wolfSSL_BN_free(bn); } } void wolfSSL_BN_clear(WOLFSSL_BIGNUM* bn) { WOLFSSL_MSG("wolfSSL_BN_clear"); if (bn && bn->internal) { mp_forcezero((mp_int*)bn->internal); } } #endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */ #if !defined(NO_RSA) && (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) static void InitwolfSSL_Rsa(WOLFSSL_RSA* rsa) { if (rsa) { XMEMSET(rsa, 0, sizeof(WOLFSSL_RSA)); } } void wolfSSL_RSA_free(WOLFSSL_RSA* rsa) { WOLFSSL_ENTER("wolfSSL_RSA_free"); if (rsa) { #if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL) int doFree = 0; if (wc_LockMutex(&rsa->refMutex) != 0) { WOLFSSL_MSG("Couldn't lock rsa mutex"); } /* only free if all references to it are done */ rsa->refCount--; if (rsa->refCount == 0) { doFree = 1; } wc_UnLockMutex(&rsa->refMutex); if (!doFree) { return; } wc_FreeMutex(&rsa->refMutex); #endif if (rsa->internal) { #if !defined(HAVE_FIPS) && !defined(HAVE_USER_RSA) && \ !defined(HAVE_FAST_RSA) && defined(WC_RSA_BLINDING) WC_RNG* rng; /* check if RNG is owned before freeing it */ if (rsa->ownRng) { rng = ((RsaKey*)rsa->internal)->rng; if (rng != NULL && rng != &globalRNG) { wc_FreeRng(rng); XFREE(rng, NULL, DYNAMIC_TYPE_RNG); } } #endif /* WC_RSA_BLINDING */ wc_FreeRsaKey((RsaKey*)rsa->internal); XFREE(rsa->internal, NULL, DYNAMIC_TYPE_RSA); rsa->internal = NULL; } wolfSSL_BN_free(rsa->iqmp); wolfSSL_BN_free(rsa->dmq1); wolfSSL_BN_free(rsa->dmp1); wolfSSL_BN_free(rsa->q); wolfSSL_BN_free(rsa->p); wolfSSL_BN_free(rsa->d); wolfSSL_BN_free(rsa->e); wolfSSL_BN_free(rsa->n); #ifdef WC_RSA_BLINDING if (rsa->rng && wc_FreeRng(rsa->rng) != 0) { WOLFSSL_MSG("Issue freeing rng"); } XFREE(rsa->rng, NULL, DYNAMIC_TYPE_RNG); #endif #if defined(OPENSSL_EXTRA) && !defined(WOLFCRYPT_ONLY) if (rsa->meth) { wolfSSL_RSA_meth_free(rsa->meth); } #endif InitwolfSSL_Rsa(rsa); /* set back to NULLs for safety */ XFREE(rsa, NULL, DYNAMIC_TYPE_RSA); /* rsa = NULL, don't try to access or double free it */ } } WOLFSSL_RSA* wolfSSL_RSA_new(void) { WOLFSSL_RSA* external; RsaKey* key; WOLFSSL_ENTER("wolfSSL_RSA_new"); key = (RsaKey*) XMALLOC(sizeof(RsaKey), NULL, DYNAMIC_TYPE_RSA); if (key == NULL) { WOLFSSL_MSG("wolfSSL_RSA_new malloc RsaKey failure"); return NULL; } external = (WOLFSSL_RSA*) XMALLOC(sizeof(WOLFSSL_RSA), NULL, DYNAMIC_TYPE_RSA); if (external == NULL) { WOLFSSL_MSG("wolfSSL_RSA_new malloc WOLFSSL_RSA failure"); XFREE(key, NULL, DYNAMIC_TYPE_RSA); return NULL; } InitwolfSSL_Rsa(external); if (wc_InitRsaKey(key, NULL) != 0) { WOLFSSL_MSG("InitRsaKey WOLFSSL_RSA failure"); XFREE(external, NULL, DYNAMIC_TYPE_RSA); XFREE(key, NULL, DYNAMIC_TYPE_RSA); return NULL; } #if !defined(HAVE_FIPS) && !defined(HAVE_USER_RSA) && \ !defined(HAVE_FAST_RSA) && defined(WC_RSA_BLINDING) { WC_RNG* rng; rng = (WC_RNG*) XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG); if (rng != NULL && wc_InitRng(rng) != 0) { WOLFSSL_MSG("InitRng failure, attempting to use global RNG"); XFREE(rng, NULL, DYNAMIC_TYPE_RNG); rng = NULL; } external->ownRng = 1; if (rng == NULL && initGlobalRNG) { external->ownRng = 0; rng = &globalRNG; } if (rng == NULL) { WOLFSSL_MSG("wolfSSL_RSA_new no WC_RNG for blinding"); XFREE(external, NULL, DYNAMIC_TYPE_RSA); XFREE(key, NULL, DYNAMIC_TYPE_RSA); return NULL; } wc_RsaSetRNG(key, rng); } #else XMEMSET(key, 0, sizeof(RsaKey)); #endif /* WC_RSA_BLINDING */ external->internal = key; external->inSet = 0; #if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL) external->refCount = 1; wc_InitMutex(&external->refMutex); #endif return external; } #endif /* !NO_RSA && (OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL) */ #if defined(OPENSSL_ALL) && defined(HAVE_PKCS7) PKCS7* wolfSSL_PKCS7_new(void) { WOLFSSL_PKCS7* pkcs7; int ret = 0; pkcs7 = (WOLFSSL_PKCS7*)XMALLOC(sizeof(*pkcs7), NULL, DYNAMIC_TYPE_PKCS7); if (pkcs7 != NULL) { XMEMSET(pkcs7, 0, sizeof(*pkcs7)); ret = wc_PKCS7_Init(&pkcs7->pkcs7, NULL, INVALID_DEVID); } if (ret != 0 && pkcs7 != NULL) XFREE(pkcs7, NULL, DYNAMIC_TYPE_PKCS7); return (PKCS7*)pkcs7; } /****************************************************************************** * wolfSSL_PKCS7_SIGNED_new - allocates PKCS7 and initialize it for a signed data * * RETURNS: * returns pointer to the PKCS7 structure on success, otherwise returns NULL */ PKCS7_SIGNED* wolfSSL_PKCS7_SIGNED_new(void) { byte signedData[]= { 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x02}; PKCS7* pkcs7 = NULL; if ((pkcs7 = wolfSSL_PKCS7_new()) == NULL) return NULL; pkcs7->contentOID = SIGNED_DATA; if ((wc_PKCS7_SetContentType(pkcs7, signedData, sizeof(signedData))) < 0) { if (pkcs7) { wolfSSL_PKCS7_free(pkcs7); return NULL; } } return pkcs7; } void wolfSSL_PKCS7_free(PKCS7* pkcs7) { WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7; if (p7 != NULL) { if (p7->data != NULL) XFREE(p7->data, NULL, DYNAMIC_TYPE_PKCS7); wc_PKCS7_Free(&p7->pkcs7); XFREE(p7, NULL, DYNAMIC_TYPE_PKCS7); } } void wolfSSL_PKCS7_SIGNED_free(PKCS7_SIGNED* p7) { wolfSSL_PKCS7_free(p7); return; } PKCS7* wolfSSL_d2i_PKCS7(PKCS7** p7, const unsigned char** in, int len) { WOLFSSL_PKCS7* pkcs7 = NULL; word32 idx = 0; if (in == NULL) return NULL; if ((pkcs7 = (WOLFSSL_PKCS7*)wolfSSL_PKCS7_new()) == NULL) return NULL; if (GetSequence(*in, &idx, &pkcs7->len, len) < 0) { wolfSSL_PKCS7_free((PKCS7*)pkcs7); return NULL; } pkcs7->len += idx; pkcs7->data = (byte*)XMALLOC(pkcs7->len, NULL, DYNAMIC_TYPE_PKCS7); if (pkcs7->data == NULL) { wolfSSL_PKCS7_free((PKCS7*)pkcs7); return NULL; } XMEMCPY(pkcs7->data, *in, pkcs7->len); *in += pkcs7->len; if (p7 != NULL) *p7 = (PKCS7*)pkcs7; return (PKCS7*)pkcs7; } PKCS7* wolfSSL_d2i_PKCS7_bio(WOLFSSL_BIO* bio, PKCS7** p7) { WOLFSSL_PKCS7* pkcs7; if (bio == NULL) return NULL; if ((pkcs7 = (WOLFSSL_PKCS7*)wolfSSL_PKCS7_new()) == NULL) return NULL; pkcs7->len = wolfSSL_BIO_pending(bio); pkcs7->data = (byte*)XMALLOC(pkcs7->len, NULL, DYNAMIC_TYPE_PKCS7); if (pkcs7->data == NULL) { wolfSSL_PKCS7_free((PKCS7*)pkcs7); return NULL; } if (wolfSSL_BIO_read(bio, pkcs7->data, pkcs7->len) != pkcs7->len) { wolfSSL_PKCS7_free((PKCS7*)pkcs7); return NULL; } if (p7 != NULL) *p7 = (PKCS7*)pkcs7; return (PKCS7*)pkcs7; } int wolfSSL_PKCS7_verify(PKCS7* pkcs7, WOLFSSL_STACK* certs, WOLFSSL_X509_STORE* store, WOLFSSL_BIO* in, WOLFSSL_BIO* out, int flags) { int ret = 0; unsigned char* mem = NULL; int memSz = 0; WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7; if (pkcs7 == NULL) return WOLFSSL_FAILURE; if (in != NULL) { if ((memSz = wolfSSL_BIO_get_mem_data(in, &mem)) < 0) return WOLFSSL_FAILURE; p7->pkcs7.content = mem; p7->pkcs7.contentSz = memSz; } /* certs is the list of certificates to find the cert with issuer/serial. */ (void)certs; /* store is the certificate store to use to verify signer certificate * associated with the signers. */ (void)store; ret = wc_PKCS7_VerifySignedData_ex(&p7->pkcs7, NULL, 0, p7->data, p7->len, NULL, 0); if (ret != 0) return WOLFSSL_FAILURE; if ((flags & PKCS7_NOVERIFY) != PKCS7_NOVERIFY) { /* All signer certificates are verified. */ return WOLFSSL_FAILURE; } if (out != NULL) wolfSSL_BIO_write(out, p7->pkcs7.content, p7->pkcs7.contentSz); return WOLFSSL_SUCCESS; } WOLFSSL_STACK* wolfSSL_PKCS7_get0_signers(PKCS7* pkcs7, WOLFSSL_STACK* certs, int flags) { WOLFSSL_STACK* signers = NULL; WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7; if (p7 == NULL) return NULL; /* Only PKCS#7 messages with a single cert that is the verifying certificate * is supported. */ if ((flags | PKCS7_NOINTERN) == PKCS7_NOINTERN) return NULL; signers = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_X509); if (signers == NULL) return NULL; signers->num = 1; signers->data.x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL, DYNAMIC_TYPE_X509); if (signers->data.x509 == NULL) { XFREE(signers, NULL, DYNAMIC_TYPE_X509); return NULL; } if (DecodeToX509(signers->data.x509, p7->pkcs7.singleCert, p7->pkcs7.singleCertSz) != 0) { XFREE(signers->data.x509, NULL, DYNAMIC_TYPE_X509); XFREE(signers, NULL, DYNAMIC_TYPE_X509); return NULL; } (void)certs; return signers; } /****************************************************************************** * wolfSSL_PEM_write_bio_PKCS7 - writes the PKCS7 data to BIO * * RETURNS: * returns WOLFSSL_SUCCESS on success, otherwise returns WOLFSSL_FAILURE */ int wolfSSL_PEM_write_bio_PKCS7(WOLFSSL_BIO* bio, PKCS7* p7) { #ifdef WOLFSSL_SMALL_STACK byte* outputHead; byte* outputFoot; #else byte outputHead[2048]; byte outputFoot[2048]; #endif word32 outputHeadSz = 2048; word32 outputFootSz = 2048; word32 outputSz = 0; byte* output = NULL; byte* pem = NULL; int pemSz = -1; enum wc_HashType hashType; byte hashBuf[WC_MAX_DIGEST_SIZE]; word32 hashSz = -1; WOLFSSL_ENTER("wolfSSL_PEM_write_bio_PKCS7()"); if (bio == NULL || p7 == NULL) return WOLFSSL_FAILURE; #ifdef WOLFSSL_SMALL_STACK outputHead = (byte*)XMALLOC(outputHeadSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (outputHead == NULL) return MEMORY_E; outputFoot = (byte*)XMALLOC(outputFootSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (outputFoot == NULL) goto error; #endif XMEMSET(hashBuf, 0, WC_MAX_DIGEST_SIZE); XMEMSET(outputHead, 0, outputHeadSz); XMEMSET(outputFoot, 0, outputFootSz); hashType = wc_OidGetHash(p7->hashOID); hashSz = wc_HashGetDigestSize(hashType); if (hashSz > WC_MAX_DIGEST_SIZE) return WOLFSSL_FAILURE; /* only SIGNED_DATA is supported */ switch (p7->contentOID) { case SIGNED_DATA: break; default: WOLFSSL_MSG("Unknown PKCS#7 Type"); return WOLFSSL_FAILURE; }; if ((wc_PKCS7_EncodeSignedData_ex(p7, hashBuf, hashSz, outputHead, &outputHeadSz, outputFoot, &outputFootSz)) != 0) return WOLFSSL_FAILURE; outputSz = outputHeadSz + p7->contentSz + outputFootSz; output = (byte*)XMALLOC(outputSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); if (!output) return WOLFSSL_FAILURE; XMEMSET(output, 0, outputSz); outputSz = 0; XMEMCPY(&output[outputSz], outputHead, outputHeadSz); outputSz += outputHeadSz; XMEMCPY(&output[outputSz], p7->content, p7->contentSz); outputSz += p7->contentSz; XMEMCPY(&output[outputSz], outputFoot, outputFootSz); outputSz += outputFootSz; /* get PEM size */ pemSz = wc_DerToPemEx(output, outputSz, NULL, 0, NULL, CERT_TYPE); if (pemSz < 0) goto error; pemSz++; /* for '\0'*/ /* create PEM buffer and convert from DER to PEM*/ if ((pem = (byte*)XMALLOC(pemSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER)) == NULL) goto error; XMEMSET(pem, 0, pemSz); if (wc_DerToPemEx(output, outputSz, pem, pemSz, NULL, CERT_TYPE) < 0) { goto error; } if ((wolfSSL_BIO_write(bio, pem, pemSz) == pemSz)) { XFREE(output, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); XFREE(pem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); #ifdef WOLFSSL_SMALL_STACK XFREE(outputHead, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); XFREE(outputFoot, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); #endif return WOLFSSL_SUCCESS; } error: #ifdef WOLFSSL_SMALL_STACK if (outputHead) { XFREE(outputHead, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); } if (outputFoot) { XFREE(outputFoot, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); } #endif if (output) { XFREE(output, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); } if (pem) { XFREE(pem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER); } return WOLFSSL_FAILURE; } #endif /* OPENSSL_ALL && HAVE_PKCS7 */ #if defined(OPENSSL_EXTRA) WOLFSSL_STACK* wolfSSL_sk_X509_new(void) { WOLFSSL_STACK* s = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL, DYNAMIC_TYPE_X509); if (s != NULL) { XMEMSET(s, 0, sizeof(*s)); s->type = STACK_TYPE_X509; } return s; } #endif #ifdef OPENSSL_ALL int wolfSSL_PEM_write_bio_PKCS8PrivateKey(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* pkey, const WOLFSSL_EVP_CIPHER* enc, char* passwd, int passwdSz, pem_password_cb* cb, void* ctx) { int ret = 0; char password[NAME_SZ]; byte* key = NULL; word32 keySz; byte* pem = NULL; int pemSz; int type = PKCS8_PRIVATEKEY_TYPE; int algId; const byte* curveOid; word32 oidSz; int encAlgId; if (bio == NULL || pkey == NULL) return -1; keySz = pkey->pkey_sz + 128; key = (byte*)XMALLOC(keySz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (key == NULL) ret = MEMORY_E; if (ret == 0 && enc != NULL && passwd == NULL) { passwdSz = cb(password, sizeof(password), 1, ctx); if (passwdSz < 0) ret = WOLFSSL_FAILURE; passwd = password; } if (ret == 0 && enc != NULL) { WC_RNG rng; ret = wc_InitRng(&rng); if (ret == 0) { #ifndef NO_DES3 if (enc == EVP_DES_CBC) encAlgId = DESb; else if (enc == EVP_DES_EDE3_CBC) encAlgId = DES3b; else #endif #if !defined(NO_AES) && defined(HAVE_AES_CBC) #ifdef WOLFSSL_AES_256 if (enc == EVP_AES_256_CBC) encAlgId = AES256CBCb; else #endif #endif ret = -1; if (ret == 0) { ret = TraditionalEnc((byte*)pkey->pkey.ptr, pkey->pkey_sz, key, &keySz, passwd, passwdSz, PKCS5, PBES2, encAlgId, NULL, 0, WC_PKCS12_ITT_DEFAULT, &rng, NULL); if (ret > 0) { keySz = ret; ret = 0; } } wc_FreeRng(&rng); } type = PKCS8_ENC_PRIVATEKEY_TYPE; } if (ret == 0 && enc == NULL) { type = PKCS8_PRIVATEKEY_TYPE; if (pkey->type == EVP_PKEY_EC) { algId = ECDSAk; ret = wc_ecc_get_oid(pkey->ecc->group->curve_oid, &curveOid, &oidSz); } else { algId = RSAk; curveOid = NULL; oidSz = 0; } if (ret >= 0) { ret = wc_CreatePKCS8Key(key, &keySz, (byte*)pkey->pkey.ptr, pkey->pkey_sz, algId, curveOid, oidSz); keySz = ret; } } if (password == passwd) XMEMSET(password, 0, passwdSz); if (ret >= 0) { pemSz = 2 * keySz + 2 * 64; pem = (byte*)XMALLOC(pemSz, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (pem == NULL) ret = MEMORY_E; } if (ret >= 0) ret = wc_DerToPemEx(key, keySz, pem, pemSz, NULL, type); if (key != NULL) XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER); if (ret >= 0) { if (wolfSSL_BIO_write(bio, pem, ret) != ret) ret = -1; } if (pem != NULL) XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER); return ret < 0 ? 0 : ret; } static int bio_get_data(WOLFSSL_BIO* bio, byte** data) { int ret = 0; byte* mem = NULL; #ifndef NO_FILESYSTEM long memSz; XFILE file; long curr; #endif if ((ret = wolfSSL_BIO_pending(bio)) > 0) { } #ifndef NO_FILESYSTEM else if (bio->type == WOLFSSL_BIO_FILE) { if (wolfSSL_BIO_get_fp(bio, &file) != WOLFSSL_SUCCESS) ret = BAD_FUNC_ARG; if (ret == 0) { curr = XFTELL(file); if (curr < 0) { ret = WOLFSSL_BAD_FILE; } if (XFSEEK(file, 0, XSEEK_END) != 0) ret = WOLFSSL_BAD_FILE; } if (ret == 0) { memSz = XFTELL(file); if (memSz > MAX_WOLFSSL_FILE_SIZE || memSz < 0) { ret = WOLFSSL_BAD_FILE; } } if (ret == 0) { memSz -= curr; ret = (int)memSz; if (XFSEEK(file, curr, SEEK_SET) != 0) ret = WOLFSSL_BAD_FILE; } } #endif if (ret > 0) { mem = (byte*)XMALLOC(ret, bio->heap, DYNAMIC_TYPE_OPENSSL); if (mem == NULL) { WOLFSSL_MSG("Memory error"); ret = MEMORY_E; } if (ret >= 0) { if ((ret = wolfSSL_BIO_read(bio, mem, ret)) <= 0) { XFREE(mem, bio->heap, DYNAMIC_TYPE_OPENSSL); ret = MEMORY_E; mem = NULL; } } } *data = mem; return ret; } #ifndef NO_WOLFSSL_STUB void wolfSSL_BIO_set_init(WOLFSSL_BIO* bio, int init) { WOLFSSL_STUB("wolfSSL_BIO_set_init"); (void)bio; (void)init; } void wolfSSL_BIO_set_shutdown(WOLFSSL_BIO* bio, int shut) { WOLFSSL_STUB("wolfSSL_BIO_set_shutdown"); (void)bio; (void)shut; } int wolfSSL_BIO_get_shutdown(WOLFSSL_BIO* bio) { WOLFSSL_STUB("wolfSSL_BIO_get_shutdown"); (void)bio; return 0; } #endif /* NO_WOLFSSL_STUB */ void wolfSSL_BIO_clear_retry_flags(WOLFSSL_BIO* bio) { WOLFSSL_ENTER("wolfSSL_BIO_clear_retry_flags"); if (bio) bio->flags &= ~(WOLFSSL_BIO_FLAG_READ|WOLFSSL_BIO_FLAG_RETRY); } int wolfSSL_BIO_should_retry(WOLFSSL_BIO *bio) { int ret = 0; if (bio != NULL) { ret = (int)(bio->flags & WOLFSSL_BIO_FLAG_RETRY); } return ret; } /* DER data is PKCS#8 encrypted. */ WOLFSSL_EVP_PKEY* wolfSSL_d2i_PKCS8PrivateKey_bio(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY** pkey, pem_password_cb* cb, void* ctx) { int ret; byte* der; int len; byte* p; char password[NAME_SZ]; int passwordSz; word32 algId; WOLFSSL_EVP_PKEY* key; if ((len = bio_get_data(bio, &der)) < 0) return NULL; if (cb != NULL) { passwordSz = cb(password, sizeof(password), PEM_PASS_READ, ctx); if (passwordSz < 0) { XFREE(der, bio->heap, DYNAMIC_TYPE_OPENSSL); return NULL; } ret = ToTraditionalEnc(der, len, password, passwordSz, &algId); if (ret < 0) { XFREE(der, bio->heap, DYNAMIC_TYPE_OPENSSL); return NULL; } XMEMSET(password, 0, passwordSz); } p = der; key = wolfSSL_d2i_PrivateKey_EVP(pkey, &p, len); XFREE(der, bio->heap, DYNAMIC_TYPE_OPENSSL); return key; } /* Detect which type of key it is before decoding. */ WOLFSSL_EVP_PKEY* wolfSSL_d2i_AutoPrivateKey(WOLFSSL_EVP_PKEY** pkey, const unsigned char** pp, long length) { int ret; WOLFSSL_EVP_PKEY* key = NULL; const byte* der = *pp; word32 idx = 0; int len = 0; word32 end = 0; int cnt = 0; int type; word32 algId; word32 keyLen = (word32)length; /* Take off PKCS#8 wrapper if found. */ if ((len = ToTraditionalInline_ex(der, &idx, keyLen, &algId)) >= 0) { der += idx; keyLen = len; } idx = 0; len = 0; /* Use the number of elements in the outer sequence to determine key type. */ ret = GetSequence(der, &idx, &len, keyLen); if (ret >= 0) { end = idx + len; while (ret >= 0 && idx < end) { /* Skip type */ idx++; /* Get length and skip over - keeping count */ len = 0; ret = GetLength(der, &idx, &len, keyLen); if (ret >= 0) { if (idx + len > end) ret = ASN_PARSE_E; else { idx += len; cnt++; } } } } if (ret >= 0) { /* ECC includes version, private[, curve][, public key] */ if (cnt >= 2 && cnt <= 4) type = EVP_PKEY_EC; else type = EVP_PKEY_RSA; key = wolfSSL_d2i_PrivateKey(type, pkey, &der, keyLen); *pp = der; } return key; } #endif #if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \ defined(WOLFSSL_CERT_GEN) && defined(WOLFSSL_CERT_REQ) int wolfSSL_X509_set_subject_name(WOLFSSL_X509 *cert, WOLFSSL_X509_NAME *name) { int i; WOLFSSL_X509_NAME_ENTRY* ne; WOLFSSL_ENTER("X509_set_subject_name"); if (cert == NULL || name == NULL) return WOLFSSL_FAILURE; FreeX509Name(&cert->subject, cert->heap); InitX509Name(&cert->subject, 0); if (name->dynamicName) { cert->subject.name = (char*)XMALLOC(name->sz, cert->heap, DYNAMIC_TYPE_SUBJECT_CN); if (cert->subject.name == NULL) return WOLFSSL_FAILURE; } XMEMCPY(cert->subject.name, name->name, name->sz); cert->subject.sz = name->sz; for (i = 0; i < 10; i++) { ne = wolfSSL_X509_NAME_get_entry(name, i); if (ne != NULL) wolfSSL_X509_NAME_add_entry(&cert->subject, ne, i, 1); } cert->subject.x509 = cert; cert->subject.name = cert->subject.fullName.fullName; cert->subject.sz = cert->subject.fullName.fullNameLen; return WOLFSSL_SUCCESS; } int wolfSSL_X509_set_issuer_name(WOLFSSL_X509 *cert, WOLFSSL_X509_NAME *name) { int i; WOLFSSL_X509_NAME_ENTRY* ne; WOLFSSL_ENTER("X509_set_issuer_name"); if (cert == NULL || name == NULL) return WOLFSSL_FAILURE; FreeX509Name(&cert->issuer, cert->heap); InitX509Name(&cert->issuer, 0); if (name->dynamicName) { cert->issuer.name = (char*)XMALLOC(name->sz, cert->heap, DYNAMIC_TYPE_SUBJECT_CN); if (cert->issuer.name == NULL) return WOLFSSL_FAILURE; } XMEMCPY(cert->issuer.name, name->name, name->sz); cert->issuer.sz = name->sz; for (i = 0; i < 10; i++) { ne = wolfSSL_X509_NAME_get_entry(name, i); if (ne != NULL) wolfSSL_X509_NAME_add_entry(&cert->issuer, ne, i, 1); } cert->issuer.x509 = cert; cert->issuer.name = cert->issuer.fullName.fullName; cert->issuer.sz = cert->issuer.fullName.fullNameLen; cert->issuerSet = 1; return WOLFSSL_SUCCESS; } int wolfSSL_X509_set_notAfter(WOLFSSL_X509* x509, const WOLFSSL_ASN1_TIME* t) { if (x509 == NULL || t == NULL) { return WOLFSSL_FAILURE; } XMEMCPY(&x509->notAfter, t, sizeof(WOLFSSL_ASN1_TIME)); return WOLFSSL_SUCCESS; } int wolfSSL_X509_set_notBefore(WOLFSSL_X509* x509, const WOLFSSL_ASN1_TIME* t) { if (x509 == NULL || t == NULL) { return WOLFSSL_FAILURE; } XMEMCPY(&x509->notBefore, t, sizeof(WOLFSSL_ASN1_TIME)); return WOLFSSL_SUCCESS; } int wolfSSL_X509_set_serialNumber(WOLFSSL_X509* x509, WOLFSSL_ASN1_INTEGER* s) { WOLFSSL_ENTER("wolfSSL_X509_set_serialNumber"); if (!x509 || !s || s->dataMax >= EXTERNAL_SERIAL_SIZE) return WOLFSSL_FAILURE; if (s->isDynamic) XSTRNCPY((char*)x509->serial,(char*)s->data,s->dataMax); else XSTRNCPY((char*)x509->serial,(char*)s->intData,s->dataMax); x509->serial[s->dataMax] = 0; x509->serialSz = s->dataMax; return WOLFSSL_SUCCESS; } int wolfSSL_X509_set_pubkey(WOLFSSL_X509 *cert, WOLFSSL_EVP_PKEY *pkey) { byte* p; WOLFSSL_ENTER("wolfSSL_X509_set_pubkey"); if (cert == NULL || pkey == NULL) return WOLFSSL_FAILURE; if (pkey->type == EVP_PKEY_RSA) cert->pubKeyOID = RSAk; else if (pkey->type == EVP_PKEY_EC) cert->pubKeyOID = ECDSAk; else return WOLFSSL_FAILURE; p = (byte*)XMALLOC(pkey->pkey_sz, cert->heap, DYNAMIC_TYPE_PUBLIC_KEY); if (p == NULL) return WOLFSSL_FAILURE; if (cert->pubKey.buffer != NULL) XFREE(cert->pubKey.buffer, cert->heap, DYNAMIC_TYPE_PUBLIC_KEY); cert->pubKey.buffer = p; XMEMCPY(cert->pubKey.buffer, pkey->pkey.ptr, pkey->pkey_sz); cert->pubKey.length = pkey->pkey_sz; return WOLFSSL_SUCCESS; } int wolfSSL_X509_set_version(WOLFSSL_X509* x509, long v) { WOLFSSL_ENTER("wolfSSL_X509_set_version"); if ((x509 == NULL) || (v < 0) || (v > INT_MAX)) { return WOLFSSL_FAILURE; } x509->version = (int) v + 1; return WOLFSSL_SUCCESS; } #endif /* OPENSSL_EXTRA && !NO_CERTS && WOLFSSL_CERT_GEN && WOLFSSL_CERT_REQ */ #if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \ defined(WOLFSSL_CERT_GEN) && defined(WOLFSSL_CERT_REQ) void wolfSSL_X509V3_set_ctx(WOLFSSL_X509V3_CTX* ctx, WOLFSSL_X509* issuer, WOLFSSL_X509* subject, WOLFSSL_X509* req, WOLFSSL_X509_CRL* crl, int flag) { int ret = WOLFSSL_SUCCESS; WOLFSSL_ENTER("wolfSSL_X509V3_set_ctx"); if (!ctx || !ctx->x509) return; /* Set parameters in ctx as long as ret == WOLFSSL_SUCCESS */ if (issuer) ret = wolfSSL_X509_set_issuer_name(ctx->x509,&issuer->issuer); if (subject && ret == WOLFSSL_SUCCESS) ret = wolfSSL_X509_set_subject_name(ctx->x509,&subject->subject); if (req && ret == WOLFSSL_SUCCESS) { WOLFSSL_MSG("req not implemented."); } if (crl && ret == WOLFSSL_SUCCESS) { WOLFSSL_MSG("crl not implemented."); } if (flag && ret == WOLFSSL_SUCCESS) { WOLFSSL_MSG("flag not implemented."); } if (!ret) { WOLFSSL_MSG("Error setting WOLFSSL_X509V3_CTX parameters."); } } int wolfSSL_i2d_X509_REQ(WOLFSSL_X509* req, unsigned char** out) { const unsigned char* der; int derSz = 0; WOLFSSL_ENTER("wolfSSL_i2d_X509_REQ"); if (req == NULL || out == NULL) { return BAD_FUNC_ARG; } der = wolfSSL_X509_get_der(req, &derSz); if (der == NULL) { return MEMORY_E; } if (*out == NULL) { *out = (unsigned char*)XMALLOC(derSz, NULL, DYNAMIC_TYPE_OPENSSL); if (*out == NULL) { return MEMORY_E; } } XMEMCPY(*out, der, derSz); return derSz; } WOLFSSL_X509* wolfSSL_X509_REQ_new(void) { return wolfSSL_X509_new(); } void wolfSSL_X509_REQ_free(WOLFSSL_X509* req) { wolfSSL_X509_free(req); } int wolfSSL_X509_REQ_sign(WOLFSSL_X509 *req, WOLFSSL_EVP_PKEY *pkey, const WOLFSSL_EVP_MD *md) { byte der[2048]; int derSz = sizeof(der); if (req == NULL || pkey == NULL || md == NULL) return WOLFSSL_FAILURE; /* Create a Cert that has the certificate request fields. */ req->sigOID = wolfSSL_sigTypeFromPKEY((WOLFSSL_EVP_MD*)md, pkey); if (wolfSSL_X509_make_der(req, 1, der, &derSz) != WOLFSSL_SUCCESS) { return WOLFSSL_FAILURE; } if (wolfSSL_X509_resign_cert(req, 1, der, sizeof(der), derSz, (WOLFSSL_EVP_MD*)md, pkey) <= 0) { return WOLFSSL_FAILURE; } return WOLFSSL_SUCCESS; } #ifndef NO_WOLFSSL_STUB int wolfSSL_X509_REQ_add_extensions(WOLFSSL_X509* req, WOLF_STACK_OF(WOLFSSL_X509_EXTENSION)* ext) { (void)req; (void)ext; return WOLFSSL_FATAL_ERROR; } #endif int wolfSSL_X509_REQ_set_subject_name(WOLFSSL_X509 *req, WOLFSSL_X509_NAME *name) { return wolfSSL_X509_set_subject_name(req, name); } int wolfSSL_X509_REQ_set_pubkey(WOLFSSL_X509 *req, WOLFSSL_EVP_PKEY *pkey) { return wolfSSL_X509_set_pubkey(req, pkey); } #endif /* OPENSSL_EXTRA && !NO_CERTS && WOLFSSL_CERT_GEN && WOLFSSL_CERT_REQ */