Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 1 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
| 2 | * All rights reserved. |
| 3 | * |
| 4 | * This package is an SSL implementation written |
| 5 | * by Eric Young (eay@cryptsoft.com). |
| 6 | * The implementation was written so as to conform with Netscapes SSL. |
| 7 | * |
| 8 | * This library is free for commercial and non-commercial use as long as |
| 9 | * the following conditions are aheared to. The following conditions |
| 10 | * apply to all code found in this distribution, be it the RC4, RSA, |
| 11 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation |
| 12 | * included with this distribution is covered by the same copyright terms |
| 13 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). |
| 14 | * |
| 15 | * Copyright remains Eric Young's, and as such any Copyright notices in |
| 16 | * the code are not to be removed. |
| 17 | * If this package is used in a product, Eric Young should be given attribution |
| 18 | * as the author of the parts of the library used. |
| 19 | * This can be in the form of a textual message at program startup or |
| 20 | * in documentation (online or textual) provided with the package. |
| 21 | * |
| 22 | * Redistribution and use in source and binary forms, with or without |
| 23 | * modification, are permitted provided that the following conditions |
| 24 | * are met: |
| 25 | * 1. Redistributions of source code must retain the copyright |
| 26 | * notice, this list of conditions and the following disclaimer. |
| 27 | * 2. Redistributions in binary form must reproduce the above copyright |
| 28 | * notice, this list of conditions and the following disclaimer in the |
| 29 | * documentation and/or other materials provided with the distribution. |
| 30 | * 3. All advertising materials mentioning features or use of this software |
| 31 | * must display the following acknowledgement: |
| 32 | * "This product includes cryptographic software written by |
| 33 | * Eric Young (eay@cryptsoft.com)" |
| 34 | * The word 'cryptographic' can be left out if the rouines from the library |
| 35 | * being used are not cryptographic related :-). |
| 36 | * 4. If you include any Windows specific code (or a derivative thereof) from |
| 37 | * the apps directory (application code) you must include an acknowledgement: |
| 38 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
| 39 | * |
| 40 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
| 41 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 42 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 43 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
| 44 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 45 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 46 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 48 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 49 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 50 | * SUCH DAMAGE. |
| 51 | * |
| 52 | * The licence and distribution terms for any publically available version or |
| 53 | * derivative of this code cannot be changed. i.e. this code cannot simply be |
| 54 | * copied and put under another distribution licence |
| 55 | * [including the GNU Public Licence.] |
| 56 | */ |
| 57 | /* ==================================================================== |
| 58 | * Copyright (c) 1998-2001 The OpenSSL Project. All rights reserved. |
| 59 | * |
| 60 | * Redistribution and use in source and binary forms, with or without |
| 61 | * modification, are permitted provided that the following conditions |
| 62 | * are met: |
| 63 | * |
| 64 | * 1. Redistributions of source code must retain the above copyright |
| 65 | * notice, this list of conditions and the following disclaimer. |
| 66 | * |
| 67 | * 2. Redistributions in binary form must reproduce the above copyright |
| 68 | * notice, this list of conditions and the following disclaimer in |
| 69 | * the documentation and/or other materials provided with the |
| 70 | * distribution. |
| 71 | * |
| 72 | * 3. All advertising materials mentioning features or use of this |
| 73 | * software must display the following acknowledgment: |
| 74 | * "This product includes software developed by the OpenSSL Project |
| 75 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" |
| 76 | * |
| 77 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
| 78 | * endorse or promote products derived from this software without |
| 79 | * prior written permission. For written permission, please contact |
| 80 | * openssl-core@openssl.org. |
| 81 | * |
| 82 | * 5. Products derived from this software may not be called "OpenSSL" |
| 83 | * nor may "OpenSSL" appear in their names without prior written |
| 84 | * permission of the OpenSSL Project. |
| 85 | * |
| 86 | * 6. Redistributions of any form whatsoever must retain the following |
| 87 | * acknowledgment: |
| 88 | * "This product includes software developed by the OpenSSL Project |
| 89 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" |
| 90 | * |
| 91 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
| 92 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 93 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| 94 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
| 95 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 96 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| 97 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| 98 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 99 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| 100 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 101 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
| 102 | * OF THE POSSIBILITY OF SUCH DAMAGE. |
| 103 | * ==================================================================== |
| 104 | * |
| 105 | * This product includes cryptographic software written by Eric Young |
| 106 | * (eay@cryptsoft.com). This product includes software written by Tim |
| 107 | * Hudson (tjh@cryptsoft.com). */ |
| 108 | |
| 109 | #include <openssl/ex_data.h> |
| 110 | |
Brian Smith | 054e682 | 2015-03-27 21:12:01 -1000 | [diff] [blame] | 111 | #include <assert.h> |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 112 | #include <limits.h> |
| 113 | #include <stdlib.h> |
Brian Smith | 054e682 | 2015-03-27 21:12:01 -1000 | [diff] [blame] | 114 | #include <string.h> |
| 115 | |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 116 | #include <openssl/crypto.h> |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 117 | #include <openssl/err.h> |
Brian Smith | 054e682 | 2015-03-27 21:12:01 -1000 | [diff] [blame] | 118 | #include <openssl/mem.h> |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 119 | #include <openssl/thread.h> |
| 120 | |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 121 | #include "internal.h" |
| 122 | |
| 123 | |
David Benjamin | 01f8a8c | 2017-04-15 18:12:55 -0400 | [diff] [blame] | 124 | DEFINE_STACK_OF(CRYPTO_EX_DATA_FUNCS) |
| 125 | |
David Benjamin | 9f33fc6 | 2015-04-15 17:29:53 -0400 | [diff] [blame] | 126 | struct crypto_ex_data_func_st { |
David Benjamin | 808f832 | 2017-08-18 14:06:02 -0400 | [diff] [blame] | 127 | long argl; // Arbitary long |
| 128 | void *argp; // Arbitary void pointer |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 129 | CRYPTO_EX_free *free_func; |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 130 | // next points to the next |CRYPTO_EX_DATA_FUNCS| or NULL if this is the last |
| 131 | // one. It may only be read if synchronized with a read from |num_funcs|. |
| 132 | CRYPTO_EX_DATA_FUNCS *next; |
David Benjamin | 9f33fc6 | 2015-04-15 17:29:53 -0400 | [diff] [blame] | 133 | }; |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 134 | |
David Benjamin | 9f33fc6 | 2015-04-15 17:29:53 -0400 | [diff] [blame] | 135 | int CRYPTO_get_ex_new_index(CRYPTO_EX_DATA_CLASS *ex_data_class, int *out_index, |
David Benjamin | d94682d | 2017-05-14 17:10:18 -0400 | [diff] [blame] | 136 | long argl, void *argp, CRYPTO_EX_free *free_func) { |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 137 | CRYPTO_EX_DATA_FUNCS *funcs = OPENSSL_malloc(sizeof(CRYPTO_EX_DATA_FUNCS)); |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 138 | if (funcs == NULL) { |
David Benjamin | 9f33fc6 | 2015-04-15 17:29:53 -0400 | [diff] [blame] | 139 | return 0; |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 140 | } |
| 141 | |
| 142 | funcs->argl = argl; |
| 143 | funcs->argp = argp; |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 144 | funcs->free_func = free_func; |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 145 | funcs->next = NULL; |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 146 | |
David Benjamin | 9f33fc6 | 2015-04-15 17:29:53 -0400 | [diff] [blame] | 147 | CRYPTO_STATIC_MUTEX_lock_write(&ex_data_class->lock); |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 148 | |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 149 | uint32_t num_funcs = CRYPTO_atomic_load_u32(&ex_data_class->num_funcs); |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 150 | // The index must fit in |int|. |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 151 | if (num_funcs > (size_t)(INT_MAX - ex_data_class->num_reserved)) { |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 152 | OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW); |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 153 | CRYPTO_STATIC_MUTEX_unlock_write(&ex_data_class->lock); |
| 154 | return 0; |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 155 | } |
| 156 | |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 157 | // Append |funcs| to the linked list. |
| 158 | if (ex_data_class->last == NULL) { |
| 159 | assert(num_funcs == 0); |
| 160 | ex_data_class->funcs = funcs; |
| 161 | ex_data_class->last = funcs; |
| 162 | } else { |
| 163 | ex_data_class->last->next = funcs; |
| 164 | ex_data_class->last = funcs; |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 165 | } |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 166 | |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 167 | CRYPTO_atomic_store_u32(&ex_data_class->num_funcs, num_funcs + 1); |
David Benjamin | 29270de | 2016-05-24 15:28:36 +0000 | [diff] [blame] | 168 | CRYPTO_STATIC_MUTEX_unlock_write(&ex_data_class->lock); |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 169 | *out_index = (int)num_funcs + ex_data_class->num_reserved; |
| 170 | return 1; |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 171 | } |
| 172 | |
| 173 | int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int index, void *val) { |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 174 | if (index < 0) { |
| 175 | // A caller that can accidentally pass in an invalid index into this |
| 176 | // function will hit an memory error if |index| happened to be valid, and |
| 177 | // expected |val| to be of a different type. |
| 178 | abort(); |
| 179 | } |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 180 | |
| 181 | if (ad->sk == NULL) { |
| 182 | ad->sk = sk_void_new_null(); |
| 183 | if (ad->sk == NULL) { |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 184 | return 0; |
| 185 | } |
| 186 | } |
| 187 | |
David Benjamin | 808f832 | 2017-08-18 14:06:02 -0400 | [diff] [blame] | 188 | // Add NULL values until the stack is long enough. |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 189 | for (size_t i = sk_void_num(ad->sk); i <= (size_t)index; i++) { |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 190 | if (!sk_void_push(ad->sk, NULL)) { |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 191 | return 0; |
| 192 | } |
| 193 | } |
| 194 | |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 195 | sk_void_set(ad->sk, (size_t)index, val); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 196 | return 1; |
| 197 | } |
| 198 | |
| 199 | void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx) { |
David Benjamin | fb3ff2c | 2014-09-30 21:00:38 -0400 | [diff] [blame] | 200 | if (ad->sk == NULL || idx < 0 || (size_t)idx >= sk_void_num(ad->sk)) { |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 201 | return NULL; |
| 202 | } |
| 203 | return sk_void_value(ad->sk, idx); |
| 204 | } |
| 205 | |
David Benjamin | 8a58933 | 2015-12-04 23:14:35 -0500 | [diff] [blame] | 206 | void CRYPTO_new_ex_data(CRYPTO_EX_DATA *ad) { |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 207 | ad->sk = NULL; |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 208 | } |
| 209 | |
David Benjamin | 9f33fc6 | 2015-04-15 17:29:53 -0400 | [diff] [blame] | 210 | void CRYPTO_free_ex_data(CRYPTO_EX_DATA_CLASS *ex_data_class, void *obj, |
| 211 | CRYPTO_EX_DATA *ad) { |
David Benjamin | 45dab25 | 2015-12-04 23:20:43 -0500 | [diff] [blame] | 212 | if (ad->sk == NULL) { |
David Benjamin | 808f832 | 2017-08-18 14:06:02 -0400 | [diff] [blame] | 213 | // Nothing to do. |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 214 | return; |
| 215 | } |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 216 | |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 217 | uint32_t num_funcs = CRYPTO_atomic_load_u32(&ex_data_class->num_funcs); |
David Benjamin | 7ff871a | 2022-11-23 12:02:37 -0500 | [diff] [blame] | 218 | // |CRYPTO_get_ex_new_index| will not allocate indices beyond |INT_MAX|. |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 219 | assert(num_funcs <= (size_t)(INT_MAX - ex_data_class->num_reserved)); |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 220 | |
David Benjamin | f712c86 | 2023-05-22 16:13:08 -0400 | [diff] [blame] | 221 | // Defer dereferencing |ex_data_class->funcs| and |funcs->next|. It must come |
| 222 | // after the |num_funcs| comparison to be correctly synchronized. |
| 223 | CRYPTO_EX_DATA_FUNCS *const *funcs = &ex_data_class->funcs; |
| 224 | for (uint32_t i = 0; i < num_funcs; i++) { |
| 225 | if ((*funcs)->free_func != NULL) { |
| 226 | int index = (int)i + ex_data_class->num_reserved; |
| 227 | void *ptr = CRYPTO_get_ex_data(ad, index); |
| 228 | (*funcs)->free_func(obj, ptr, ad, index, (*funcs)->argl, (*funcs)->argp); |
| 229 | } |
| 230 | funcs = &(*funcs)->next; |
| 231 | } |
David Benjamin | 32cd83f | 2015-04-15 15:28:43 -0400 | [diff] [blame] | 232 | |
David Benjamin | cca4ba7 | 2015-04-22 15:49:27 -0400 | [diff] [blame] | 233 | sk_void_free(ad->sk); |
| 234 | ad->sk = NULL; |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 235 | } |
| 236 | |
David Benjamin | 9f33fc6 | 2015-04-15 17:29:53 -0400 | [diff] [blame] | 237 | void CRYPTO_cleanup_all_ex_data(void) {} |