1/*
2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10/* ====================================================================
11 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
12 * ECDH support in OpenSSL originally developed by
13 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
14 */
15
16#ifndef HEADER_CRYPTO_H
17# define HEADER_CRYPTO_H
18
19# include <stdlib.h>
20# include <time.h>
21
22# include <openssl/e_os2.h>
23
24# ifndef OPENSSL_NO_STDIO
25# include <stdio.h>
26# endif
27
28# include <openssl/stack.h>
29# include <openssl/safestack.h>
30# include <openssl/opensslv.h>
31# include <openssl/ossl_typ.h>
32# include <openssl/opensslconf.h>
33
34# ifdef CHARSET_EBCDIC
35# include <openssl/ebcdic.h>
36# endif
37
38/*
39 * Resolve problems on some operating systems with symbol names that clash
40 * one way or another
41 */
42# include <openssl/symhacks.h>
43
44# if OPENSSL_API_COMPAT < 0x10100000L
45# include <openssl/opensslv.h>
46# endif
47
48#ifdef __cplusplus
49extern "C" {
50#endif
51
52# if OPENSSL_API_COMPAT < 0x10100000L
53# define SSLeay OpenSSL_version_num
54# define SSLeay_version OpenSSL_version
55# define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER
56# define SSLEAY_VERSION OPENSSL_VERSION
57# define SSLEAY_CFLAGS OPENSSL_CFLAGS
58# define SSLEAY_BUILT_ON OPENSSL_BUILT_ON
59# define SSLEAY_PLATFORM OPENSSL_PLATFORM
60# define SSLEAY_DIR OPENSSL_DIR
61
62/*
63 * Old type for allocating dynamic locks. No longer used. Use the new thread
64 * API instead.
65 */
66typedef struct {
67 int dummy;
68} CRYPTO_dynlock;
69
70# endif /* OPENSSL_API_COMPAT */
71
72typedef void CRYPTO_RWLOCK;
73
74CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void);
75int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock);
76int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock);
77int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock);
78void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock);
79
80int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock);
81
82/*
83 * The following can be used to detect memory leaks in the library. If
84 * used, it turns on malloc checking
85 */
86# define CRYPTO_MEM_CHECK_OFF 0x0 /* Control only */
87# define CRYPTO_MEM_CHECK_ON 0x1 /* Control and mode bit */
88# define CRYPTO_MEM_CHECK_ENABLE 0x2 /* Control and mode bit */
89# define CRYPTO_MEM_CHECK_DISABLE 0x3 /* Control only */
90
91struct crypto_ex_data_st {
92 STACK_OF(void) *sk;
93};
94DEFINE_STACK_OF(void)
95
96/*
97 * Per class, we have a STACK of function pointers.
98 */
99# define CRYPTO_EX_INDEX_SSL 0
100# define CRYPTO_EX_INDEX_SSL_CTX 1
101# define CRYPTO_EX_INDEX_SSL_SESSION 2
102# define CRYPTO_EX_INDEX_X509 3
103# define CRYPTO_EX_INDEX_X509_STORE 4
104# define CRYPTO_EX_INDEX_X509_STORE_CTX 5
105# define CRYPTO_EX_INDEX_DH 6
106# define CRYPTO_EX_INDEX_DSA 7
107# define CRYPTO_EX_INDEX_EC_KEY 8
108# define CRYPTO_EX_INDEX_RSA 9
109# define CRYPTO_EX_INDEX_ENGINE 10
110# define CRYPTO_EX_INDEX_UI 11
111# define CRYPTO_EX_INDEX_BIO 12
112# define CRYPTO_EX_INDEX_APP 13
113# define CRYPTO_EX_INDEX__COUNT 14
114
115/*
116 * This is the default callbacks, but we can have others as well: this is
117 * needed in Win32 where the application malloc and the library malloc may
118 * not be the same.
119 */
120#define OPENSSL_malloc_init() \
121 CRYPTO_set_mem_functions(CRYPTO_malloc, CRYPTO_realloc, CRYPTO_free)
122
123int CRYPTO_mem_ctrl(int mode);
124
125# define OPENSSL_malloc(num) \
126 CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
127# define OPENSSL_zalloc(num) \
128 CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
129# define OPENSSL_realloc(addr, num) \
130 CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE)
131# define OPENSSL_clear_realloc(addr, old_num, num) \
132 CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE)
133# define OPENSSL_clear_free(addr, num) \
134 CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
135# define OPENSSL_free(addr) \
136 CRYPTO_free(addr, OPENSSL_FILE, OPENSSL_LINE)
137# define OPENSSL_memdup(str, s) \
138 CRYPTO_memdup((str), s, OPENSSL_FILE, OPENSSL_LINE)
139# define OPENSSL_strdup(str) \
140 CRYPTO_strdup(str, OPENSSL_FILE, OPENSSL_LINE)
141# define OPENSSL_strndup(str, n) \
142 CRYPTO_strndup(str, n, OPENSSL_FILE, OPENSSL_LINE)
143# define OPENSSL_secure_malloc(num) \
144 CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
145# define OPENSSL_secure_zalloc(num) \
146 CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
147# define OPENSSL_secure_free(addr) \
148 CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE)
149# define OPENSSL_secure_clear_free(addr, num) \
150 CRYPTO_secure_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
151# define OPENSSL_secure_actual_size(ptr) \
152 CRYPTO_secure_actual_size(ptr)
153
154size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz);
155size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz);
156size_t OPENSSL_strnlen(const char *str, size_t maxlen);
157char *OPENSSL_buf2hexstr(const unsigned char *buffer, long len);
158unsigned char *OPENSSL_hexstr2buf(const char *str, long *len);
159int OPENSSL_hexchar2int(unsigned char c);
160
161# define OPENSSL_MALLOC_MAX_NELEMS(type) (((1U<<(sizeof(int)*8-1))-1)/sizeof(type))
162
163unsigned long OpenSSL_version_num(void);
164const char *OpenSSL_version(int type);
165# define OPENSSL_VERSION 0
166# define OPENSSL_CFLAGS 1
167# define OPENSSL_BUILT_ON 2
168# define OPENSSL_PLATFORM 3
169# define OPENSSL_DIR 4
170# define OPENSSL_ENGINES_DIR 5
171
172int OPENSSL_issetugid(void);
173
174typedef void CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
175 int idx, long argl, void *argp);
176typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
177 int idx, long argl, void *argp);
178typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
179 void *from_d, int idx, long argl, void *argp);
180__owur int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
181 CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
182 CRYPTO_EX_free *free_func);
183/* No longer use an index. */
184int CRYPTO_free_ex_index(int class_index, int idx);
185
186/*
187 * Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a
188 * given class (invokes whatever per-class callbacks are applicable)
189 */
190int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
191int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
192 const CRYPTO_EX_DATA *from);
193
194void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
195
196/*
197 * Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular
198 * index (relative to the class type involved)
199 */
200int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
201void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
202
203# if OPENSSL_API_COMPAT < 0x10100000L
204/*
205 * This function cleans up all "ex_data" state. It mustn't be called under
206 * potential race-conditions.
207 */
208# define CRYPTO_cleanup_all_ex_data() while(0) continue
209
210/*
211 * The old locking functions have been removed completely without compatibility
212 * macros. This is because the old functions either could not properly report
213 * errors, or the returned error values were not clearly documented.
214 * Replacing the locking functions with with no-ops would cause race condition
215 * issues in the affected applications. It is far better for them to fail at
216 * compile time.
217 * On the other hand, the locking callbacks are no longer used. Consequently,
218 * the callback management functions can be safely replaced with no-op macros.
219 */
220# define CRYPTO_num_locks() (1)
221# define CRYPTO_set_locking_callback(func)
222# define CRYPTO_get_locking_callback() (NULL)
223# define CRYPTO_set_add_lock_callback(func)
224# define CRYPTO_get_add_lock_callback() (NULL)
225
226/*
227 * These defines where used in combination with the old locking callbacks,
228 * they are not called anymore, but old code that's not called might still
229 * use them.
230 */
231# define CRYPTO_LOCK 1
232# define CRYPTO_UNLOCK 2
233# define CRYPTO_READ 4
234# define CRYPTO_WRITE 8
235
236/* This structure is no longer used */
237typedef struct crypto_threadid_st {
238 int dummy;
239} CRYPTO_THREADID;
240/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
241# define CRYPTO_THREADID_set_numeric(id, val)
242# define CRYPTO_THREADID_set_pointer(id, ptr)
243# define CRYPTO_THREADID_set_callback(threadid_func) (0)
244# define CRYPTO_THREADID_get_callback() (NULL)
245# define CRYPTO_THREADID_current(id)
246# define CRYPTO_THREADID_cmp(a, b) (-1)
247# define CRYPTO_THREADID_cpy(dest, src)
248# define CRYPTO_THREADID_hash(id) (0UL)
249
250# if OPENSSL_API_COMPAT < 0x10000000L
251# define CRYPTO_set_id_callback(func)
252# define CRYPTO_get_id_callback() (NULL)
253# define CRYPTO_thread_id() (0UL)
254# endif /* OPENSSL_API_COMPAT < 0x10000000L */
255
256# define CRYPTO_set_dynlock_create_callback(dyn_create_function)
257# define CRYPTO_set_dynlock_lock_callback(dyn_lock_function)
258# define CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function)
259# define CRYPTO_get_dynlock_create_callback() (NULL)
260# define CRYPTO_get_dynlock_lock_callback() (NULL)
261# define CRYPTO_get_dynlock_destroy_callback() (NULL)
262# endif /* OPENSSL_API_COMPAT < 0x10100000L */
263
264int CRYPTO_set_mem_functions(
265 void *(*m) (size_t, const char *, int),
266 void *(*r) (void *, size_t, const char *, int),
267 void (*f) (void *, const char *, int));
268int CRYPTO_set_mem_debug(int flag);
269void CRYPTO_get_mem_functions(
270 void *(**m) (size_t, const char *, int),
271 void *(**r) (void *, size_t, const char *, int),
272 void (**f) (void *, const char *, int));
273
274void *CRYPTO_malloc(size_t num, const char *file, int line);
275void *CRYPTO_zalloc(size_t num, const char *file, int line);
276void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line);
277char *CRYPTO_strdup(const char *str, const char *file, int line);
278char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line);
279void CRYPTO_free(void *ptr, const char *file, int line);
280void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line);
281void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line);
282void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
283 const char *file, int line);
284
285int CRYPTO_secure_malloc_init(size_t sz, int minsize);
286int CRYPTO_secure_malloc_done(void);
287void *CRYPTO_secure_malloc(size_t num, const char *file, int line);
288void *CRYPTO_secure_zalloc(size_t num, const char *file, int line);
289void CRYPTO_secure_free(void *ptr, const char *file, int line);
290void CRYPTO_secure_clear_free(void *ptr, size_t num,
291 const char *file, int line);
292int CRYPTO_secure_allocated(const void *ptr);
293int CRYPTO_secure_malloc_initialized(void);
294size_t CRYPTO_secure_actual_size(void *ptr);
295size_t CRYPTO_secure_used(void);
296
297void OPENSSL_cleanse(void *ptr, size_t len);
298
299# ifndef OPENSSL_NO_CRYPTO_MDEBUG
300# define OPENSSL_mem_debug_push(info) \
301 CRYPTO_mem_debug_push(info, OPENSSL_FILE, OPENSSL_LINE)
302# define OPENSSL_mem_debug_pop() \
303 CRYPTO_mem_debug_pop()
304int CRYPTO_mem_debug_push(const char *info, const char *file, int line);
305int CRYPTO_mem_debug_pop(void);
306
307/*-
308 * Debugging functions (enabled by CRYPTO_set_mem_debug(1))
309 * The flag argument has the following significance:
310 * 0: called before the actual memory allocation has taken place
311 * 1: called after the actual memory allocation has taken place
312 */
313void CRYPTO_mem_debug_malloc(void *addr, size_t num, int flag,
314 const char *file, int line);
315void CRYPTO_mem_debug_realloc(void *addr1, void *addr2, size_t num, int flag,
316 const char *file, int line);
317void CRYPTO_mem_debug_free(void *addr, int flag,
318 const char *file, int line);
319
320# ifndef OPENSSL_NO_STDIO
321int CRYPTO_mem_leaks_fp(FILE *);
322# endif
323int CRYPTO_mem_leaks(BIO *bio);
324# endif
325
326/* die if we have to */
327ossl_noreturn void OPENSSL_die(const char *assertion, const char *file, int line);
328# if OPENSSL_API_COMPAT < 0x10100000L
329# define OpenSSLDie(f,l,a) OPENSSL_die((a),(f),(l))
330# endif
331# define OPENSSL_assert(e) \
332 (void)((e) ? 0 : (OPENSSL_die("assertion failed: " #e, OPENSSL_FILE, OPENSSL_LINE), 1))
333
334int OPENSSL_isservice(void);
335
336int FIPS_mode(void);
337int FIPS_mode_set(int r);
338
339void OPENSSL_init(void);
340
341struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result);
342int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec);
343int OPENSSL_gmtime_diff(int *pday, int *psec,
344 const struct tm *from, const struct tm *to);
345
346/*
347 * CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal.
348 * It takes an amount of time dependent on |len|, but independent of the
349 * contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements
350 * into a defined order as the return value when a != b is undefined, other
351 * than to be non-zero.
352 */
353int CRYPTO_memcmp(const volatile void * volatile in_a,
354 const volatile void * volatile in_b,
355 size_t len);
356
357/* Standard initialisation options */
358# define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0x00000001L
359# define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0x00000002L
360# define OPENSSL_INIT_ADD_ALL_CIPHERS 0x00000004L
361# define OPENSSL_INIT_ADD_ALL_DIGESTS 0x00000008L
362# define OPENSSL_INIT_NO_ADD_ALL_CIPHERS 0x00000010L
363# define OPENSSL_INIT_NO_ADD_ALL_DIGESTS 0x00000020L
364# define OPENSSL_INIT_LOAD_CONFIG 0x00000040L
365# define OPENSSL_INIT_NO_LOAD_CONFIG 0x00000080L
366# define OPENSSL_INIT_ASYNC 0x00000100L
367# define OPENSSL_INIT_ENGINE_RDRAND 0x00000200L
368# define OPENSSL_INIT_ENGINE_DYNAMIC 0x00000400L
369# define OPENSSL_INIT_ENGINE_OPENSSL 0x00000800L
370# define OPENSSL_INIT_ENGINE_CRYPTODEV 0x00001000L
371# define OPENSSL_INIT_ENGINE_CAPI 0x00002000L
372# define OPENSSL_INIT_ENGINE_PADLOCK 0x00004000L
373# define OPENSSL_INIT_ENGINE_AFALG 0x00008000L
374/* OPENSSL_INIT flag 0x00010000 reserved for internal use */
375/* OPENSSL_INIT flag range 0xfff00000 reserved for OPENSSL_init_ssl() */
376/* Max OPENSSL_INIT flag value is 0x80000000 */
377
378/* openssl and dasync not counted as builtin */
379# define OPENSSL_INIT_ENGINE_ALL_BUILTIN \
380 (OPENSSL_INIT_ENGINE_RDRAND | OPENSSL_INIT_ENGINE_DYNAMIC \
381 | OPENSSL_INIT_ENGINE_CRYPTODEV | OPENSSL_INIT_ENGINE_CAPI | \
382 OPENSSL_INIT_ENGINE_PADLOCK)
383
384
385/* Library initialisation functions */
386void OPENSSL_cleanup(void);
387int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
388int OPENSSL_atexit(void (*handler)(void));
389void OPENSSL_thread_stop(void);
390
391/* Low-level control of initialization */
392OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void);
393# ifndef OPENSSL_NO_STDIO
394int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings,
395 const char *config_file);
396# endif
397void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings);
398
399# if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
400# if defined(_WIN32)
401# if defined(BASETYPES) || defined(_WINDEF_H)
402/* application has to include <windows.h> in order to use this */
403typedef DWORD CRYPTO_THREAD_LOCAL;
404typedef DWORD CRYPTO_THREAD_ID;
405
406typedef LONG CRYPTO_ONCE;
407# define CRYPTO_ONCE_STATIC_INIT 0
408# endif
409# else
410# include <pthread.h>
411typedef pthread_once_t CRYPTO_ONCE;
412typedef pthread_key_t CRYPTO_THREAD_LOCAL;
413typedef pthread_t CRYPTO_THREAD_ID;
414
415# define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT
416# endif
417# endif
418
419# if !defined(CRYPTO_ONCE_STATIC_INIT)
420typedef unsigned int CRYPTO_ONCE;
421typedef unsigned int CRYPTO_THREAD_LOCAL;
422typedef unsigned int CRYPTO_THREAD_ID;
423# define CRYPTO_ONCE_STATIC_INIT 0
424# endif
425
426int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void));
427
428int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *));
429void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key);
430int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val);
431int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key);
432
433CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void);
434int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b);
435
436/* BEGIN ERROR CODES */
437/*
438 * The following lines are auto generated by the script mkerr.pl. Any changes
439 * made after this point may be overwritten when the script is next run.
440 */
441
442int ERR_load_CRYPTO_strings(void);
443
444/* Error codes for the CRYPTO functions. */
445
446/* Function codes. */
447# define CRYPTO_F_CRYPTO_DUP_EX_DATA 110
448# define CRYPTO_F_CRYPTO_FREE_EX_DATA 111
449# define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 100
450# define CRYPTO_F_CRYPTO_MEMDUP 115
451# define CRYPTO_F_CRYPTO_NEW_EX_DATA 112
452# define CRYPTO_F_CRYPTO_SET_EX_DATA 102
453# define CRYPTO_F_FIPS_MODE_SET 109
454# define CRYPTO_F_GET_AND_LOCK 113
455# define CRYPTO_F_OPENSSL_BUF2HEXSTR 117
456# define CRYPTO_F_OPENSSL_HEXSTR2BUF 118
457# define CRYPTO_F_OPENSSL_INIT_CRYPTO 116
458
459/* Reason codes. */
460# define CRYPTO_R_FIPS_MODE_NOT_SUPPORTED 101
461# define CRYPTO_R_ILLEGAL_HEX_DIGIT 102
462# define CRYPTO_R_ODD_NUMBER_OF_DIGITS 103
463
464# ifdef __cplusplus
465}
466# endif
467#endif
468