1 /*
2 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
3 *
4 * This Source Code Form is subject to the terms of the Mozilla Public
5 * License, v. 2.0. If a copy of the MPL was not distributed with this
6 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
7 *
8 * See the COPYRIGHT file distributed with this work for additional
9 * information regarding copyright ownership.
10 */
11
12 #include <inttypes.h>
13 #include <stdlib.h>
14 #include <string.h>
15
16 #include <openssl/crypto.h>
17 #include <openssl/engine.h>
18 #include <openssl/evp.h>
19 #include <openssl/hmac.h>
20 #include <openssl/opensslv.h>
21 #include <openssl/ssl.h>
22
23 #include "openssl_shim.h"
24
25 #if !HAVE_CRYPTO_ZALLOC
26 void *
CRYPTO_zalloc(size_t num,const char * file,int line)27 CRYPTO_zalloc(size_t num, const char *file, int line) {
28 void *ret = CRYPTO_malloc(num, file, line);
29 if (ret != NULL) {
30 memset(ret, 0, num);
31 }
32 return (ret);
33 }
34 #endif /* if !HAVE_CRYPTO_ZALLOC */
35
36 #if !HAVE_EVP_CIPHER_CTX_NEW
37 EVP_CIPHER_CTX *
EVP_CIPHER_CTX_new(void)38 EVP_CIPHER_CTX_new(void) {
39 EVP_CIPHER_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
40 return (ctx);
41 }
42 #endif /* if !HAVE_EVP_CIPHER_CTX_NEW */
43
44 #if !HAVE_EVP_CIPHER_CTX_FREE
45 void
EVP_CIPHER_CTX_free(EVP_CIPHER_CTX * ctx)46 EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx) {
47 if (ctx != NULL) {
48 EVP_CIPHER_CTX_cleanup(ctx);
49 OPENSSL_free(ctx);
50 }
51 }
52 #endif /* if !HAVE_EVP_CIPHER_CTX_FREE */
53
54 #if !HAVE_EVP_MD_CTX_NEW
55 EVP_MD_CTX *
EVP_MD_CTX_new(void)56 EVP_MD_CTX_new(void) {
57 EVP_MD_CTX *ctx = OPENSSL_malloc(sizeof(*ctx));
58 if (ctx != NULL) {
59 memset(ctx, 0, sizeof(*ctx));
60 }
61 return (ctx);
62 }
63 #endif /* if !HAVE_EVP_MD_CTX_NEW */
64
65 #if !HAVE_EVP_MD_CTX_FREE
66 void
EVP_MD_CTX_free(EVP_MD_CTX * ctx)67 EVP_MD_CTX_free(EVP_MD_CTX *ctx) {
68 if (ctx != NULL) {
69 EVP_MD_CTX_cleanup(ctx);
70 OPENSSL_free(ctx);
71 }
72 }
73 #endif /* if !HAVE_EVP_MD_CTX_FREE */
74
75 #if !HAVE_EVP_MD_CTX_RESET
76 int
EVP_MD_CTX_reset(EVP_MD_CTX * ctx)77 EVP_MD_CTX_reset(EVP_MD_CTX *ctx) {
78 return (EVP_MD_CTX_cleanup(ctx));
79 }
80 #endif /* if !HAVE_EVP_MD_CTX_RESET */
81
82 #if !HAVE_HMAC_CTX_NEW
83 HMAC_CTX *
HMAC_CTX_new(void)84 HMAC_CTX_new(void) {
85 HMAC_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
86 if (ctx != NULL) {
87 if (!HMAC_CTX_reset(ctx)) {
88 HMAC_CTX_free(ctx);
89 return (NULL);
90 }
91 }
92 return (ctx);
93 }
94 #endif /* if !HAVE_HMAC_CTX_NEW */
95
96 #if !HAVE_HMAC_CTX_FREE
97 void
HMAC_CTX_free(HMAC_CTX * ctx)98 HMAC_CTX_free(HMAC_CTX *ctx) {
99 if (ctx != NULL) {
100 HMAC_CTX_cleanup(ctx);
101 OPENSSL_free(ctx);
102 }
103 }
104 #endif /* if !HAVE_HMAC_CTX_FREE */
105
106 #if !HAVE_HMAC_CTX_RESET
107 int
HMAC_CTX_reset(HMAC_CTX * ctx)108 HMAC_CTX_reset(HMAC_CTX *ctx) {
109 HMAC_CTX_cleanup(ctx);
110 return (1);
111 }
112 #endif /* if !HAVE_HMAC_CTX_RESET */
113
114 #if !HAVE_HMAC_CTX_GET_MD
115 const EVP_MD *
HMAC_CTX_get_md(const HMAC_CTX * ctx)116 HMAC_CTX_get_md(const HMAC_CTX *ctx) {
117 return (ctx->md);
118 }
119 #endif /* if !HAVE_HMAC_CTX_GET_MD */
120
121 #if !HAVE_SSL_READ_EX
122 int
SSL_read_ex(SSL * ssl,void * buf,size_t num,size_t * readbytes)123 SSL_read_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes) {
124 int rv = SSL_read(ssl, buf, num);
125 if (rv > 0) {
126 *readbytes = rv;
127 rv = 1;
128 }
129
130 return (rv);
131 }
132 #endif
133
134 #if !HAVE_SSL_PEEK_EX
135 int
SSL_peek_ex(SSL * ssl,void * buf,size_t num,size_t * readbytes)136 SSL_peek_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes) {
137 int rv = SSL_peek(ssl, buf, num);
138 if (rv > 0) {
139 *readbytes = rv;
140 rv = 1;
141 }
142
143 return (rv);
144 }
145 #endif
146
147 #if !HAVE_SSL_WRITE_EX
148 int
SSL_write_ex(SSL * ssl,const void * buf,size_t num,size_t * written)149 SSL_write_ex(SSL *ssl, const void *buf, size_t num, size_t *written) {
150 int rv = SSL_write(ssl, buf, num);
151 if (rv > 0) {
152 *written = rv;
153 rv = 1;
154 }
155
156 return (rv);
157 }
158 #endif
159
160 #if !HAVE_BIO_READ_EX
161 int
BIO_read_ex(BIO * b,void * data,size_t dlen,size_t * readbytes)162 BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes) {
163 int rv = BIO_read(b, data, dlen);
164 if (rv > 0) {
165 *readbytes = rv;
166 rv = 1;
167 }
168
169 return (rv);
170 }
171 #endif
172
173 #if !HAVE_BIO_WRITE_EX
174 int
BIO_write_ex(BIO * b,const void * data,size_t dlen,size_t * written)175 BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written) {
176 int rv = BIO_write(b, data, dlen);
177 if (rv > 0) {
178 *written = rv;
179 rv = 1;
180 }
181
182 return (rv);
183 }
184 #endif
185
186 #if !HAVE_OPENSSL_INIT_CRYPTO
187 int
OPENSSL_init_crypto(uint64_t opts,const void * settings)188 OPENSSL_init_crypto(uint64_t opts, const void *settings) {
189 (void)settings;
190
191 if ((opts & OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS) == 0) {
192 ERR_load_crypto_strings();
193 }
194
195 if ((opts & (OPENSSL_INIT_NO_ADD_ALL_CIPHERS |
196 OPENSSL_INIT_NO_ADD_ALL_CIPHERS)) == 0)
197 {
198 OpenSSL_add_all_algorithms();
199 } else if ((opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS) == 0) {
200 OpenSSL_add_all_digests();
201 } else if ((opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS) == 0) {
202 OpenSSL_add_all_ciphers();
203 }
204
205 return (1);
206 }
207 #endif
208
209 #if !HAVE_OPENSSL_INIT_SSL
210 int
OPENSSL_init_ssl(uint64_t opts,const void * settings)211 OPENSSL_init_ssl(uint64_t opts, const void *settings) {
212 OPENSSL_init_crypto(opts, settings);
213
214 SSL_library_init();
215
216 if ((opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS) == 0) {
217 SSL_load_error_strings();
218 }
219
220 return (1);
221 }
222 #endif
223