<deleted>:rust into master
| @ -1,5 +1,8 @@ | |||
| /target | |||
| **/*.rs.bk | |||
| Cargo.lock | |||
| node_modules/ | |||
| package-lock.json | |||
| build/ | |||
| test.js | |||
| .vscode | |||
| *.node | |||
| test.js | |||
| @ -0,0 +1,31 @@ | |||
| [package] | |||
| name = "deezcryptor" | |||
| version = "0.1.0" | |||
| authors = ["sagudev <samo.golez@outlook.com>"] | |||
| edition = "2018" | |||
| [features] | |||
| default = ["blowfish/bcrypt"] | |||
| [lib] | |||
| crate-type = ["cdylib"] | |||
| [dependencies] | |||
| napi = "1" | |||
| napi-derive = "1" | |||
| md-5 = "0.9" | |||
| blowfish = "0.7" | |||
| block-modes = "0.7" | |||
| [target.'cfg(all(unix, not(target_env = "musl"), not(target_arch = "aarch64")))'.dependencies] | |||
| jemallocator = {version = "0.3", features = ["disable_initial_exec_tls"]} | |||
| [target.'cfg(all(windows, target_arch = "x86_64"))'.dependencies] | |||
| mimalloc = {version = "0.1"} | |||
| [build-dependencies] | |||
| napi-build = "1" | |||
| [profile.release] | |||
| lto = true | |||
| opt-level = 3 | |||
| @ -1,48 +0,0 @@ | |||
| { | |||
| "targets": [ | |||
| { | |||
| "target_name": "decryptor", | |||
| "cflags!": [ "-fno-exceptions" ], | |||
| "cflags_cc!": [ "-fno-exceptions" ], | |||
| "sources": [ "native/decryptor.cc" ], | |||
| "include_dirs": [ | |||
| "<!@(node -p \"require('node-addon-api').include\")" | |||
| ], | |||
| 'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ], | |||
| 'conditions': [ | |||
| ["OS=='linux'", { | |||
| 'libraries': [ | |||
| '-lcrypto', | |||
| '-lssl' | |||
| ] | |||
| }], | |||
| ["OS=='win'", { | |||
| "include_dirs": [ | |||
| "<!@(node -p \"require('node-addon-api').include\")", | |||
| "<(module_root_dir)\openssl\include" | |||
| ], | |||
| "link_settings": { | |||
| "libraries": [ | |||
| "<(module_root_dir)\openssl\lib\libcrypto.lib", | |||
| "<(module_root_dir)\openssl\lib\libssl.lib" | |||
| ] | |||
| }, | |||
| "variables": { | |||
| "dll_files": [ | |||
| "<(module_root_dir)\openssl\libcrypto-1_1-x64.dll", | |||
| "<(module_root_dir)\openssl\libssl-1_1-x64.dll" | |||
| ] | |||
| }, | |||
| "copies": [{ | |||
| "destination": "<(module_root_dir)/build/Release/", | |||
| "files": [ | |||
| "<(module_root_dir)\openssl\libcrypto-1_1-x64.dll", | |||
| "<(module_root_dir)\openssl\libssl-1_1-x64.dll" | |||
| ] | |||
| }] | |||
| }] | |||
| ] | |||
| } | |||
| ] | |||
| } | |||
| @ -0,0 +1,5 @@ | |||
| extern crate napi_build; | |||
| fn main() { | |||
| napi_build::setup(); | |||
| } | |||
| @ -1,52 +0,0 @@ | |||
| #include <napi.h> | |||
| #include <iostream> | |||
| #include "decryptor.h" | |||
| Napi::Value napiGetKey(const Napi::CallbackInfo& info) { | |||
| Napi::Env env = info.Env(); | |||
| std::string trackIdArg = info[0].As<Napi::String>().Utf8Value(); | |||
| char* trackId = new char[trackIdArg.length() + 1]; | |||
| strcpy(trackId, trackIdArg.c_str()); | |||
| char key[16]; | |||
| getKey(trackId, key); | |||
| return Napi::String::New(env, key, 16); | |||
| } | |||
| void napiDecryptFile(const Napi::CallbackInfo& info) { | |||
| std::string decKeyArg = info[0].As<Napi::String>().Utf8Value(); | |||
| char* decKey = new char[17]; | |||
| strcpy(decKey, decKeyArg.c_str()); | |||
| std::string inputFn = info[1].As<Napi::String>().Utf8Value(); | |||
| std::string outputFn = info[2].As<Napi::String>().Utf8Value(); | |||
| decryptFile(decKey, inputFn.c_str(), outputFn.c_str()); | |||
| return; | |||
| } | |||
| Napi::Value napiDecryptBuffer(const Napi::CallbackInfo& info) { | |||
| Napi::Env env = info.Env(); | |||
| std::string decKeyArg = info[0].As<Napi::String>().Utf8Value(); | |||
| char* decKey = new char[17]; | |||
| strcpy(decKey, decKeyArg.c_str()); | |||
| size_t arrlen = info[1].As<Napi::Buffer<unsigned char>>().Length(); | |||
| unsigned char* buffer = info[1].As<Napi::Buffer<unsigned char>>().Data(); | |||
| unsigned char* decrypted = new unsigned char[arrlen]; | |||
| decryptBytes(decKey, arrlen, buffer, decrypted); | |||
| return Napi::Buffer<unsigned char>::New(env, decrypted, arrlen); | |||
| } | |||
| Napi::Object Init(Napi::Env env, Napi::Object exports) { | |||
| exports.Set(Napi::String::New(env, "getKey"), Napi::Function::New(env, napiGetKey)); | |||
| exports.Set(Napi::String::New(env, "decryptFile"), Napi::Function::New(env, napiDecryptFile)); | |||
| exports.Set(Napi::String::New(env, "decryptBuffer"), Napi::Function::New(env, napiDecryptBuffer)); | |||
| return exports; | |||
| } | |||
| NODE_API_MODULE(decryptor, Init) | |||
| @ -1,73 +0,0 @@ | |||
| #include <stdio.h> | |||
| #include <stdlib.h> | |||
| #include <string.h> | |||
| #include <openssl/md5.h> | |||
| #include <openssl/blowfish.h> | |||
| void getKey(char* trackId, char* key) { | |||
| unsigned char digest[MD5_DIGEST_LENGTH]; | |||
| MD5_CTX context; | |||
| MD5_Init(&context); | |||
| MD5_Update(&context, trackId, strlen(trackId)); | |||
| MD5_Final(digest, &context); | |||
| char MD5String[33]; | |||
| for (int i = 0; i < 16; i++) | |||
| sprintf(&MD5String[i*2], "%02x", (unsigned int)digest[i]); | |||
| const char secret[] = "g4el58wc0zvf9na1"; | |||
| for(int i=0; i<16; i++) | |||
| key[i] = MD5String[i] ^ MD5String[i+16] ^ secret[i]; | |||
| } | |||
| void decryptFile(char* decKey, const char* inputfn, const char* outputfn) { | |||
| unsigned char* bfKey = reinterpret_cast<unsigned char*>(decKey); | |||
| BF_KEY key; | |||
| BF_set_key(&key, 16, bfKey); | |||
| FILE* ofile = fopen(outputfn, "wb"); | |||
| FILE* ifile = fopen(inputfn, "rb"); | |||
| int i=0; | |||
| while (!feof(ifile)) { | |||
| unsigned char buffer[2048]; | |||
| int read = fread(buffer, 1, 2048, ifile); | |||
| if (i % 3 == 0 && read == 2048) { | |||
| unsigned char decrypted[2048]; | |||
| unsigned char IV[8] = {0,1,2,3,4,5,6,7}; | |||
| BF_cbc_encrypt(buffer, decrypted, 2048, &key, IV, BF_DECRYPT); | |||
| fwrite(decrypted, sizeof(unsigned char), sizeof(decrypted), ofile); | |||
| } else { | |||
| fwrite(buffer, sizeof(unsigned char), read, ofile); | |||
| } | |||
| i++; | |||
| } | |||
| fclose(ofile); | |||
| fclose(ifile); | |||
| } | |||
| void decryptBytes(char* decKey, long length, unsigned char* data, unsigned char* output) { | |||
| unsigned char* bfKey = reinterpret_cast<unsigned char*>(decKey); | |||
| BF_KEY key; | |||
| BF_set_key(&key, 16, bfKey); | |||
| int count = length/2048; | |||
| int i=0; | |||
| for(i=0; i<count; i++) { | |||
| if (i % 3 == 0) { | |||
| unsigned char buffer[2048]; | |||
| memcpy(buffer, &data[i*2048], 2048); | |||
| unsigned char decrypted[2048]; | |||
| unsigned char IV[8] = {0,1,2,3,4,5,6,7}; | |||
| BF_cbc_encrypt(buffer, decrypted, 2048, &key, IV, BF_DECRYPT); | |||
| memcpy(&output[i*2048], decrypted, 2048); | |||
| } else { | |||
| memcpy(&output[i*2048], &data[i*2048], 2048); | |||
| } | |||
| } | |||
| if (length % 2048 != 0){ | |||
| memcpy(&output[i*2048], &data[i*2048], (length-(i*2048))); | |||
| } | |||
| } | |||
| @ -1,92 +0,0 @@ | |||
| /* | |||
| * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_AES_H | |||
| # define HEADER_AES_H | |||
| # include <openssl/opensslconf.h> | |||
| # include <stddef.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| # define AES_ENCRYPT 1 | |||
| # define AES_DECRYPT 0 | |||
| /* | |||
| * Because array size can't be a const in C, the following two are macros. | |||
| * Both sizes are in bytes. | |||
| */ | |||
| # define AES_MAXNR 14 | |||
| # define AES_BLOCK_SIZE 16 | |||
| /* This should be a hidden type, but EVP requires that the size be known */ | |||
| struct aes_key_st { | |||
| # ifdef AES_LONG | |||
| unsigned long rd_key[4 * (AES_MAXNR + 1)]; | |||
| # else | |||
| unsigned int rd_key[4 * (AES_MAXNR + 1)]; | |||
| # endif | |||
| int rounds; | |||
| }; | |||
| typedef struct aes_key_st AES_KEY; | |||
| const char *AES_options(void); | |||
| int AES_set_encrypt_key(const unsigned char *userKey, const int bits, | |||
| AES_KEY *key); | |||
| int AES_set_decrypt_key(const unsigned char *userKey, const int bits, | |||
| AES_KEY *key); | |||
| void AES_encrypt(const unsigned char *in, unsigned char *out, | |||
| const AES_KEY *key); | |||
| void AES_decrypt(const unsigned char *in, unsigned char *out, | |||
| const AES_KEY *key); | |||
| void AES_ecb_encrypt(const unsigned char *in, unsigned char *out, | |||
| const AES_KEY *key, const int enc); | |||
| void AES_cbc_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const AES_KEY *key, | |||
| unsigned char *ivec, const int enc); | |||
| void AES_cfb128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const AES_KEY *key, | |||
| unsigned char *ivec, int *num, const int enc); | |||
| void AES_cfb1_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const AES_KEY *key, | |||
| unsigned char *ivec, int *num, const int enc); | |||
| void AES_cfb8_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const AES_KEY *key, | |||
| unsigned char *ivec, int *num, const int enc); | |||
| void AES_ofb128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const AES_KEY *key, | |||
| unsigned char *ivec, int *num); | |||
| /* NB: the IV is _two_ blocks long */ | |||
| void AES_ige_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const AES_KEY *key, | |||
| unsigned char *ivec, const int enc); | |||
| /* NB: the IV is _four_ blocks long */ | |||
| void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const AES_KEY *key, | |||
| const AES_KEY *key2, const unsigned char *ivec, | |||
| const int enc); | |||
| int AES_wrap_key(AES_KEY *key, const unsigned char *iv, | |||
| unsigned char *out, | |||
| const unsigned char *in, unsigned int inlen); | |||
| int AES_unwrap_key(AES_KEY *key, const unsigned char *iv, | |||
| unsigned char *out, | |||
| const unsigned char *in, unsigned int inlen); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,138 +0,0 @@ | |||
| /* | |||
| * Copyright 2004-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #define APPLINK_STDIN 1 | |||
| #define APPLINK_STDOUT 2 | |||
| #define APPLINK_STDERR 3 | |||
| #define APPLINK_FPRINTF 4 | |||
| #define APPLINK_FGETS 5 | |||
| #define APPLINK_FREAD 6 | |||
| #define APPLINK_FWRITE 7 | |||
| #define APPLINK_FSETMOD 8 | |||
| #define APPLINK_FEOF 9 | |||
| #define APPLINK_FCLOSE 10 /* should not be used */ | |||
| #define APPLINK_FOPEN 11 /* solely for completeness */ | |||
| #define APPLINK_FSEEK 12 | |||
| #define APPLINK_FTELL 13 | |||
| #define APPLINK_FFLUSH 14 | |||
| #define APPLINK_FERROR 15 | |||
| #define APPLINK_CLEARERR 16 | |||
| #define APPLINK_FILENO 17 /* to be used with below */ | |||
| #define APPLINK_OPEN 18 /* formally can't be used, as flags can vary */ | |||
| #define APPLINK_READ 19 | |||
| #define APPLINK_WRITE 20 | |||
| #define APPLINK_LSEEK 21 | |||
| #define APPLINK_CLOSE 22 | |||
| #define APPLINK_MAX 22 /* always same as last macro */ | |||
| #ifndef APPMACROS_ONLY | |||
| # include <stdio.h> | |||
| # include <io.h> | |||
| # include <fcntl.h> | |||
| static void *app_stdin(void) | |||
| { | |||
| return stdin; | |||
| } | |||
| static void *app_stdout(void) | |||
| { | |||
| return stdout; | |||
| } | |||
| static void *app_stderr(void) | |||
| { | |||
| return stderr; | |||
| } | |||
| static int app_feof(FILE *fp) | |||
| { | |||
| return feof(fp); | |||
| } | |||
| static int app_ferror(FILE *fp) | |||
| { | |||
| return ferror(fp); | |||
| } | |||
| static void app_clearerr(FILE *fp) | |||
| { | |||
| clearerr(fp); | |||
| } | |||
| static int app_fileno(FILE *fp) | |||
| { | |||
| return _fileno(fp); | |||
| } | |||
| static int app_fsetmod(FILE *fp, char mod) | |||
| { | |||
| return _setmode(_fileno(fp), mod == 'b' ? _O_BINARY : _O_TEXT); | |||
| } | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| __declspec(dllexport) | |||
| void ** | |||
| # if defined(__BORLANDC__) | |||
| /* | |||
| * __stdcall appears to be the only way to get the name | |||
| * decoration right with Borland C. Otherwise it works | |||
| * purely incidentally, as we pass no parameters. | |||
| */ | |||
| __stdcall | |||
| # else | |||
| __cdecl | |||
| # endif | |||
| OPENSSL_Applink(void) | |||
| { | |||
| static int once = 1; | |||
| static void *OPENSSL_ApplinkTable[APPLINK_MAX + 1] = | |||
| { (void *)APPLINK_MAX }; | |||
| if (once) { | |||
| OPENSSL_ApplinkTable[APPLINK_STDIN] = app_stdin; | |||
| OPENSSL_ApplinkTable[APPLINK_STDOUT] = app_stdout; | |||
| OPENSSL_ApplinkTable[APPLINK_STDERR] = app_stderr; | |||
| OPENSSL_ApplinkTable[APPLINK_FPRINTF] = fprintf; | |||
| OPENSSL_ApplinkTable[APPLINK_FGETS] = fgets; | |||
| OPENSSL_ApplinkTable[APPLINK_FREAD] = fread; | |||
| OPENSSL_ApplinkTable[APPLINK_FWRITE] = fwrite; | |||
| OPENSSL_ApplinkTable[APPLINK_FSETMOD] = app_fsetmod; | |||
| OPENSSL_ApplinkTable[APPLINK_FEOF] = app_feof; | |||
| OPENSSL_ApplinkTable[APPLINK_FCLOSE] = fclose; | |||
| OPENSSL_ApplinkTable[APPLINK_FOPEN] = fopen; | |||
| OPENSSL_ApplinkTable[APPLINK_FSEEK] = fseek; | |||
| OPENSSL_ApplinkTable[APPLINK_FTELL] = ftell; | |||
| OPENSSL_ApplinkTable[APPLINK_FFLUSH] = fflush; | |||
| OPENSSL_ApplinkTable[APPLINK_FERROR] = app_ferror; | |||
| OPENSSL_ApplinkTable[APPLINK_CLEARERR] = app_clearerr; | |||
| OPENSSL_ApplinkTable[APPLINK_FILENO] = app_fileno; | |||
| OPENSSL_ApplinkTable[APPLINK_OPEN] = _open; | |||
| OPENSSL_ApplinkTable[APPLINK_READ] = _read; | |||
| OPENSSL_ApplinkTable[APPLINK_WRITE] = _write; | |||
| OPENSSL_ApplinkTable[APPLINK_LSEEK] = _lseek; | |||
| OPENSSL_ApplinkTable[APPLINK_CLOSE] = _close; | |||
| once = 0; | |||
| } | |||
| return OPENSSL_ApplinkTable; | |||
| } | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,886 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_ASN1_H | |||
| # define HEADER_ASN1_H | |||
| # include <time.h> | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/opensslconf.h> | |||
| # include <openssl/bio.h> | |||
| # include <openssl/safestack.h> | |||
| # include <openssl/asn1err.h> | |||
| # include <openssl/symhacks.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # include <openssl/bn.h> | |||
| # endif | |||
| # ifdef OPENSSL_BUILD_SHLIBCRYPTO | |||
| # undef OPENSSL_EXTERN | |||
| # define OPENSSL_EXTERN OPENSSL_EXPORT | |||
| # endif | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # define V_ASN1_UNIVERSAL 0x00 | |||
| # define V_ASN1_APPLICATION 0x40 | |||
| # define V_ASN1_CONTEXT_SPECIFIC 0x80 | |||
| # define V_ASN1_PRIVATE 0xc0 | |||
| # define V_ASN1_CONSTRUCTED 0x20 | |||
| # define V_ASN1_PRIMITIVE_TAG 0x1f | |||
| # define V_ASN1_PRIMATIVE_TAG /*compat*/ V_ASN1_PRIMITIVE_TAG | |||
| # define V_ASN1_APP_CHOOSE -2/* let the recipient choose */ | |||
| # define V_ASN1_OTHER -3/* used in ASN1_TYPE */ | |||
| # define V_ASN1_ANY -4/* used in ASN1 template code */ | |||
| # define V_ASN1_UNDEF -1 | |||
| /* ASN.1 tag values */ | |||
| # define V_ASN1_EOC 0 | |||
| # define V_ASN1_BOOLEAN 1 /**/ | |||
| # define V_ASN1_INTEGER 2 | |||
| # define V_ASN1_BIT_STRING 3 | |||
| # define V_ASN1_OCTET_STRING 4 | |||
| # define V_ASN1_NULL 5 | |||
| # define V_ASN1_OBJECT 6 | |||
| # define V_ASN1_OBJECT_DESCRIPTOR 7 | |||
| # define V_ASN1_EXTERNAL 8 | |||
| # define V_ASN1_REAL 9 | |||
| # define V_ASN1_ENUMERATED 10 | |||
| # define V_ASN1_UTF8STRING 12 | |||
| # define V_ASN1_SEQUENCE 16 | |||
| # define V_ASN1_SET 17 | |||
| # define V_ASN1_NUMERICSTRING 18 /**/ | |||
| # define V_ASN1_PRINTABLESTRING 19 | |||
| # define V_ASN1_T61STRING 20 | |||
| # define V_ASN1_TELETEXSTRING 20/* alias */ | |||
| # define V_ASN1_VIDEOTEXSTRING 21 /**/ | |||
| # define V_ASN1_IA5STRING 22 | |||
| # define V_ASN1_UTCTIME 23 | |||
| # define V_ASN1_GENERALIZEDTIME 24 /**/ | |||
| # define V_ASN1_GRAPHICSTRING 25 /**/ | |||
| # define V_ASN1_ISO64STRING 26 /**/ | |||
| # define V_ASN1_VISIBLESTRING 26/* alias */ | |||
| # define V_ASN1_GENERALSTRING 27 /**/ | |||
| # define V_ASN1_UNIVERSALSTRING 28 /**/ | |||
| # define V_ASN1_BMPSTRING 30 | |||
| /* | |||
| * NB the constants below are used internally by ASN1_INTEGER | |||
| * and ASN1_ENUMERATED to indicate the sign. They are *not* on | |||
| * the wire tag values. | |||
| */ | |||
| # define V_ASN1_NEG 0x100 | |||
| # define V_ASN1_NEG_INTEGER (2 | V_ASN1_NEG) | |||
| # define V_ASN1_NEG_ENUMERATED (10 | V_ASN1_NEG) | |||
| /* For use with d2i_ASN1_type_bytes() */ | |||
| # define B_ASN1_NUMERICSTRING 0x0001 | |||
| # define B_ASN1_PRINTABLESTRING 0x0002 | |||
| # define B_ASN1_T61STRING 0x0004 | |||
| # define B_ASN1_TELETEXSTRING 0x0004 | |||
| # define B_ASN1_VIDEOTEXSTRING 0x0008 | |||
| # define B_ASN1_IA5STRING 0x0010 | |||
| # define B_ASN1_GRAPHICSTRING 0x0020 | |||
| # define B_ASN1_ISO64STRING 0x0040 | |||
| # define B_ASN1_VISIBLESTRING 0x0040 | |||
| # define B_ASN1_GENERALSTRING 0x0080 | |||
| # define B_ASN1_UNIVERSALSTRING 0x0100 | |||
| # define B_ASN1_OCTET_STRING 0x0200 | |||
| # define B_ASN1_BIT_STRING 0x0400 | |||
| # define B_ASN1_BMPSTRING 0x0800 | |||
| # define B_ASN1_UNKNOWN 0x1000 | |||
| # define B_ASN1_UTF8STRING 0x2000 | |||
| # define B_ASN1_UTCTIME 0x4000 | |||
| # define B_ASN1_GENERALIZEDTIME 0x8000 | |||
| # define B_ASN1_SEQUENCE 0x10000 | |||
| /* For use with ASN1_mbstring_copy() */ | |||
| # define MBSTRING_FLAG 0x1000 | |||
| # define MBSTRING_UTF8 (MBSTRING_FLAG) | |||
| # define MBSTRING_ASC (MBSTRING_FLAG|1) | |||
| # define MBSTRING_BMP (MBSTRING_FLAG|2) | |||
| # define MBSTRING_UNIV (MBSTRING_FLAG|4) | |||
| # define SMIME_OLDMIME 0x400 | |||
| # define SMIME_CRLFEOL 0x800 | |||
| # define SMIME_STREAM 0x1000 | |||
| struct X509_algor_st; | |||
| DEFINE_STACK_OF(X509_ALGOR) | |||
| # define ASN1_STRING_FLAG_BITS_LEFT 0x08/* Set if 0x07 has bits left value */ | |||
| /* | |||
| * This indicates that the ASN1_STRING is not a real value but just a place | |||
| * holder for the location where indefinite length constructed data should be | |||
| * inserted in the memory buffer | |||
| */ | |||
| # define ASN1_STRING_FLAG_NDEF 0x010 | |||
| /* | |||
| * This flag is used by the CMS code to indicate that a string is not | |||
| * complete and is a place holder for content when it had all been accessed. | |||
| * The flag will be reset when content has been written to it. | |||
| */ | |||
| # define ASN1_STRING_FLAG_CONT 0x020 | |||
| /* | |||
| * This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING | |||
| * type. | |||
| */ | |||
| # define ASN1_STRING_FLAG_MSTRING 0x040 | |||
| /* String is embedded and only content should be freed */ | |||
| # define ASN1_STRING_FLAG_EMBED 0x080 | |||
| /* String should be parsed in RFC 5280's time format */ | |||
| # define ASN1_STRING_FLAG_X509_TIME 0x100 | |||
| /* This is the base type that holds just about everything :-) */ | |||
| struct asn1_string_st { | |||
| int length; | |||
| int type; | |||
| unsigned char *data; | |||
| /* | |||
| * The value of the following field depends on the type being held. It | |||
| * is mostly being used for BIT_STRING so if the input data has a | |||
| * non-zero 'unused bits' value, it will be handled correctly | |||
| */ | |||
| long flags; | |||
| }; | |||
| /* | |||
| * ASN1_ENCODING structure: this is used to save the received encoding of an | |||
| * ASN1 type. This is useful to get round problems with invalid encodings | |||
| * which can break signatures. | |||
| */ | |||
| typedef struct ASN1_ENCODING_st { | |||
| unsigned char *enc; /* DER encoding */ | |||
| long len; /* Length of encoding */ | |||
| int modified; /* set to 1 if 'enc' is invalid */ | |||
| } ASN1_ENCODING; | |||
| /* Used with ASN1 LONG type: if a long is set to this it is omitted */ | |||
| # define ASN1_LONG_UNDEF 0x7fffffffL | |||
| # define STABLE_FLAGS_MALLOC 0x01 | |||
| /* | |||
| * A zero passed to ASN1_STRING_TABLE_new_add for the flags is interpreted | |||
| * as "don't change" and STABLE_FLAGS_MALLOC is always set. By setting | |||
| * STABLE_FLAGS_MALLOC only we can clear the existing value. Use the alias | |||
| * STABLE_FLAGS_CLEAR to reflect this. | |||
| */ | |||
| # define STABLE_FLAGS_CLEAR STABLE_FLAGS_MALLOC | |||
| # define STABLE_NO_MASK 0x02 | |||
| # define DIRSTRING_TYPE \ | |||
| (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING) | |||
| # define PKCS9STRING_TYPE (DIRSTRING_TYPE|B_ASN1_IA5STRING) | |||
| typedef struct asn1_string_table_st { | |||
| int nid; | |||
| long minsize; | |||
| long maxsize; | |||
| unsigned long mask; | |||
| unsigned long flags; | |||
| } ASN1_STRING_TABLE; | |||
| DEFINE_STACK_OF(ASN1_STRING_TABLE) | |||
| /* size limits: this stuff is taken straight from RFC2459 */ | |||
| # define ub_name 32768 | |||
| # define ub_common_name 64 | |||
| # define ub_locality_name 128 | |||
| # define ub_state_name 128 | |||
| # define ub_organization_name 64 | |||
| # define ub_organization_unit_name 64 | |||
| # define ub_title 64 | |||
| # define ub_email_address 128 | |||
| /* | |||
| * Declarations for template structures: for full definitions see asn1t.h | |||
| */ | |||
| typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE; | |||
| typedef struct ASN1_TLC_st ASN1_TLC; | |||
| /* This is just an opaque pointer */ | |||
| typedef struct ASN1_VALUE_st ASN1_VALUE; | |||
| /* Declare ASN1 functions: the implement macro in in asn1t.h */ | |||
| # define DECLARE_ASN1_FUNCTIONS(type) DECLARE_ASN1_FUNCTIONS_name(type, type) | |||
| # define DECLARE_ASN1_ALLOC_FUNCTIONS(type) \ | |||
| DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, type) | |||
| # define DECLARE_ASN1_FUNCTIONS_name(type, name) \ | |||
| DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ | |||
| DECLARE_ASN1_ENCODE_FUNCTIONS(type, name, name) | |||
| # define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \ | |||
| DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ | |||
| DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) | |||
| # define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) \ | |||
| type *d2i_##name(type **a, const unsigned char **in, long len); \ | |||
| int i2d_##name(type *a, unsigned char **out); \ | |||
| DECLARE_ASN1_ITEM(itname) | |||
| # define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \ | |||
| type *d2i_##name(type **a, const unsigned char **in, long len); \ | |||
| int i2d_##name(const type *a, unsigned char **out); \ | |||
| DECLARE_ASN1_ITEM(name) | |||
| # define DECLARE_ASN1_NDEF_FUNCTION(name) \ | |||
| int i2d_##name##_NDEF(name *a, unsigned char **out); | |||
| # define DECLARE_ASN1_FUNCTIONS_const(name) \ | |||
| DECLARE_ASN1_ALLOC_FUNCTIONS(name) \ | |||
| DECLARE_ASN1_ENCODE_FUNCTIONS_const(name, name) | |||
| # define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ | |||
| type *name##_new(void); \ | |||
| void name##_free(type *a); | |||
| # define DECLARE_ASN1_PRINT_FUNCTION(stname) \ | |||
| DECLARE_ASN1_PRINT_FUNCTION_fname(stname, stname) | |||
| # define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname) \ | |||
| int fname##_print_ctx(BIO *out, stname *x, int indent, \ | |||
| const ASN1_PCTX *pctx); | |||
| # define D2I_OF(type) type *(*)(type **,const unsigned char **,long) | |||
| # define I2D_OF(type) int (*)(type *,unsigned char **) | |||
| # define I2D_OF_const(type) int (*)(const type *,unsigned char **) | |||
| # define CHECKED_D2I_OF(type, d2i) \ | |||
| ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0))) | |||
| # define CHECKED_I2D_OF(type, i2d) \ | |||
| ((i2d_of_void*) (1 ? i2d : ((I2D_OF(type))0))) | |||
| # define CHECKED_NEW_OF(type, xnew) \ | |||
| ((void *(*)(void)) (1 ? xnew : ((type *(*)(void))0))) | |||
| # define CHECKED_PTR_OF(type, p) \ | |||
| ((void*) (1 ? p : (type*)0)) | |||
| # define CHECKED_PPTR_OF(type, p) \ | |||
| ((void**) (1 ? p : (type**)0)) | |||
| # define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **,const unsigned char **,long) | |||
| # define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(type *,unsigned char **) | |||
| # define TYPEDEF_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type) | |||
| TYPEDEF_D2I2D_OF(void); | |||
| /*- | |||
| * The following macros and typedefs allow an ASN1_ITEM | |||
| * to be embedded in a structure and referenced. Since | |||
| * the ASN1_ITEM pointers need to be globally accessible | |||
| * (possibly from shared libraries) they may exist in | |||
| * different forms. On platforms that support it the | |||
| * ASN1_ITEM structure itself will be globally exported. | |||
| * Other platforms will export a function that returns | |||
| * an ASN1_ITEM pointer. | |||
| * | |||
| * To handle both cases transparently the macros below | |||
| * should be used instead of hard coding an ASN1_ITEM | |||
| * pointer in a structure. | |||
| * | |||
| * The structure will look like this: | |||
| * | |||
| * typedef struct SOMETHING_st { | |||
| * ... | |||
| * ASN1_ITEM_EXP *iptr; | |||
| * ... | |||
| * } SOMETHING; | |||
| * | |||
| * It would be initialised as e.g.: | |||
| * | |||
| * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...}; | |||
| * | |||
| * and the actual pointer extracted with: | |||
| * | |||
| * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr); | |||
| * | |||
| * Finally an ASN1_ITEM pointer can be extracted from an | |||
| * appropriate reference with: ASN1_ITEM_rptr(X509). This | |||
| * would be used when a function takes an ASN1_ITEM * argument. | |||
| * | |||
| */ | |||
| # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION | |||
| /* ASN1_ITEM pointer exported type */ | |||
| typedef const ASN1_ITEM ASN1_ITEM_EXP; | |||
| /* Macro to obtain ASN1_ITEM pointer from exported type */ | |||
| # define ASN1_ITEM_ptr(iptr) (iptr) | |||
| /* Macro to include ASN1_ITEM pointer from base type */ | |||
| # define ASN1_ITEM_ref(iptr) (&(iptr##_it)) | |||
| # define ASN1_ITEM_rptr(ref) (&(ref##_it)) | |||
| # define DECLARE_ASN1_ITEM(name) \ | |||
| OPENSSL_EXTERN const ASN1_ITEM name##_it; | |||
| # else | |||
| /* | |||
| * Platforms that can't easily handle shared global variables are declared as | |||
| * functions returning ASN1_ITEM pointers. | |||
| */ | |||
| /* ASN1_ITEM pointer exported type */ | |||
| typedef const ASN1_ITEM *ASN1_ITEM_EXP (void); | |||
| /* Macro to obtain ASN1_ITEM pointer from exported type */ | |||
| # define ASN1_ITEM_ptr(iptr) (iptr()) | |||
| /* Macro to include ASN1_ITEM pointer from base type */ | |||
| # define ASN1_ITEM_ref(iptr) (iptr##_it) | |||
| # define ASN1_ITEM_rptr(ref) (ref##_it()) | |||
| # define DECLARE_ASN1_ITEM(name) \ | |||
| const ASN1_ITEM * name##_it(void); | |||
| # endif | |||
| /* Parameters used by ASN1_STRING_print_ex() */ | |||
| /* | |||
| * These determine which characters to escape: RFC2253 special characters, | |||
| * control characters and MSB set characters | |||
| */ | |||
| # define ASN1_STRFLGS_ESC_2253 1 | |||
| # define ASN1_STRFLGS_ESC_CTRL 2 | |||
| # define ASN1_STRFLGS_ESC_MSB 4 | |||
| /* | |||
| * This flag determines how we do escaping: normally RC2253 backslash only, | |||
| * set this to use backslash and quote. | |||
| */ | |||
| # define ASN1_STRFLGS_ESC_QUOTE 8 | |||
| /* These three flags are internal use only. */ | |||
| /* Character is a valid PrintableString character */ | |||
| # define CHARTYPE_PRINTABLESTRING 0x10 | |||
| /* Character needs escaping if it is the first character */ | |||
| # define CHARTYPE_FIRST_ESC_2253 0x20 | |||
| /* Character needs escaping if it is the last character */ | |||
| # define CHARTYPE_LAST_ESC_2253 0x40 | |||
| /* | |||
| * NB the internal flags are safely reused below by flags handled at the top | |||
| * level. | |||
| */ | |||
| /* | |||
| * If this is set we convert all character strings to UTF8 first | |||
| */ | |||
| # define ASN1_STRFLGS_UTF8_CONVERT 0x10 | |||
| /* | |||
| * If this is set we don't attempt to interpret content: just assume all | |||
| * strings are 1 byte per character. This will produce some pretty odd | |||
| * looking output! | |||
| */ | |||
| # define ASN1_STRFLGS_IGNORE_TYPE 0x20 | |||
| /* If this is set we include the string type in the output */ | |||
| # define ASN1_STRFLGS_SHOW_TYPE 0x40 | |||
| /* | |||
| * This determines which strings to display and which to 'dump' (hex dump of | |||
| * content octets or DER encoding). We can only dump non character strings or | |||
| * everything. If we don't dump 'unknown' they are interpreted as character | |||
| * strings with 1 octet per character and are subject to the usual escaping | |||
| * options. | |||
| */ | |||
| # define ASN1_STRFLGS_DUMP_ALL 0x80 | |||
| # define ASN1_STRFLGS_DUMP_UNKNOWN 0x100 | |||
| /* | |||
| * These determine what 'dumping' does, we can dump the content octets or the | |||
| * DER encoding: both use the RFC2253 #XXXXX notation. | |||
| */ | |||
| # define ASN1_STRFLGS_DUMP_DER 0x200 | |||
| /* | |||
| * This flag specifies that RC2254 escaping shall be performed. | |||
| */ | |||
| #define ASN1_STRFLGS_ESC_2254 0x400 | |||
| /* | |||
| * All the string flags consistent with RFC2253, escaping control characters | |||
| * isn't essential in RFC2253 but it is advisable anyway. | |||
| */ | |||
| # define ASN1_STRFLGS_RFC2253 (ASN1_STRFLGS_ESC_2253 | \ | |||
| ASN1_STRFLGS_ESC_CTRL | \ | |||
| ASN1_STRFLGS_ESC_MSB | \ | |||
| ASN1_STRFLGS_UTF8_CONVERT | \ | |||
| ASN1_STRFLGS_DUMP_UNKNOWN | \ | |||
| ASN1_STRFLGS_DUMP_DER) | |||
| DEFINE_STACK_OF(ASN1_INTEGER) | |||
| DEFINE_STACK_OF(ASN1_GENERALSTRING) | |||
| DEFINE_STACK_OF(ASN1_UTF8STRING) | |||
| typedef struct asn1_type_st { | |||
| int type; | |||
| union { | |||
| char *ptr; | |||
| ASN1_BOOLEAN boolean; | |||
| ASN1_STRING *asn1_string; | |||
| ASN1_OBJECT *object; | |||
| ASN1_INTEGER *integer; | |||
| ASN1_ENUMERATED *enumerated; | |||
| ASN1_BIT_STRING *bit_string; | |||
| ASN1_OCTET_STRING *octet_string; | |||
| ASN1_PRINTABLESTRING *printablestring; | |||
| ASN1_T61STRING *t61string; | |||
| ASN1_IA5STRING *ia5string; | |||
| ASN1_GENERALSTRING *generalstring; | |||
| ASN1_BMPSTRING *bmpstring; | |||
| ASN1_UNIVERSALSTRING *universalstring; | |||
| ASN1_UTCTIME *utctime; | |||
| ASN1_GENERALIZEDTIME *generalizedtime; | |||
| ASN1_VISIBLESTRING *visiblestring; | |||
| ASN1_UTF8STRING *utf8string; | |||
| /* | |||
| * set and sequence are left complete and still contain the set or | |||
| * sequence bytes | |||
| */ | |||
| ASN1_STRING *set; | |||
| ASN1_STRING *sequence; | |||
| ASN1_VALUE *asn1_value; | |||
| } value; | |||
| } ASN1_TYPE; | |||
| DEFINE_STACK_OF(ASN1_TYPE) | |||
| typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY; | |||
| DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY) | |||
| DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SET_ANY) | |||
| /* This is used to contain a list of bit names */ | |||
| typedef struct BIT_STRING_BITNAME_st { | |||
| int bitnum; | |||
| const char *lname; | |||
| const char *sname; | |||
| } BIT_STRING_BITNAME; | |||
| # define B_ASN1_TIME \ | |||
| B_ASN1_UTCTIME | \ | |||
| B_ASN1_GENERALIZEDTIME | |||
| # define B_ASN1_PRINTABLE \ | |||
| B_ASN1_NUMERICSTRING| \ | |||
| B_ASN1_PRINTABLESTRING| \ | |||
| B_ASN1_T61STRING| \ | |||
| B_ASN1_IA5STRING| \ | |||
| B_ASN1_BIT_STRING| \ | |||
| B_ASN1_UNIVERSALSTRING|\ | |||
| B_ASN1_BMPSTRING|\ | |||
| B_ASN1_UTF8STRING|\ | |||
| B_ASN1_SEQUENCE|\ | |||
| B_ASN1_UNKNOWN | |||
| # define B_ASN1_DIRECTORYSTRING \ | |||
| B_ASN1_PRINTABLESTRING| \ | |||
| B_ASN1_TELETEXSTRING|\ | |||
| B_ASN1_BMPSTRING|\ | |||
| B_ASN1_UNIVERSALSTRING|\ | |||
| B_ASN1_UTF8STRING | |||
| # define B_ASN1_DISPLAYTEXT \ | |||
| B_ASN1_IA5STRING| \ | |||
| B_ASN1_VISIBLESTRING| \ | |||
| B_ASN1_BMPSTRING|\ | |||
| B_ASN1_UTF8STRING | |||
| DECLARE_ASN1_FUNCTIONS_fname(ASN1_TYPE, ASN1_ANY, ASN1_TYPE) | |||
| int ASN1_TYPE_get(const ASN1_TYPE *a); | |||
| void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value); | |||
| int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value); | |||
| int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b); | |||
| ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t); | |||
| void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t); | |||
| ASN1_OBJECT *ASN1_OBJECT_new(void); | |||
| void ASN1_OBJECT_free(ASN1_OBJECT *a); | |||
| int i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp); | |||
| ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp, | |||
| long length); | |||
| DECLARE_ASN1_ITEM(ASN1_OBJECT) | |||
| DEFINE_STACK_OF(ASN1_OBJECT) | |||
| ASN1_STRING *ASN1_STRING_new(void); | |||
| void ASN1_STRING_free(ASN1_STRING *a); | |||
| void ASN1_STRING_clear_free(ASN1_STRING *a); | |||
| int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str); | |||
| ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *a); | |||
| ASN1_STRING *ASN1_STRING_type_new(int type); | |||
| int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b); | |||
| /* | |||
| * Since this is used to store all sorts of things, via macros, for now, | |||
| * make its data void * | |||
| */ | |||
| int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len); | |||
| void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len); | |||
| int ASN1_STRING_length(const ASN1_STRING *x); | |||
| void ASN1_STRING_length_set(ASN1_STRING *x, int n); | |||
| int ASN1_STRING_type(const ASN1_STRING *x); | |||
| DEPRECATEDIN_1_1_0(unsigned char *ASN1_STRING_data(ASN1_STRING *x)) | |||
| const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x); | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING) | |||
| int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length); | |||
| int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value); | |||
| int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n); | |||
| int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a, | |||
| const unsigned char *flags, int flags_len); | |||
| int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs, | |||
| BIT_STRING_BITNAME *tbl, int indent); | |||
| int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl); | |||
| int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value, | |||
| BIT_STRING_BITNAME *tbl); | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER) | |||
| ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp, | |||
| long length); | |||
| ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x); | |||
| int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y); | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED) | |||
| int ASN1_UTCTIME_check(const ASN1_UTCTIME *a); | |||
| ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t); | |||
| ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t, | |||
| int offset_day, long offset_sec); | |||
| int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str); | |||
| int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t); | |||
| int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a); | |||
| ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s, | |||
| time_t t); | |||
| ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, | |||
| time_t t, int offset_day, | |||
| long offset_sec); | |||
| int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str); | |||
| int ASN1_TIME_diff(int *pday, int *psec, | |||
| const ASN1_TIME *from, const ASN1_TIME *to); | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING) | |||
| ASN1_OCTET_STRING *ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a); | |||
| int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a, | |||
| const ASN1_OCTET_STRING *b); | |||
| int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data, | |||
| int len); | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_NULL) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING) | |||
| int UTF8_getc(const unsigned char *str, int len, unsigned long *val); | |||
| int UTF8_putc(unsigned char *str, int len, unsigned long value); | |||
| DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE) | |||
| DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING) | |||
| DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME) | |||
| DECLARE_ASN1_FUNCTIONS(ASN1_TIME) | |||
| DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF) | |||
| ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t); | |||
| ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t, | |||
| int offset_day, long offset_sec); | |||
| int ASN1_TIME_check(const ASN1_TIME *t); | |||
| ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t, | |||
| ASN1_GENERALIZEDTIME **out); | |||
| int ASN1_TIME_set_string(ASN1_TIME *s, const char *str); | |||
| int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str); | |||
| int ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm); | |||
| int ASN1_TIME_normalize(ASN1_TIME *s); | |||
| int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t); | |||
| int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b); | |||
| int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a); | |||
| int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size); | |||
| int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a); | |||
| int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size); | |||
| int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a); | |||
| int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size); | |||
| int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type); | |||
| int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a); | |||
| int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num); | |||
| ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len, | |||
| const char *sn, const char *ln); | |||
| int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a); | |||
| int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r); | |||
| int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a); | |||
| int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r); | |||
| int ASN1_INTEGER_set(ASN1_INTEGER *a, long v); | |||
| long ASN1_INTEGER_get(const ASN1_INTEGER *a); | |||
| ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai); | |||
| BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn); | |||
| int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a); | |||
| int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r); | |||
| int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v); | |||
| long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a); | |||
| ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai); | |||
| BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn); | |||
| /* General */ | |||
| /* given a string, return the correct type, max is the maximum length */ | |||
| int ASN1_PRINTABLE_type(const unsigned char *s, int max); | |||
| unsigned long ASN1_tag2bit(int tag); | |||
| /* SPECIALS */ | |||
| int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag, | |||
| int *pclass, long omax); | |||
| int ASN1_check_infinite_end(unsigned char **p, long len); | |||
| int ASN1_const_check_infinite_end(const unsigned char **p, long len); | |||
| void ASN1_put_object(unsigned char **pp, int constructed, int length, | |||
| int tag, int xclass); | |||
| int ASN1_put_eoc(unsigned char **pp); | |||
| int ASN1_object_size(int constructed, int length, int tag); | |||
| /* Used to implement other functions */ | |||
| void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x); | |||
| # define ASN1_dup_of(type,i2d,d2i,x) \ | |||
| ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), \ | |||
| CHECKED_D2I_OF(type, d2i), \ | |||
| CHECKED_PTR_OF(type, x))) | |||
| # define ASN1_dup_of_const(type,i2d,d2i,x) \ | |||
| ((type*)ASN1_dup(CHECKED_I2D_OF(const type, i2d), \ | |||
| CHECKED_D2I_OF(type, d2i), \ | |||
| CHECKED_PTR_OF(const type, x))) | |||
| void *ASN1_item_dup(const ASN1_ITEM *it, void *x); | |||
| /* ASN1 alloc/free macros for when a type is only used internally */ | |||
| # define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type)) | |||
| # define M_ASN1_free_of(x, type) \ | |||
| ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type)) | |||
| # ifndef OPENSSL_NO_STDIO | |||
| void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x); | |||
| # define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \ | |||
| ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \ | |||
| CHECKED_D2I_OF(type, d2i), \ | |||
| in, \ | |||
| CHECKED_PPTR_OF(type, x))) | |||
| void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x); | |||
| int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x); | |||
| # define ASN1_i2d_fp_of(type,i2d,out,x) \ | |||
| (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \ | |||
| out, \ | |||
| CHECKED_PTR_OF(type, x))) | |||
| # define ASN1_i2d_fp_of_const(type,i2d,out,x) \ | |||
| (ASN1_i2d_fp(CHECKED_I2D_OF(const type, i2d), \ | |||
| out, \ | |||
| CHECKED_PTR_OF(const type, x))) | |||
| int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x); | |||
| int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags); | |||
| # endif | |||
| int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in); | |||
| void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x); | |||
| # define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \ | |||
| ((type*)ASN1_d2i_bio( CHECKED_NEW_OF(type, xnew), \ | |||
| CHECKED_D2I_OF(type, d2i), \ | |||
| in, \ | |||
| CHECKED_PPTR_OF(type, x))) | |||
| void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x); | |||
| int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x); | |||
| # define ASN1_i2d_bio_of(type,i2d,out,x) \ | |||
| (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \ | |||
| out, \ | |||
| CHECKED_PTR_OF(type, x))) | |||
| # define ASN1_i2d_bio_of_const(type,i2d,out,x) \ | |||
| (ASN1_i2d_bio(CHECKED_I2D_OF(const type, i2d), \ | |||
| out, \ | |||
| CHECKED_PTR_OF(const type, x))) | |||
| int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x); | |||
| int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a); | |||
| int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a); | |||
| int ASN1_TIME_print(BIO *fp, const ASN1_TIME *a); | |||
| int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v); | |||
| int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags); | |||
| int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off); | |||
| int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num, | |||
| unsigned char *buf, int off); | |||
| int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent); | |||
| int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent, | |||
| int dump); | |||
| const char *ASN1_tag2str(int tag); | |||
| /* Used to load and write Netscape format cert */ | |||
| int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s); | |||
| int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len); | |||
| int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len); | |||
| int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, | |||
| unsigned char *data, int len); | |||
| int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num, | |||
| unsigned char *data, int max_len); | |||
| void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it); | |||
| ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, | |||
| ASN1_OCTET_STRING **oct); | |||
| void ASN1_STRING_set_default_mask(unsigned long mask); | |||
| int ASN1_STRING_set_default_mask_asc(const char *p); | |||
| unsigned long ASN1_STRING_get_default_mask(void); | |||
| int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len, | |||
| int inform, unsigned long mask); | |||
| int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, | |||
| int inform, unsigned long mask, | |||
| long minsize, long maxsize); | |||
| ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, | |||
| const unsigned char *in, int inlen, | |||
| int inform, int nid); | |||
| ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid); | |||
| int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long); | |||
| void ASN1_STRING_TABLE_cleanup(void); | |||
| /* ASN1 template functions */ | |||
| /* Old API compatible functions */ | |||
| ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it); | |||
| void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it); | |||
| ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in, | |||
| long len, const ASN1_ITEM *it); | |||
| int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it); | |||
| int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out, | |||
| const ASN1_ITEM *it); | |||
| void ASN1_add_oid_module(void); | |||
| void ASN1_add_stable_module(void); | |||
| ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf); | |||
| ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf); | |||
| int ASN1_str2mask(const char *str, unsigned long *pmask); | |||
| /* ASN1 Print flags */ | |||
| /* Indicate missing OPTIONAL fields */ | |||
| # define ASN1_PCTX_FLAGS_SHOW_ABSENT 0x001 | |||
| /* Mark start and end of SEQUENCE */ | |||
| # define ASN1_PCTX_FLAGS_SHOW_SEQUENCE 0x002 | |||
| /* Mark start and end of SEQUENCE/SET OF */ | |||
| # define ASN1_PCTX_FLAGS_SHOW_SSOF 0x004 | |||
| /* Show the ASN1 type of primitives */ | |||
| # define ASN1_PCTX_FLAGS_SHOW_TYPE 0x008 | |||
| /* Don't show ASN1 type of ANY */ | |||
| # define ASN1_PCTX_FLAGS_NO_ANY_TYPE 0x010 | |||
| /* Don't show ASN1 type of MSTRINGs */ | |||
| # define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE 0x020 | |||
| /* Don't show field names in SEQUENCE */ | |||
| # define ASN1_PCTX_FLAGS_NO_FIELD_NAME 0x040 | |||
| /* Show structure names of each SEQUENCE field */ | |||
| # define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME 0x080 | |||
| /* Don't show structure name even at top level */ | |||
| # define ASN1_PCTX_FLAGS_NO_STRUCT_NAME 0x100 | |||
| int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent, | |||
| const ASN1_ITEM *it, const ASN1_PCTX *pctx); | |||
| ASN1_PCTX *ASN1_PCTX_new(void); | |||
| void ASN1_PCTX_free(ASN1_PCTX *p); | |||
| unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p); | |||
| void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags); | |||
| unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p); | |||
| void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags); | |||
| unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p); | |||
| void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags); | |||
| unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p); | |||
| void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags); | |||
| unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p); | |||
| void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags); | |||
| ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx)); | |||
| void ASN1_SCTX_free(ASN1_SCTX *p); | |||
| const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p); | |||
| const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p); | |||
| unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p); | |||
| void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data); | |||
| void *ASN1_SCTX_get_app_data(ASN1_SCTX *p); | |||
| const BIO_METHOD *BIO_f_asn1(void); | |||
| BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it); | |||
| int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, | |||
| const ASN1_ITEM *it); | |||
| int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, | |||
| const char *hdr, const ASN1_ITEM *it); | |||
| int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags, | |||
| int ctype_nid, int econt_nid, | |||
| STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it); | |||
| ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it); | |||
| int SMIME_crlf_copy(BIO *in, BIO *out, int flags); | |||
| int SMIME_text(BIO *in, BIO *out); | |||
| const ASN1_ITEM *ASN1_ITEM_lookup(const char *name); | |||
| const ASN1_ITEM *ASN1_ITEM_get(size_t i); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,10 +0,0 @@ | |||
| /* | |||
| * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #error "This file is obsolete; please update your software." | |||
| @ -1,256 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_ASN1ERR_H | |||
| # define HEADER_ASN1ERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_ASN1_strings(void); | |||
| /* | |||
| * ASN1 function codes. | |||
| */ | |||
| # define ASN1_F_A2D_ASN1_OBJECT 100 | |||
| # define ASN1_F_A2I_ASN1_INTEGER 102 | |||
| # define ASN1_F_A2I_ASN1_STRING 103 | |||
| # define ASN1_F_APPEND_EXP 176 | |||
| # define ASN1_F_ASN1_BIO_INIT 113 | |||
| # define ASN1_F_ASN1_BIT_STRING_SET_BIT 183 | |||
| # define ASN1_F_ASN1_CB 177 | |||
| # define ASN1_F_ASN1_CHECK_TLEN 104 | |||
| # define ASN1_F_ASN1_COLLECT 106 | |||
| # define ASN1_F_ASN1_D2I_EX_PRIMITIVE 108 | |||
| # define ASN1_F_ASN1_D2I_FP 109 | |||
| # define ASN1_F_ASN1_D2I_READ_BIO 107 | |||
| # define ASN1_F_ASN1_DIGEST 184 | |||
| # define ASN1_F_ASN1_DO_ADB 110 | |||
| # define ASN1_F_ASN1_DO_LOCK 233 | |||
| # define ASN1_F_ASN1_DUP 111 | |||
| # define ASN1_F_ASN1_ENC_SAVE 115 | |||
| # define ASN1_F_ASN1_EX_C2I 204 | |||
| # define ASN1_F_ASN1_FIND_END 190 | |||
| # define ASN1_F_ASN1_GENERALIZEDTIME_ADJ 216 | |||
| # define ASN1_F_ASN1_GENERATE_V3 178 | |||
| # define ASN1_F_ASN1_GET_INT64 224 | |||
| # define ASN1_F_ASN1_GET_OBJECT 114 | |||
| # define ASN1_F_ASN1_GET_UINT64 225 | |||
| # define ASN1_F_ASN1_I2D_BIO 116 | |||
| # define ASN1_F_ASN1_I2D_FP 117 | |||
| # define ASN1_F_ASN1_ITEM_D2I_FP 206 | |||
| # define ASN1_F_ASN1_ITEM_DUP 191 | |||
| # define ASN1_F_ASN1_ITEM_EMBED_D2I 120 | |||
| # define ASN1_F_ASN1_ITEM_EMBED_NEW 121 | |||
| # define ASN1_F_ASN1_ITEM_FLAGS_I2D 118 | |||
| # define ASN1_F_ASN1_ITEM_I2D_BIO 192 | |||
| # define ASN1_F_ASN1_ITEM_I2D_FP 193 | |||
| # define ASN1_F_ASN1_ITEM_PACK 198 | |||
| # define ASN1_F_ASN1_ITEM_SIGN 195 | |||
| # define ASN1_F_ASN1_ITEM_SIGN_CTX 220 | |||
| # define ASN1_F_ASN1_ITEM_UNPACK 199 | |||
| # define ASN1_F_ASN1_ITEM_VERIFY 197 | |||
| # define ASN1_F_ASN1_MBSTRING_NCOPY 122 | |||
| # define ASN1_F_ASN1_OBJECT_NEW 123 | |||
| # define ASN1_F_ASN1_OUTPUT_DATA 214 | |||
| # define ASN1_F_ASN1_PCTX_NEW 205 | |||
| # define ASN1_F_ASN1_PRIMITIVE_NEW 119 | |||
| # define ASN1_F_ASN1_SCTX_NEW 221 | |||
| # define ASN1_F_ASN1_SIGN 128 | |||
| # define ASN1_F_ASN1_STR2TYPE 179 | |||
| # define ASN1_F_ASN1_STRING_GET_INT64 227 | |||
| # define ASN1_F_ASN1_STRING_GET_UINT64 230 | |||
| # define ASN1_F_ASN1_STRING_SET 186 | |||
| # define ASN1_F_ASN1_STRING_TABLE_ADD 129 | |||
| # define ASN1_F_ASN1_STRING_TO_BN 228 | |||
| # define ASN1_F_ASN1_STRING_TYPE_NEW 130 | |||
| # define ASN1_F_ASN1_TEMPLATE_EX_D2I 132 | |||
| # define ASN1_F_ASN1_TEMPLATE_NEW 133 | |||
| # define ASN1_F_ASN1_TEMPLATE_NOEXP_D2I 131 | |||
| # define ASN1_F_ASN1_TIME_ADJ 217 | |||
| # define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING 134 | |||
| # define ASN1_F_ASN1_TYPE_GET_OCTETSTRING 135 | |||
| # define ASN1_F_ASN1_UTCTIME_ADJ 218 | |||
| # define ASN1_F_ASN1_VERIFY 137 | |||
| # define ASN1_F_B64_READ_ASN1 209 | |||
| # define ASN1_F_B64_WRITE_ASN1 210 | |||
| # define ASN1_F_BIO_NEW_NDEF 208 | |||
| # define ASN1_F_BITSTR_CB 180 | |||
| # define ASN1_F_BN_TO_ASN1_STRING 229 | |||
| # define ASN1_F_C2I_ASN1_BIT_STRING 189 | |||
| # define ASN1_F_C2I_ASN1_INTEGER 194 | |||
| # define ASN1_F_C2I_ASN1_OBJECT 196 | |||
| # define ASN1_F_C2I_IBUF 226 | |||
| # define ASN1_F_C2I_UINT64_INT 101 | |||
| # define ASN1_F_COLLECT_DATA 140 | |||
| # define ASN1_F_D2I_ASN1_OBJECT 147 | |||
| # define ASN1_F_D2I_ASN1_UINTEGER 150 | |||
| # define ASN1_F_D2I_AUTOPRIVATEKEY 207 | |||
| # define ASN1_F_D2I_PRIVATEKEY 154 | |||
| # define ASN1_F_D2I_PUBLICKEY 155 | |||
| # define ASN1_F_DO_BUF 142 | |||
| # define ASN1_F_DO_CREATE 124 | |||
| # define ASN1_F_DO_DUMP 125 | |||
| # define ASN1_F_DO_TCREATE 222 | |||
| # define ASN1_F_I2A_ASN1_OBJECT 126 | |||
| # define ASN1_F_I2D_ASN1_BIO_STREAM 211 | |||
| # define ASN1_F_I2D_ASN1_OBJECT 143 | |||
| # define ASN1_F_I2D_DSA_PUBKEY 161 | |||
| # define ASN1_F_I2D_EC_PUBKEY 181 | |||
| # define ASN1_F_I2D_PRIVATEKEY 163 | |||
| # define ASN1_F_I2D_PUBLICKEY 164 | |||
| # define ASN1_F_I2D_RSA_PUBKEY 165 | |||
| # define ASN1_F_LONG_C2I 166 | |||
| # define ASN1_F_NDEF_PREFIX 127 | |||
| # define ASN1_F_NDEF_SUFFIX 136 | |||
| # define ASN1_F_OID_MODULE_INIT 174 | |||
| # define ASN1_F_PARSE_TAGGING 182 | |||
| # define ASN1_F_PKCS5_PBE2_SET_IV 167 | |||
| # define ASN1_F_PKCS5_PBE2_SET_SCRYPT 231 | |||
| # define ASN1_F_PKCS5_PBE_SET 202 | |||
| # define ASN1_F_PKCS5_PBE_SET0_ALGOR 215 | |||
| # define ASN1_F_PKCS5_PBKDF2_SET 219 | |||
| # define ASN1_F_PKCS5_SCRYPT_SET 232 | |||
| # define ASN1_F_SMIME_READ_ASN1 212 | |||
| # define ASN1_F_SMIME_TEXT 213 | |||
| # define ASN1_F_STABLE_GET 138 | |||
| # define ASN1_F_STBL_MODULE_INIT 223 | |||
| # define ASN1_F_UINT32_C2I 105 | |||
| # define ASN1_F_UINT32_NEW 139 | |||
| # define ASN1_F_UINT64_C2I 112 | |||
| # define ASN1_F_UINT64_NEW 141 | |||
| # define ASN1_F_X509_CRL_ADD0_REVOKED 169 | |||
| # define ASN1_F_X509_INFO_NEW 170 | |||
| # define ASN1_F_X509_NAME_ENCODE 203 | |||
| # define ASN1_F_X509_NAME_EX_D2I 158 | |||
| # define ASN1_F_X509_NAME_EX_NEW 171 | |||
| # define ASN1_F_X509_PKEY_NEW 173 | |||
| /* | |||
| * ASN1 reason codes. | |||
| */ | |||
| # define ASN1_R_ADDING_OBJECT 171 | |||
| # define ASN1_R_ASN1_PARSE_ERROR 203 | |||
| # define ASN1_R_ASN1_SIG_PARSE_ERROR 204 | |||
| # define ASN1_R_AUX_ERROR 100 | |||
| # define ASN1_R_BAD_OBJECT_HEADER 102 | |||
| # define ASN1_R_BMPSTRING_IS_WRONG_LENGTH 214 | |||
| # define ASN1_R_BN_LIB 105 | |||
| # define ASN1_R_BOOLEAN_IS_WRONG_LENGTH 106 | |||
| # define ASN1_R_BUFFER_TOO_SMALL 107 | |||
| # define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 108 | |||
| # define ASN1_R_CONTEXT_NOT_INITIALISED 217 | |||
| # define ASN1_R_DATA_IS_WRONG 109 | |||
| # define ASN1_R_DECODE_ERROR 110 | |||
| # define ASN1_R_DEPTH_EXCEEDED 174 | |||
| # define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED 198 | |||
| # define ASN1_R_ENCODE_ERROR 112 | |||
| # define ASN1_R_ERROR_GETTING_TIME 173 | |||
| # define ASN1_R_ERROR_LOADING_SECTION 172 | |||
| # define ASN1_R_ERROR_SETTING_CIPHER_PARAMS 114 | |||
| # define ASN1_R_EXPECTING_AN_INTEGER 115 | |||
| # define ASN1_R_EXPECTING_AN_OBJECT 116 | |||
| # define ASN1_R_EXPLICIT_LENGTH_MISMATCH 119 | |||
| # define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED 120 | |||
| # define ASN1_R_FIELD_MISSING 121 | |||
| # define ASN1_R_FIRST_NUM_TOO_LARGE 122 | |||
| # define ASN1_R_HEADER_TOO_LONG 123 | |||
| # define ASN1_R_ILLEGAL_BITSTRING_FORMAT 175 | |||
| # define ASN1_R_ILLEGAL_BOOLEAN 176 | |||
| # define ASN1_R_ILLEGAL_CHARACTERS 124 | |||
| # define ASN1_R_ILLEGAL_FORMAT 177 | |||
| # define ASN1_R_ILLEGAL_HEX 178 | |||
| # define ASN1_R_ILLEGAL_IMPLICIT_TAG 179 | |||
| # define ASN1_R_ILLEGAL_INTEGER 180 | |||
| # define ASN1_R_ILLEGAL_NEGATIVE_VALUE 226 | |||
| # define ASN1_R_ILLEGAL_NESTED_TAGGING 181 | |||
| # define ASN1_R_ILLEGAL_NULL 125 | |||
| # define ASN1_R_ILLEGAL_NULL_VALUE 182 | |||
| # define ASN1_R_ILLEGAL_OBJECT 183 | |||
| # define ASN1_R_ILLEGAL_OPTIONAL_ANY 126 | |||
| # define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE 170 | |||
| # define ASN1_R_ILLEGAL_PADDING 221 | |||
| # define ASN1_R_ILLEGAL_TAGGED_ANY 127 | |||
| # define ASN1_R_ILLEGAL_TIME_VALUE 184 | |||
| # define ASN1_R_ILLEGAL_ZERO_CONTENT 222 | |||
| # define ASN1_R_INTEGER_NOT_ASCII_FORMAT 185 | |||
| # define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG 128 | |||
| # define ASN1_R_INVALID_BIT_STRING_BITS_LEFT 220 | |||
| # define ASN1_R_INVALID_BMPSTRING_LENGTH 129 | |||
| # define ASN1_R_INVALID_DIGIT 130 | |||
| # define ASN1_R_INVALID_MIME_TYPE 205 | |||
| # define ASN1_R_INVALID_MODIFIER 186 | |||
| # define ASN1_R_INVALID_NUMBER 187 | |||
| # define ASN1_R_INVALID_OBJECT_ENCODING 216 | |||
| # define ASN1_R_INVALID_SCRYPT_PARAMETERS 227 | |||
| # define ASN1_R_INVALID_SEPARATOR 131 | |||
| # define ASN1_R_INVALID_STRING_TABLE_VALUE 218 | |||
| # define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH 133 | |||
| # define ASN1_R_INVALID_UTF8STRING 134 | |||
| # define ASN1_R_INVALID_VALUE 219 | |||
| # define ASN1_R_LIST_ERROR 188 | |||
| # define ASN1_R_MIME_NO_CONTENT_TYPE 206 | |||
| # define ASN1_R_MIME_PARSE_ERROR 207 | |||
| # define ASN1_R_MIME_SIG_PARSE_ERROR 208 | |||
| # define ASN1_R_MISSING_EOC 137 | |||
| # define ASN1_R_MISSING_SECOND_NUMBER 138 | |||
| # define ASN1_R_MISSING_VALUE 189 | |||
| # define ASN1_R_MSTRING_NOT_UNIVERSAL 139 | |||
| # define ASN1_R_MSTRING_WRONG_TAG 140 | |||
| # define ASN1_R_NESTED_ASN1_STRING 197 | |||
| # define ASN1_R_NESTED_TOO_DEEP 201 | |||
| # define ASN1_R_NON_HEX_CHARACTERS 141 | |||
| # define ASN1_R_NOT_ASCII_FORMAT 190 | |||
| # define ASN1_R_NOT_ENOUGH_DATA 142 | |||
| # define ASN1_R_NO_CONTENT_TYPE 209 | |||
| # define ASN1_R_NO_MATCHING_CHOICE_TYPE 143 | |||
| # define ASN1_R_NO_MULTIPART_BODY_FAILURE 210 | |||
| # define ASN1_R_NO_MULTIPART_BOUNDARY 211 | |||
| # define ASN1_R_NO_SIG_CONTENT_TYPE 212 | |||
| # define ASN1_R_NULL_IS_WRONG_LENGTH 144 | |||
| # define ASN1_R_OBJECT_NOT_ASCII_FORMAT 191 | |||
| # define ASN1_R_ODD_NUMBER_OF_CHARS 145 | |||
| # define ASN1_R_SECOND_NUMBER_TOO_LARGE 147 | |||
| # define ASN1_R_SEQUENCE_LENGTH_MISMATCH 148 | |||
| # define ASN1_R_SEQUENCE_NOT_CONSTRUCTED 149 | |||
| # define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG 192 | |||
| # define ASN1_R_SHORT_LINE 150 | |||
| # define ASN1_R_SIG_INVALID_MIME_TYPE 213 | |||
| # define ASN1_R_STREAMING_NOT_SUPPORTED 202 | |||
| # define ASN1_R_STRING_TOO_LONG 151 | |||
| # define ASN1_R_STRING_TOO_SHORT 152 | |||
| # define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154 | |||
| # define ASN1_R_TIME_NOT_ASCII_FORMAT 193 | |||
| # define ASN1_R_TOO_LARGE 223 | |||
| # define ASN1_R_TOO_LONG 155 | |||
| # define ASN1_R_TOO_SMALL 224 | |||
| # define ASN1_R_TYPE_NOT_CONSTRUCTED 156 | |||
| # define ASN1_R_TYPE_NOT_PRIMITIVE 195 | |||
| # define ASN1_R_UNEXPECTED_EOC 159 | |||
| # define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH 215 | |||
| # define ASN1_R_UNKNOWN_FORMAT 160 | |||
| # define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM 161 | |||
| # define ASN1_R_UNKNOWN_OBJECT_TYPE 162 | |||
| # define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE 163 | |||
| # define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM 199 | |||
| # define ASN1_R_UNKNOWN_TAG 194 | |||
| # define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE 164 | |||
| # define ASN1_R_UNSUPPORTED_CIPHER 228 | |||
| # define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE 167 | |||
| # define ASN1_R_UNSUPPORTED_TYPE 196 | |||
| # define ASN1_R_WRONG_INTEGER_TYPE 225 | |||
| # define ASN1_R_WRONG_PUBLIC_KEY_TYPE 200 | |||
| # define ASN1_R_WRONG_TAG 168 | |||
| #endif | |||
| @ -1,945 +0,0 @@ | |||
| /* | |||
| * Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_ASN1T_H | |||
| # define HEADER_ASN1T_H | |||
| # include <stddef.h> | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/asn1.h> | |||
| # ifdef OPENSSL_BUILD_SHLIBCRYPTO | |||
| # undef OPENSSL_EXTERN | |||
| # define OPENSSL_EXTERN OPENSSL_EXPORT | |||
| # endif | |||
| /* ASN1 template defines, structures and functions */ | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION | |||
| /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ | |||
| # define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr)) | |||
| /* Macros for start and end of ASN1_ITEM definition */ | |||
| # define ASN1_ITEM_start(itname) \ | |||
| const ASN1_ITEM itname##_it = { | |||
| # define static_ASN1_ITEM_start(itname) \ | |||
| static const ASN1_ITEM itname##_it = { | |||
| # define ASN1_ITEM_end(itname) \ | |||
| }; | |||
| # else | |||
| /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ | |||
| # define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)((iptr)())) | |||
| /* Macros for start and end of ASN1_ITEM definition */ | |||
| # define ASN1_ITEM_start(itname) \ | |||
| const ASN1_ITEM * itname##_it(void) \ | |||
| { \ | |||
| static const ASN1_ITEM local_it = { | |||
| # define static_ASN1_ITEM_start(itname) \ | |||
| static ASN1_ITEM_start(itname) | |||
| # define ASN1_ITEM_end(itname) \ | |||
| }; \ | |||
| return &local_it; \ | |||
| } | |||
| # endif | |||
| /* Macros to aid ASN1 template writing */ | |||
| # define ASN1_ITEM_TEMPLATE(tname) \ | |||
| static const ASN1_TEMPLATE tname##_item_tt | |||
| # define ASN1_ITEM_TEMPLATE_END(tname) \ | |||
| ;\ | |||
| ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_PRIMITIVE,\ | |||
| -1,\ | |||
| &tname##_item_tt,\ | |||
| 0,\ | |||
| NULL,\ | |||
| 0,\ | |||
| #tname \ | |||
| ASN1_ITEM_end(tname) | |||
| # define static_ASN1_ITEM_TEMPLATE_END(tname) \ | |||
| ;\ | |||
| static_ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_PRIMITIVE,\ | |||
| -1,\ | |||
| &tname##_item_tt,\ | |||
| 0,\ | |||
| NULL,\ | |||
| 0,\ | |||
| #tname \ | |||
| ASN1_ITEM_end(tname) | |||
| /* This is a ASN1 type which just embeds a template */ | |||
| /*- | |||
| * This pair helps declare a SEQUENCE. We can do: | |||
| * | |||
| * ASN1_SEQUENCE(stname) = { | |||
| * ... SEQUENCE components ... | |||
| * } ASN1_SEQUENCE_END(stname) | |||
| * | |||
| * This will produce an ASN1_ITEM called stname_it | |||
| * for a structure called stname. | |||
| * | |||
| * If you want the same structure but a different | |||
| * name then use: | |||
| * | |||
| * ASN1_SEQUENCE(itname) = { | |||
| * ... SEQUENCE components ... | |||
| * } ASN1_SEQUENCE_END_name(stname, itname) | |||
| * | |||
| * This will create an item called itname_it using | |||
| * a structure called stname. | |||
| */ | |||
| # define ASN1_SEQUENCE(tname) \ | |||
| static const ASN1_TEMPLATE tname##_seq_tt[] | |||
| # define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname) | |||
| # define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname) | |||
| # define ASN1_SEQUENCE_END_name(stname, tname) \ | |||
| ;\ | |||
| ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_SEQUENCE,\ | |||
| V_ASN1_SEQUENCE,\ | |||
| tname##_seq_tt,\ | |||
| sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| NULL,\ | |||
| sizeof(stname),\ | |||
| #tname \ | |||
| ASN1_ITEM_end(tname) | |||
| # define static_ASN1_SEQUENCE_END_name(stname, tname) \ | |||
| ;\ | |||
| static_ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_SEQUENCE,\ | |||
| V_ASN1_SEQUENCE,\ | |||
| tname##_seq_tt,\ | |||
| sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| NULL,\ | |||
| sizeof(stname),\ | |||
| #stname \ | |||
| ASN1_ITEM_end(tname) | |||
| # define ASN1_NDEF_SEQUENCE(tname) \ | |||
| ASN1_SEQUENCE(tname) | |||
| # define ASN1_NDEF_SEQUENCE_cb(tname, cb) \ | |||
| ASN1_SEQUENCE_cb(tname, cb) | |||
| # define ASN1_SEQUENCE_cb(tname, cb) \ | |||
| static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ | |||
| ASN1_SEQUENCE(tname) | |||
| # define ASN1_BROKEN_SEQUENCE(tname) \ | |||
| static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \ | |||
| ASN1_SEQUENCE(tname) | |||
| # define ASN1_SEQUENCE_ref(tname, cb) \ | |||
| static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0}; \ | |||
| ASN1_SEQUENCE(tname) | |||
| # define ASN1_SEQUENCE_enc(tname, enc, cb) \ | |||
| static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \ | |||
| ASN1_SEQUENCE(tname) | |||
| # define ASN1_NDEF_SEQUENCE_END(tname) \ | |||
| ;\ | |||
| ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_NDEF_SEQUENCE,\ | |||
| V_ASN1_SEQUENCE,\ | |||
| tname##_seq_tt,\ | |||
| sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| NULL,\ | |||
| sizeof(tname),\ | |||
| #tname \ | |||
| ASN1_ITEM_end(tname) | |||
| # define static_ASN1_NDEF_SEQUENCE_END(tname) \ | |||
| ;\ | |||
| static_ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_NDEF_SEQUENCE,\ | |||
| V_ASN1_SEQUENCE,\ | |||
| tname##_seq_tt,\ | |||
| sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| NULL,\ | |||
| sizeof(tname),\ | |||
| #tname \ | |||
| ASN1_ITEM_end(tname) | |||
| # define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname) | |||
| # define static_ASN1_BROKEN_SEQUENCE_END(stname) \ | |||
| static_ASN1_SEQUENCE_END_ref(stname, stname) | |||
| # define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) | |||
| # define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) | |||
| # define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname) | |||
| # define ASN1_SEQUENCE_END_ref(stname, tname) \ | |||
| ;\ | |||
| ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_SEQUENCE,\ | |||
| V_ASN1_SEQUENCE,\ | |||
| tname##_seq_tt,\ | |||
| sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| &tname##_aux,\ | |||
| sizeof(stname),\ | |||
| #tname \ | |||
| ASN1_ITEM_end(tname) | |||
| # define static_ASN1_SEQUENCE_END_ref(stname, tname) \ | |||
| ;\ | |||
| static_ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_SEQUENCE,\ | |||
| V_ASN1_SEQUENCE,\ | |||
| tname##_seq_tt,\ | |||
| sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| &tname##_aux,\ | |||
| sizeof(stname),\ | |||
| #stname \ | |||
| ASN1_ITEM_end(tname) | |||
| # define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \ | |||
| ;\ | |||
| ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_NDEF_SEQUENCE,\ | |||
| V_ASN1_SEQUENCE,\ | |||
| tname##_seq_tt,\ | |||
| sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| &tname##_aux,\ | |||
| sizeof(stname),\ | |||
| #stname \ | |||
| ASN1_ITEM_end(tname) | |||
| /*- | |||
| * This pair helps declare a CHOICE type. We can do: | |||
| * | |||
| * ASN1_CHOICE(chname) = { | |||
| * ... CHOICE options ... | |||
| * ASN1_CHOICE_END(chname) | |||
| * | |||
| * This will produce an ASN1_ITEM called chname_it | |||
| * for a structure called chname. The structure | |||
| * definition must look like this: | |||
| * typedef struct { | |||
| * int type; | |||
| * union { | |||
| * ASN1_SOMETHING *opt1; | |||
| * ASN1_SOMEOTHER *opt2; | |||
| * } value; | |||
| * } chname; | |||
| * | |||
| * the name of the selector must be 'type'. | |||
| * to use an alternative selector name use the | |||
| * ASN1_CHOICE_END_selector() version. | |||
| */ | |||
| # define ASN1_CHOICE(tname) \ | |||
| static const ASN1_TEMPLATE tname##_ch_tt[] | |||
| # define ASN1_CHOICE_cb(tname, cb) \ | |||
| static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ | |||
| ASN1_CHOICE(tname) | |||
| # define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname) | |||
| # define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname) | |||
| # define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type) | |||
| # define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type) | |||
| # define ASN1_CHOICE_END_selector(stname, tname, selname) \ | |||
| ;\ | |||
| ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_CHOICE,\ | |||
| offsetof(stname,selname) ,\ | |||
| tname##_ch_tt,\ | |||
| sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| NULL,\ | |||
| sizeof(stname),\ | |||
| #stname \ | |||
| ASN1_ITEM_end(tname) | |||
| # define static_ASN1_CHOICE_END_selector(stname, tname, selname) \ | |||
| ;\ | |||
| static_ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_CHOICE,\ | |||
| offsetof(stname,selname) ,\ | |||
| tname##_ch_tt,\ | |||
| sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| NULL,\ | |||
| sizeof(stname),\ | |||
| #stname \ | |||
| ASN1_ITEM_end(tname) | |||
| # define ASN1_CHOICE_END_cb(stname, tname, selname) \ | |||
| ;\ | |||
| ASN1_ITEM_start(tname) \ | |||
| ASN1_ITYPE_CHOICE,\ | |||
| offsetof(stname,selname) ,\ | |||
| tname##_ch_tt,\ | |||
| sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ | |||
| &tname##_aux,\ | |||
| sizeof(stname),\ | |||
| #stname \ | |||
| ASN1_ITEM_end(tname) | |||
| /* This helps with the template wrapper form of ASN1_ITEM */ | |||
| # define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \ | |||
| (flags), (tag), 0,\ | |||
| #name, ASN1_ITEM_ref(type) } | |||
| /* These help with SEQUENCE or CHOICE components */ | |||
| /* used to declare other types */ | |||
| # define ASN1_EX_TYPE(flags, tag, stname, field, type) { \ | |||
| (flags), (tag), offsetof(stname, field),\ | |||
| #field, ASN1_ITEM_ref(type) } | |||
| /* implicit and explicit helper macros */ | |||
| # define ASN1_IMP_EX(stname, field, type, tag, ex) \ | |||
| ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | (ex), tag, stname, field, type) | |||
| # define ASN1_EXP_EX(stname, field, type, tag, ex) \ | |||
| ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | (ex), tag, stname, field, type) | |||
| /* Any defined by macros: the field used is in the table itself */ | |||
| # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION | |||
| # define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } | |||
| # define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } | |||
| # else | |||
| # define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb } | |||
| # define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb } | |||
| # endif | |||
| /* Plain simple type */ | |||
| # define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type) | |||
| /* Embedded simple type */ | |||
| # define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED,0, stname, field, type) | |||
| /* OPTIONAL simple type */ | |||
| # define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type) | |||
| # define ASN1_OPT_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED, 0, stname, field, type) | |||
| /* IMPLICIT tagged simple type */ | |||
| # define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0) | |||
| # define ASN1_IMP_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_EMBED) | |||
| /* IMPLICIT tagged OPTIONAL simple type */ | |||
| # define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) | |||
| # define ASN1_IMP_OPT_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED) | |||
| /* Same as above but EXPLICIT */ | |||
| # define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0) | |||
| # define ASN1_EXP_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_EMBED) | |||
| # define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) | |||
| # define ASN1_EXP_OPT_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED) | |||
| /* SEQUENCE OF type */ | |||
| # define ASN1_SEQUENCE_OF(stname, field, type) \ | |||
| ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type) | |||
| /* OPTIONAL SEQUENCE OF */ | |||
| # define ASN1_SEQUENCE_OF_OPT(stname, field, type) \ | |||
| ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) | |||
| /* Same as above but for SET OF */ | |||
| # define ASN1_SET_OF(stname, field, type) \ | |||
| ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type) | |||
| # define ASN1_SET_OF_OPT(stname, field, type) \ | |||
| ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) | |||
| /* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */ | |||
| # define ASN1_IMP_SET_OF(stname, field, type, tag) \ | |||
| ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) | |||
| # define ASN1_EXP_SET_OF(stname, field, type, tag) \ | |||
| ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) | |||
| # define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \ | |||
| ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) | |||
| # define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \ | |||
| ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) | |||
| # define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \ | |||
| ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) | |||
| # define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \ | |||
| ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) | |||
| # define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \ | |||
| ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) | |||
| # define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \ | |||
| ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) | |||
| /* EXPLICIT using indefinite length constructed form */ | |||
| # define ASN1_NDEF_EXP(stname, field, type, tag) \ | |||
| ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF) | |||
| /* EXPLICIT OPTIONAL using indefinite length constructed form */ | |||
| # define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \ | |||
| ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF) | |||
| /* Macros for the ASN1_ADB structure */ | |||
| # define ASN1_ADB(name) \ | |||
| static const ASN1_ADB_TABLE name##_adbtbl[] | |||
| # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION | |||
| # define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \ | |||
| ;\ | |||
| static const ASN1_ADB name##_adb = {\ | |||
| flags,\ | |||
| offsetof(name, field),\ | |||
| adb_cb,\ | |||
| name##_adbtbl,\ | |||
| sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ | |||
| def,\ | |||
| none\ | |||
| } | |||
| # else | |||
| # define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \ | |||
| ;\ | |||
| static const ASN1_ITEM *name##_adb(void) \ | |||
| { \ | |||
| static const ASN1_ADB internal_adb = \ | |||
| {\ | |||
| flags,\ | |||
| offsetof(name, field),\ | |||
| adb_cb,\ | |||
| name##_adbtbl,\ | |||
| sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ | |||
| def,\ | |||
| none\ | |||
| }; \ | |||
| return (const ASN1_ITEM *) &internal_adb; \ | |||
| } \ | |||
| void dummy_function(void) | |||
| # endif | |||
| # define ADB_ENTRY(val, template) {val, template} | |||
| # define ASN1_ADB_TEMPLATE(name) \ | |||
| static const ASN1_TEMPLATE name##_tt | |||
| /* | |||
| * This is the ASN1 template structure that defines a wrapper round the | |||
| * actual type. It determines the actual position of the field in the value | |||
| * structure, various flags such as OPTIONAL and the field name. | |||
| */ | |||
| struct ASN1_TEMPLATE_st { | |||
| unsigned long flags; /* Various flags */ | |||
| long tag; /* tag, not used if no tagging */ | |||
| unsigned long offset; /* Offset of this field in structure */ | |||
| const char *field_name; /* Field name */ | |||
| ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */ | |||
| }; | |||
| /* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */ | |||
| # define ASN1_TEMPLATE_item(t) (t->item_ptr) | |||
| # define ASN1_TEMPLATE_adb(t) (t->item_ptr) | |||
| typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE; | |||
| typedef struct ASN1_ADB_st ASN1_ADB; | |||
| struct ASN1_ADB_st { | |||
| unsigned long flags; /* Various flags */ | |||
| unsigned long offset; /* Offset of selector field */ | |||
| int (*adb_cb)(long *psel); /* Application callback */ | |||
| const ASN1_ADB_TABLE *tbl; /* Table of possible types */ | |||
| long tblcount; /* Number of entries in tbl */ | |||
| const ASN1_TEMPLATE *default_tt; /* Type to use if no match */ | |||
| const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */ | |||
| }; | |||
| struct ASN1_ADB_TABLE_st { | |||
| long value; /* NID for an object or value for an int */ | |||
| const ASN1_TEMPLATE tt; /* item for this value */ | |||
| }; | |||
| /* template flags */ | |||
| /* Field is optional */ | |||
| # define ASN1_TFLG_OPTIONAL (0x1) | |||
| /* Field is a SET OF */ | |||
| # define ASN1_TFLG_SET_OF (0x1 << 1) | |||
| /* Field is a SEQUENCE OF */ | |||
| # define ASN1_TFLG_SEQUENCE_OF (0x2 << 1) | |||
| /* | |||
| * Special case: this refers to a SET OF that will be sorted into DER order | |||
| * when encoded *and* the corresponding STACK will be modified to match the | |||
| * new order. | |||
| */ | |||
| # define ASN1_TFLG_SET_ORDER (0x3 << 1) | |||
| /* Mask for SET OF or SEQUENCE OF */ | |||
| # define ASN1_TFLG_SK_MASK (0x3 << 1) | |||
| /* | |||
| * These flags mean the tag should be taken from the tag field. If EXPLICIT | |||
| * then the underlying type is used for the inner tag. | |||
| */ | |||
| /* IMPLICIT tagging */ | |||
| # define ASN1_TFLG_IMPTAG (0x1 << 3) | |||
| /* EXPLICIT tagging, inner tag from underlying type */ | |||
| # define ASN1_TFLG_EXPTAG (0x2 << 3) | |||
| # define ASN1_TFLG_TAG_MASK (0x3 << 3) | |||
| /* context specific IMPLICIT */ | |||
| # define ASN1_TFLG_IMPLICIT (ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT) | |||
| /* context specific EXPLICIT */ | |||
| # define ASN1_TFLG_EXPLICIT (ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT) | |||
| /* | |||
| * If tagging is in force these determine the type of tag to use. Otherwise | |||
| * the tag is determined by the underlying type. These values reflect the | |||
| * actual octet format. | |||
| */ | |||
| /* Universal tag */ | |||
| # define ASN1_TFLG_UNIVERSAL (0x0<<6) | |||
| /* Application tag */ | |||
| # define ASN1_TFLG_APPLICATION (0x1<<6) | |||
| /* Context specific tag */ | |||
| # define ASN1_TFLG_CONTEXT (0x2<<6) | |||
| /* Private tag */ | |||
| # define ASN1_TFLG_PRIVATE (0x3<<6) | |||
| # define ASN1_TFLG_TAG_CLASS (0x3<<6) | |||
| /* | |||
| * These are for ANY DEFINED BY type. In this case the 'item' field points to | |||
| * an ASN1_ADB structure which contains a table of values to decode the | |||
| * relevant type | |||
| */ | |||
| # define ASN1_TFLG_ADB_MASK (0x3<<8) | |||
| # define ASN1_TFLG_ADB_OID (0x1<<8) | |||
| # define ASN1_TFLG_ADB_INT (0x1<<9) | |||
| /* | |||
| * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes | |||
| * indefinite length constructed encoding to be used if required. | |||
| */ | |||
| # define ASN1_TFLG_NDEF (0x1<<11) | |||
| /* Field is embedded and not a pointer */ | |||
| # define ASN1_TFLG_EMBED (0x1 << 12) | |||
| /* This is the actual ASN1 item itself */ | |||
| struct ASN1_ITEM_st { | |||
| char itype; /* The item type, primitive, SEQUENCE, CHOICE | |||
| * or extern */ | |||
| long utype; /* underlying type */ | |||
| const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains | |||
| * the contents */ | |||
| long tcount; /* Number of templates if SEQUENCE or CHOICE */ | |||
| const void *funcs; /* functions that handle this type */ | |||
| long size; /* Structure size (usually) */ | |||
| const char *sname; /* Structure name */ | |||
| }; | |||
| /*- | |||
| * These are values for the itype field and | |||
| * determine how the type is interpreted. | |||
| * | |||
| * For PRIMITIVE types the underlying type | |||
| * determines the behaviour if items is NULL. | |||
| * | |||
| * Otherwise templates must contain a single | |||
| * template and the type is treated in the | |||
| * same way as the type specified in the template. | |||
| * | |||
| * For SEQUENCE types the templates field points | |||
| * to the members, the size field is the | |||
| * structure size. | |||
| * | |||
| * For CHOICE types the templates field points | |||
| * to each possible member (typically a union) | |||
| * and the 'size' field is the offset of the | |||
| * selector. | |||
| * | |||
| * The 'funcs' field is used for application | |||
| * specific functions. | |||
| * | |||
| * The EXTERN type uses a new style d2i/i2d. | |||
| * The new style should be used where possible | |||
| * because it avoids things like the d2i IMPLICIT | |||
| * hack. | |||
| * | |||
| * MSTRING is a multiple string type, it is used | |||
| * for a CHOICE of character strings where the | |||
| * actual strings all occupy an ASN1_STRING | |||
| * structure. In this case the 'utype' field | |||
| * has a special meaning, it is used as a mask | |||
| * of acceptable types using the B_ASN1 constants. | |||
| * | |||
| * NDEF_SEQUENCE is the same as SEQUENCE except | |||
| * that it will use indefinite length constructed | |||
| * encoding if requested. | |||
| * | |||
| */ | |||
| # define ASN1_ITYPE_PRIMITIVE 0x0 | |||
| # define ASN1_ITYPE_SEQUENCE 0x1 | |||
| # define ASN1_ITYPE_CHOICE 0x2 | |||
| # define ASN1_ITYPE_EXTERN 0x4 | |||
| # define ASN1_ITYPE_MSTRING 0x5 | |||
| # define ASN1_ITYPE_NDEF_SEQUENCE 0x6 | |||
| /* | |||
| * Cache for ASN1 tag and length, so we don't keep re-reading it for things | |||
| * like CHOICE | |||
| */ | |||
| struct ASN1_TLC_st { | |||
| char valid; /* Values below are valid */ | |||
| int ret; /* return value */ | |||
| long plen; /* length */ | |||
| int ptag; /* class value */ | |||
| int pclass; /* class value */ | |||
| int hdrlen; /* header length */ | |||
| }; | |||
| /* Typedefs for ASN1 function pointers */ | |||
| typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, | |||
| const ASN1_ITEM *it, int tag, int aclass, char opt, | |||
| ASN1_TLC *ctx); | |||
| typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, | |||
| const ASN1_ITEM *it, int tag, int aclass); | |||
| typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it); | |||
| typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it); | |||
| typedef int ASN1_ex_print_func(BIO *out, ASN1_VALUE **pval, | |||
| int indent, const char *fname, | |||
| const ASN1_PCTX *pctx); | |||
| typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, | |||
| int *putype, const ASN1_ITEM *it); | |||
| typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont, | |||
| int len, int utype, char *free_cont, | |||
| const ASN1_ITEM *it); | |||
| typedef int ASN1_primitive_print(BIO *out, ASN1_VALUE **pval, | |||
| const ASN1_ITEM *it, int indent, | |||
| const ASN1_PCTX *pctx); | |||
| typedef struct ASN1_EXTERN_FUNCS_st { | |||
| void *app_data; | |||
| ASN1_ex_new_func *asn1_ex_new; | |||
| ASN1_ex_free_func *asn1_ex_free; | |||
| ASN1_ex_free_func *asn1_ex_clear; | |||
| ASN1_ex_d2i *asn1_ex_d2i; | |||
| ASN1_ex_i2d *asn1_ex_i2d; | |||
| ASN1_ex_print_func *asn1_ex_print; | |||
| } ASN1_EXTERN_FUNCS; | |||
| typedef struct ASN1_PRIMITIVE_FUNCS_st { | |||
| void *app_data; | |||
| unsigned long flags; | |||
| ASN1_ex_new_func *prim_new; | |||
| ASN1_ex_free_func *prim_free; | |||
| ASN1_ex_free_func *prim_clear; | |||
| ASN1_primitive_c2i *prim_c2i; | |||
| ASN1_primitive_i2c *prim_i2c; | |||
| ASN1_primitive_print *prim_print; | |||
| } ASN1_PRIMITIVE_FUNCS; | |||
| /* | |||
| * This is the ASN1_AUX structure: it handles various miscellaneous | |||
| * requirements. For example the use of reference counts and an informational | |||
| * callback. The "informational callback" is called at various points during | |||
| * the ASN1 encoding and decoding. It can be used to provide minor | |||
| * customisation of the structures used. This is most useful where the | |||
| * supplied routines *almost* do the right thing but need some extra help at | |||
| * a few points. If the callback returns zero then it is assumed a fatal | |||
| * error has occurred and the main operation should be abandoned. If major | |||
| * changes in the default behaviour are required then an external type is | |||
| * more appropriate. | |||
| */ | |||
| typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it, | |||
| void *exarg); | |||
| typedef struct ASN1_AUX_st { | |||
| void *app_data; | |||
| int flags; | |||
| int ref_offset; /* Offset of reference value */ | |||
| int ref_lock; /* Lock type to use */ | |||
| ASN1_aux_cb *asn1_cb; | |||
| int enc_offset; /* Offset of ASN1_ENCODING structure */ | |||
| } ASN1_AUX; | |||
| /* For print related callbacks exarg points to this structure */ | |||
| typedef struct ASN1_PRINT_ARG_st { | |||
| BIO *out; | |||
| int indent; | |||
| const ASN1_PCTX *pctx; | |||
| } ASN1_PRINT_ARG; | |||
| /* For streaming related callbacks exarg points to this structure */ | |||
| typedef struct ASN1_STREAM_ARG_st { | |||
| /* BIO to stream through */ | |||
| BIO *out; | |||
| /* BIO with filters appended */ | |||
| BIO *ndef_bio; | |||
| /* Streaming I/O boundary */ | |||
| unsigned char **boundary; | |||
| } ASN1_STREAM_ARG; | |||
| /* Flags in ASN1_AUX */ | |||
| /* Use a reference count */ | |||
| # define ASN1_AFLG_REFCOUNT 1 | |||
| /* Save the encoding of structure (useful for signatures) */ | |||
| # define ASN1_AFLG_ENCODING 2 | |||
| /* The Sequence length is invalid */ | |||
| # define ASN1_AFLG_BROKEN 4 | |||
| /* operation values for asn1_cb */ | |||
| # define ASN1_OP_NEW_PRE 0 | |||
| # define ASN1_OP_NEW_POST 1 | |||
| # define ASN1_OP_FREE_PRE 2 | |||
| # define ASN1_OP_FREE_POST 3 | |||
| # define ASN1_OP_D2I_PRE 4 | |||
| # define ASN1_OP_D2I_POST 5 | |||
| # define ASN1_OP_I2D_PRE 6 | |||
| # define ASN1_OP_I2D_POST 7 | |||
| # define ASN1_OP_PRINT_PRE 8 | |||
| # define ASN1_OP_PRINT_POST 9 | |||
| # define ASN1_OP_STREAM_PRE 10 | |||
| # define ASN1_OP_STREAM_POST 11 | |||
| # define ASN1_OP_DETACHED_PRE 12 | |||
| # define ASN1_OP_DETACHED_POST 13 | |||
| /* Macro to implement a primitive type */ | |||
| # define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0) | |||
| # define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \ | |||
| ASN1_ITEM_start(itname) \ | |||
| ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \ | |||
| ASN1_ITEM_end(itname) | |||
| /* Macro to implement a multi string type */ | |||
| # define IMPLEMENT_ASN1_MSTRING(itname, mask) \ | |||
| ASN1_ITEM_start(itname) \ | |||
| ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \ | |||
| ASN1_ITEM_end(itname) | |||
| # define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \ | |||
| ASN1_ITEM_start(sname) \ | |||
| ASN1_ITYPE_EXTERN, \ | |||
| tag, \ | |||
| NULL, \ | |||
| 0, \ | |||
| &fptrs, \ | |||
| 0, \ | |||
| #sname \ | |||
| ASN1_ITEM_end(sname) | |||
| /* Macro to implement standard functions in terms of ASN1_ITEM structures */ | |||
| # define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname) | |||
| # define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname) | |||
| # define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \ | |||
| IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname) | |||
| # define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \ | |||
| IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname) | |||
| # define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \ | |||
| IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname) | |||
| # define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \ | |||
| pre stname *fname##_new(void) \ | |||
| { \ | |||
| return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ | |||
| } \ | |||
| pre void fname##_free(stname *a) \ | |||
| { \ | |||
| ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ | |||
| } | |||
| # define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \ | |||
| stname *fname##_new(void) \ | |||
| { \ | |||
| return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ | |||
| } \ | |||
| void fname##_free(stname *a) \ | |||
| { \ | |||
| ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ | |||
| } | |||
| # define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \ | |||
| IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ | |||
| IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) | |||
| # define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ | |||
| stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ | |||
| { \ | |||
| return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ | |||
| } \ | |||
| int i2d_##fname(stname *a, unsigned char **out) \ | |||
| { \ | |||
| return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ | |||
| } | |||
| # define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \ | |||
| int i2d_##stname##_NDEF(stname *a, unsigned char **out) \ | |||
| { \ | |||
| return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\ | |||
| } | |||
| # define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname) \ | |||
| static stname *d2i_##stname(stname **a, \ | |||
| const unsigned char **in, long len) \ | |||
| { \ | |||
| return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \ | |||
| ASN1_ITEM_rptr(stname)); \ | |||
| } \ | |||
| static int i2d_##stname(stname *a, unsigned char **out) \ | |||
| { \ | |||
| return ASN1_item_i2d((ASN1_VALUE *)a, out, \ | |||
| ASN1_ITEM_rptr(stname)); \ | |||
| } | |||
| /* | |||
| * This includes evil casts to remove const: they will go away when full ASN1 | |||
| * constification is done. | |||
| */ | |||
| # define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ | |||
| stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ | |||
| { \ | |||
| return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ | |||
| } \ | |||
| int i2d_##fname(const stname *a, unsigned char **out) \ | |||
| { \ | |||
| return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ | |||
| } | |||
| # define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \ | |||
| stname * stname##_dup(stname *x) \ | |||
| { \ | |||
| return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \ | |||
| } | |||
| # define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \ | |||
| IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname) | |||
| # define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \ | |||
| int fname##_print_ctx(BIO *out, stname *x, int indent, \ | |||
| const ASN1_PCTX *pctx) \ | |||
| { \ | |||
| return ASN1_item_print(out, (ASN1_VALUE *)x, indent, \ | |||
| ASN1_ITEM_rptr(itname), pctx); \ | |||
| } | |||
| # define IMPLEMENT_ASN1_FUNCTIONS_const(name) \ | |||
| IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name) | |||
| # define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \ | |||
| IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ | |||
| IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) | |||
| /* external definitions for primitive types */ | |||
| DECLARE_ASN1_ITEM(ASN1_BOOLEAN) | |||
| DECLARE_ASN1_ITEM(ASN1_TBOOLEAN) | |||
| DECLARE_ASN1_ITEM(ASN1_FBOOLEAN) | |||
| DECLARE_ASN1_ITEM(ASN1_SEQUENCE) | |||
| DECLARE_ASN1_ITEM(CBIGNUM) | |||
| DECLARE_ASN1_ITEM(BIGNUM) | |||
| DECLARE_ASN1_ITEM(INT32) | |||
| DECLARE_ASN1_ITEM(ZINT32) | |||
| DECLARE_ASN1_ITEM(UINT32) | |||
| DECLARE_ASN1_ITEM(ZUINT32) | |||
| DECLARE_ASN1_ITEM(INT64) | |||
| DECLARE_ASN1_ITEM(ZINT64) | |||
| DECLARE_ASN1_ITEM(UINT64) | |||
| DECLARE_ASN1_ITEM(ZUINT64) | |||
| # if OPENSSL_API_COMPAT < 0x10200000L | |||
| /* | |||
| * LONG and ZLONG are strongly discouraged for use as stored data, as the | |||
| * underlying C type (long) differs in size depending on the architecture. | |||
| * They are designed with 32-bit longs in mind. | |||
| */ | |||
| DECLARE_ASN1_ITEM(LONG) | |||
| DECLARE_ASN1_ITEM(ZLONG) | |||
| # endif | |||
| DEFINE_STACK_OF(ASN1_VALUE) | |||
| /* Functions used internally by the ASN1 code */ | |||
| int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it); | |||
| void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it); | |||
| int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, | |||
| const ASN1_ITEM *it, int tag, int aclass, char opt, | |||
| ASN1_TLC *ctx); | |||
| int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, | |||
| const ASN1_ITEM *it, int tag, int aclass); | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,76 +0,0 @@ | |||
| /* | |||
| * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #include <stdlib.h> | |||
| #ifndef HEADER_ASYNC_H | |||
| # define HEADER_ASYNC_H | |||
| #if defined(_WIN32) | |||
| # if defined(BASETYPES) || defined(_WINDEF_H) | |||
| /* application has to include <windows.h> to use this */ | |||
| #define OSSL_ASYNC_FD HANDLE | |||
| #define OSSL_BAD_ASYNC_FD INVALID_HANDLE_VALUE | |||
| # endif | |||
| #else | |||
| #define OSSL_ASYNC_FD int | |||
| #define OSSL_BAD_ASYNC_FD -1 | |||
| #endif | |||
| # include <openssl/asyncerr.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| typedef struct async_job_st ASYNC_JOB; | |||
| typedef struct async_wait_ctx_st ASYNC_WAIT_CTX; | |||
| #define ASYNC_ERR 0 | |||
| #define ASYNC_NO_JOBS 1 | |||
| #define ASYNC_PAUSE 2 | |||
| #define ASYNC_FINISH 3 | |||
| int ASYNC_init_thread(size_t max_size, size_t init_size); | |||
| void ASYNC_cleanup_thread(void); | |||
| #ifdef OSSL_ASYNC_FD | |||
| ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void); | |||
| void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx); | |||
| int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key, | |||
| OSSL_ASYNC_FD fd, | |||
| void *custom_data, | |||
| void (*cleanup)(ASYNC_WAIT_CTX *, const void *, | |||
| OSSL_ASYNC_FD, void *)); | |||
| int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key, | |||
| OSSL_ASYNC_FD *fd, void **custom_data); | |||
| int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *fd, | |||
| size_t *numfds); | |||
| int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *addfd, | |||
| size_t *numaddfds, OSSL_ASYNC_FD *delfd, | |||
| size_t *numdelfds); | |||
| int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key); | |||
| #endif | |||
| int ASYNC_is_capable(void); | |||
| int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret, | |||
| int (*func)(void *), void *args, size_t size); | |||
| int ASYNC_pause_job(void); | |||
| ASYNC_JOB *ASYNC_get_current_job(void); | |||
| ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job); | |||
| void ASYNC_block_pause(void); | |||
| void ASYNC_unblock_pause(void); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,42 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_ASYNCERR_H | |||
| # define HEADER_ASYNCERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_ASYNC_strings(void); | |||
| /* | |||
| * ASYNC function codes. | |||
| */ | |||
| # define ASYNC_F_ASYNC_CTX_NEW 100 | |||
| # define ASYNC_F_ASYNC_INIT_THREAD 101 | |||
| # define ASYNC_F_ASYNC_JOB_NEW 102 | |||
| # define ASYNC_F_ASYNC_PAUSE_JOB 103 | |||
| # define ASYNC_F_ASYNC_START_FUNC 104 | |||
| # define ASYNC_F_ASYNC_START_JOB 105 | |||
| # define ASYNC_F_ASYNC_WAIT_CTX_SET_WAIT_FD 106 | |||
| /* | |||
| * ASYNC reason codes. | |||
| */ | |||
| # define ASYNC_R_FAILED_TO_SET_POOL 101 | |||
| # define ASYNC_R_FAILED_TO_SWAP_CONTEXT 102 | |||
| # define ASYNC_R_INIT_FAILED 105 | |||
| # define ASYNC_R_INVALID_POOL_SIZE 103 | |||
| #endif | |||
| @ -1,801 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_BIO_H | |||
| # define HEADER_BIO_H | |||
| # include <openssl/e_os2.h> | |||
| # ifndef OPENSSL_NO_STDIO | |||
| # include <stdio.h> | |||
| # endif | |||
| # include <stdarg.h> | |||
| # include <openssl/crypto.h> | |||
| # include <openssl/bioerr.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /* There are the classes of BIOs */ | |||
| # define BIO_TYPE_DESCRIPTOR 0x0100 /* socket, fd, connect or accept */ | |||
| # define BIO_TYPE_FILTER 0x0200 | |||
| # define BIO_TYPE_SOURCE_SINK 0x0400 | |||
| /* These are the 'types' of BIOs */ | |||
| # define BIO_TYPE_NONE 0 | |||
| # define BIO_TYPE_MEM ( 1|BIO_TYPE_SOURCE_SINK) | |||
| # define BIO_TYPE_FILE ( 2|BIO_TYPE_SOURCE_SINK) | |||
| # define BIO_TYPE_FD ( 4|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) | |||
| # define BIO_TYPE_SOCKET ( 5|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) | |||
| # define BIO_TYPE_NULL ( 6|BIO_TYPE_SOURCE_SINK) | |||
| # define BIO_TYPE_SSL ( 7|BIO_TYPE_FILTER) | |||
| # define BIO_TYPE_MD ( 8|BIO_TYPE_FILTER) | |||
| # define BIO_TYPE_BUFFER ( 9|BIO_TYPE_FILTER) | |||
| # define BIO_TYPE_CIPHER (10|BIO_TYPE_FILTER) | |||
| # define BIO_TYPE_BASE64 (11|BIO_TYPE_FILTER) | |||
| # define BIO_TYPE_CONNECT (12|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) | |||
| # define BIO_TYPE_ACCEPT (13|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) | |||
| # define BIO_TYPE_NBIO_TEST (16|BIO_TYPE_FILTER)/* server proxy BIO */ | |||
| # define BIO_TYPE_NULL_FILTER (17|BIO_TYPE_FILTER) | |||
| # define BIO_TYPE_BIO (19|BIO_TYPE_SOURCE_SINK)/* half a BIO pair */ | |||
| # define BIO_TYPE_LINEBUFFER (20|BIO_TYPE_FILTER) | |||
| # define BIO_TYPE_DGRAM (21|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) | |||
| # define BIO_TYPE_ASN1 (22|BIO_TYPE_FILTER) | |||
| # define BIO_TYPE_COMP (23|BIO_TYPE_FILTER) | |||
| # ifndef OPENSSL_NO_SCTP | |||
| # define BIO_TYPE_DGRAM_SCTP (24|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) | |||
| # endif | |||
| #define BIO_TYPE_START 128 | |||
| /* | |||
| * BIO_FILENAME_READ|BIO_CLOSE to open or close on free. | |||
| * BIO_set_fp(in,stdin,BIO_NOCLOSE); | |||
| */ | |||
| # define BIO_NOCLOSE 0x00 | |||
| # define BIO_CLOSE 0x01 | |||
| /* | |||
| * These are used in the following macros and are passed to BIO_ctrl() | |||
| */ | |||
| # define BIO_CTRL_RESET 1/* opt - rewind/zero etc */ | |||
| # define BIO_CTRL_EOF 2/* opt - are we at the eof */ | |||
| # define BIO_CTRL_INFO 3/* opt - extra tit-bits */ | |||
| # define BIO_CTRL_SET 4/* man - set the 'IO' type */ | |||
| # define BIO_CTRL_GET 5/* man - get the 'IO' type */ | |||
| # define BIO_CTRL_PUSH 6/* opt - internal, used to signify change */ | |||
| # define BIO_CTRL_POP 7/* opt - internal, used to signify change */ | |||
| # define BIO_CTRL_GET_CLOSE 8/* man - set the 'close' on free */ | |||
| # define BIO_CTRL_SET_CLOSE 9/* man - set the 'close' on free */ | |||
| # define BIO_CTRL_PENDING 10/* opt - is their more data buffered */ | |||
| # define BIO_CTRL_FLUSH 11/* opt - 'flush' buffered output */ | |||
| # define BIO_CTRL_DUP 12/* man - extra stuff for 'duped' BIO */ | |||
| # define BIO_CTRL_WPENDING 13/* opt - number of bytes still to write */ | |||
| # define BIO_CTRL_SET_CALLBACK 14/* opt - set callback function */ | |||
| # define BIO_CTRL_GET_CALLBACK 15/* opt - set callback function */ | |||
| # define BIO_CTRL_PEEK 29/* BIO_f_buffer special */ | |||
| # define BIO_CTRL_SET_FILENAME 30/* BIO_s_file special */ | |||
| /* dgram BIO stuff */ | |||
| # define BIO_CTRL_DGRAM_CONNECT 31/* BIO dgram special */ | |||
| # define BIO_CTRL_DGRAM_SET_CONNECTED 32/* allow for an externally connected | |||
| * socket to be passed in */ | |||
| # define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33/* setsockopt, essentially */ | |||
| # define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34/* getsockopt, essentially */ | |||
| # define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35/* setsockopt, essentially */ | |||
| # define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36/* getsockopt, essentially */ | |||
| # define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37/* flag whether the last */ | |||
| # define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38/* I/O operation tiemd out */ | |||
| /* #ifdef IP_MTU_DISCOVER */ | |||
| # define BIO_CTRL_DGRAM_MTU_DISCOVER 39/* set DF bit on egress packets */ | |||
| /* #endif */ | |||
| # define BIO_CTRL_DGRAM_QUERY_MTU 40/* as kernel for current MTU */ | |||
| # define BIO_CTRL_DGRAM_GET_FALLBACK_MTU 47 | |||
| # define BIO_CTRL_DGRAM_GET_MTU 41/* get cached value for MTU */ | |||
| # define BIO_CTRL_DGRAM_SET_MTU 42/* set cached value for MTU. | |||
| * want to use this if asking | |||
| * the kernel fails */ | |||
| # define BIO_CTRL_DGRAM_MTU_EXCEEDED 43/* check whether the MTU was | |||
| * exceed in the previous write | |||
| * operation */ | |||
| # define BIO_CTRL_DGRAM_GET_PEER 46 | |||
| # define BIO_CTRL_DGRAM_SET_PEER 44/* Destination for the data */ | |||
| # define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT 45/* Next DTLS handshake timeout | |||
| * to adjust socket timeouts */ | |||
| # define BIO_CTRL_DGRAM_SET_DONT_FRAG 48 | |||
| # define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD 49 | |||
| /* Deliberately outside of OPENSSL_NO_SCTP - used in bss_dgram.c */ | |||
| # define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE 50 | |||
| # ifndef OPENSSL_NO_SCTP | |||
| /* SCTP stuff */ | |||
| # define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY 51 | |||
| # define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY 52 | |||
| # define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD 53 | |||
| # define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO 60 | |||
| # define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO 61 | |||
| # define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO 62 | |||
| # define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO 63 | |||
| # define BIO_CTRL_DGRAM_SCTP_GET_PRINFO 64 | |||
| # define BIO_CTRL_DGRAM_SCTP_SET_PRINFO 65 | |||
| # define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN 70 | |||
| # endif | |||
| # define BIO_CTRL_DGRAM_SET_PEEK_MODE 71 | |||
| /* modifiers */ | |||
| # define BIO_FP_READ 0x02 | |||
| # define BIO_FP_WRITE 0x04 | |||
| # define BIO_FP_APPEND 0x08 | |||
| # define BIO_FP_TEXT 0x10 | |||
| # define BIO_FLAGS_READ 0x01 | |||
| # define BIO_FLAGS_WRITE 0x02 | |||
| # define BIO_FLAGS_IO_SPECIAL 0x04 | |||
| # define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL) | |||
| # define BIO_FLAGS_SHOULD_RETRY 0x08 | |||
| # ifndef BIO_FLAGS_UPLINK | |||
| /* | |||
| * "UPLINK" flag denotes file descriptors provided by application. It | |||
| * defaults to 0, as most platforms don't require UPLINK interface. | |||
| */ | |||
| # define BIO_FLAGS_UPLINK 0 | |||
| # endif | |||
| # define BIO_FLAGS_BASE64_NO_NL 0x100 | |||
| /* | |||
| * This is used with memory BIOs: | |||
| * BIO_FLAGS_MEM_RDONLY means we shouldn't free up or change the data in any way; | |||
| * BIO_FLAGS_NONCLEAR_RST means we shouldn't clear data on reset. | |||
| */ | |||
| # define BIO_FLAGS_MEM_RDONLY 0x200 | |||
| # define BIO_FLAGS_NONCLEAR_RST 0x400 | |||
| # define BIO_FLAGS_IN_EOF 0x800 | |||
| typedef union bio_addr_st BIO_ADDR; | |||
| typedef struct bio_addrinfo_st BIO_ADDRINFO; | |||
| int BIO_get_new_index(void); | |||
| void BIO_set_flags(BIO *b, int flags); | |||
| int BIO_test_flags(const BIO *b, int flags); | |||
| void BIO_clear_flags(BIO *b, int flags); | |||
| # define BIO_get_flags(b) BIO_test_flags(b, ~(0x0)) | |||
| # define BIO_set_retry_special(b) \ | |||
| BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY)) | |||
| # define BIO_set_retry_read(b) \ | |||
| BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY)) | |||
| # define BIO_set_retry_write(b) \ | |||
| BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY)) | |||
| /* These are normally used internally in BIOs */ | |||
| # define BIO_clear_retry_flags(b) \ | |||
| BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) | |||
| # define BIO_get_retry_flags(b) \ | |||
| BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) | |||
| /* These should be used by the application to tell why we should retry */ | |||
| # define BIO_should_read(a) BIO_test_flags(a, BIO_FLAGS_READ) | |||
| # define BIO_should_write(a) BIO_test_flags(a, BIO_FLAGS_WRITE) | |||
| # define BIO_should_io_special(a) BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL) | |||
| # define BIO_retry_type(a) BIO_test_flags(a, BIO_FLAGS_RWS) | |||
| # define BIO_should_retry(a) BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY) | |||
| /* | |||
| * The next three are used in conjunction with the BIO_should_io_special() | |||
| * condition. After this returns true, BIO *BIO_get_retry_BIO(BIO *bio, int | |||
| * *reason); will walk the BIO stack and return the 'reason' for the special | |||
| * and the offending BIO. Given a BIO, BIO_get_retry_reason(bio) will return | |||
| * the code. | |||
| */ | |||
| /* | |||
| * Returned from the SSL bio when the certificate retrieval code had an error | |||
| */ | |||
| # define BIO_RR_SSL_X509_LOOKUP 0x01 | |||
| /* Returned from the connect BIO when a connect would have blocked */ | |||
| # define BIO_RR_CONNECT 0x02 | |||
| /* Returned from the accept BIO when an accept would have blocked */ | |||
| # define BIO_RR_ACCEPT 0x03 | |||
| /* These are passed by the BIO callback */ | |||
| # define BIO_CB_FREE 0x01 | |||
| # define BIO_CB_READ 0x02 | |||
| # define BIO_CB_WRITE 0x03 | |||
| # define BIO_CB_PUTS 0x04 | |||
| # define BIO_CB_GETS 0x05 | |||
| # define BIO_CB_CTRL 0x06 | |||
| /* | |||
| * The callback is called before and after the underling operation, The | |||
| * BIO_CB_RETURN flag indicates if it is after the call | |||
| */ | |||
| # define BIO_CB_RETURN 0x80 | |||
| # define BIO_CB_return(a) ((a)|BIO_CB_RETURN) | |||
| # define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN)) | |||
| # define BIO_cb_post(a) ((a)&BIO_CB_RETURN) | |||
| typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi, | |||
| long argl, long ret); | |||
| typedef long (*BIO_callback_fn_ex)(BIO *b, int oper, const char *argp, | |||
| size_t len, int argi, | |||
| long argl, int ret, size_t *processed); | |||
| BIO_callback_fn BIO_get_callback(const BIO *b); | |||
| void BIO_set_callback(BIO *b, BIO_callback_fn callback); | |||
| BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b); | |||
| void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex callback); | |||
| char *BIO_get_callback_arg(const BIO *b); | |||
| void BIO_set_callback_arg(BIO *b, char *arg); | |||
| typedef struct bio_method_st BIO_METHOD; | |||
| const char *BIO_method_name(const BIO *b); | |||
| int BIO_method_type(const BIO *b); | |||
| typedef int BIO_info_cb(BIO *, int, int); | |||
| typedef BIO_info_cb bio_info_cb; /* backward compatibility */ | |||
| DEFINE_STACK_OF(BIO) | |||
| /* Prefix and suffix callback in ASN1 BIO */ | |||
| typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen, | |||
| void *parg); | |||
| # ifndef OPENSSL_NO_SCTP | |||
| /* SCTP parameter structs */ | |||
| struct bio_dgram_sctp_sndinfo { | |||
| uint16_t snd_sid; | |||
| uint16_t snd_flags; | |||
| uint32_t snd_ppid; | |||
| uint32_t snd_context; | |||
| }; | |||
| struct bio_dgram_sctp_rcvinfo { | |||
| uint16_t rcv_sid; | |||
| uint16_t rcv_ssn; | |||
| uint16_t rcv_flags; | |||
| uint32_t rcv_ppid; | |||
| uint32_t rcv_tsn; | |||
| uint32_t rcv_cumtsn; | |||
| uint32_t rcv_context; | |||
| }; | |||
| struct bio_dgram_sctp_prinfo { | |||
| uint16_t pr_policy; | |||
| uint32_t pr_value; | |||
| }; | |||
| # endif | |||
| /* | |||
| * #define BIO_CONN_get_param_hostname BIO_ctrl | |||
| */ | |||
| # define BIO_C_SET_CONNECT 100 | |||
| # define BIO_C_DO_STATE_MACHINE 101 | |||
| # define BIO_C_SET_NBIO 102 | |||
| /* # define BIO_C_SET_PROXY_PARAM 103 */ | |||
| # define BIO_C_SET_FD 104 | |||
| # define BIO_C_GET_FD 105 | |||
| # define BIO_C_SET_FILE_PTR 106 | |||
| # define BIO_C_GET_FILE_PTR 107 | |||
| # define BIO_C_SET_FILENAME 108 | |||
| # define BIO_C_SET_SSL 109 | |||
| # define BIO_C_GET_SSL 110 | |||
| # define BIO_C_SET_MD 111 | |||
| # define BIO_C_GET_MD 112 | |||
| # define BIO_C_GET_CIPHER_STATUS 113 | |||
| # define BIO_C_SET_BUF_MEM 114 | |||
| # define BIO_C_GET_BUF_MEM_PTR 115 | |||
| # define BIO_C_GET_BUFF_NUM_LINES 116 | |||
| # define BIO_C_SET_BUFF_SIZE 117 | |||
| # define BIO_C_SET_ACCEPT 118 | |||
| # define BIO_C_SSL_MODE 119 | |||
| # define BIO_C_GET_MD_CTX 120 | |||
| /* # define BIO_C_GET_PROXY_PARAM 121 */ | |||
| # define BIO_C_SET_BUFF_READ_DATA 122/* data to read first */ | |||
| # define BIO_C_GET_CONNECT 123 | |||
| # define BIO_C_GET_ACCEPT 124 | |||
| # define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125 | |||
| # define BIO_C_GET_SSL_NUM_RENEGOTIATES 126 | |||
| # define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127 | |||
| # define BIO_C_FILE_SEEK 128 | |||
| # define BIO_C_GET_CIPHER_CTX 129 | |||
| # define BIO_C_SET_BUF_MEM_EOF_RETURN 130/* return end of input | |||
| * value */ | |||
| # define BIO_C_SET_BIND_MODE 131 | |||
| # define BIO_C_GET_BIND_MODE 132 | |||
| # define BIO_C_FILE_TELL 133 | |||
| # define BIO_C_GET_SOCKS 134 | |||
| # define BIO_C_SET_SOCKS 135 | |||
| # define BIO_C_SET_WRITE_BUF_SIZE 136/* for BIO_s_bio */ | |||
| # define BIO_C_GET_WRITE_BUF_SIZE 137 | |||
| # define BIO_C_MAKE_BIO_PAIR 138 | |||
| # define BIO_C_DESTROY_BIO_PAIR 139 | |||
| # define BIO_C_GET_WRITE_GUARANTEE 140 | |||
| # define BIO_C_GET_READ_REQUEST 141 | |||
| # define BIO_C_SHUTDOWN_WR 142 | |||
| # define BIO_C_NREAD0 143 | |||
| # define BIO_C_NREAD 144 | |||
| # define BIO_C_NWRITE0 145 | |||
| # define BIO_C_NWRITE 146 | |||
| # define BIO_C_RESET_READ_REQUEST 147 | |||
| # define BIO_C_SET_MD_CTX 148 | |||
| # define BIO_C_SET_PREFIX 149 | |||
| # define BIO_C_GET_PREFIX 150 | |||
| # define BIO_C_SET_SUFFIX 151 | |||
| # define BIO_C_GET_SUFFIX 152 | |||
| # define BIO_C_SET_EX_ARG 153 | |||
| # define BIO_C_GET_EX_ARG 154 | |||
| # define BIO_C_SET_CONNECT_MODE 155 | |||
| # define BIO_set_app_data(s,arg) BIO_set_ex_data(s,0,arg) | |||
| # define BIO_get_app_data(s) BIO_get_ex_data(s,0) | |||
| # define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) | |||
| # ifndef OPENSSL_NO_SOCK | |||
| /* IP families we support, for BIO_s_connect() and BIO_s_accept() */ | |||
| /* Note: the underlying operating system may not support some of them */ | |||
| # define BIO_FAMILY_IPV4 4 | |||
| # define BIO_FAMILY_IPV6 6 | |||
| # define BIO_FAMILY_IPANY 256 | |||
| /* BIO_s_connect() */ | |||
| # define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0, \ | |||
| (char *)(name)) | |||
| # define BIO_set_conn_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,1, \ | |||
| (char *)(port)) | |||
| # define BIO_set_conn_address(b,addr) BIO_ctrl(b,BIO_C_SET_CONNECT,2, \ | |||
| (char *)(addr)) | |||
| # define BIO_set_conn_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,f) | |||
| # define BIO_get_conn_hostname(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0)) | |||
| # define BIO_get_conn_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1)) | |||
| # define BIO_get_conn_address(b) ((const BIO_ADDR *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2)) | |||
| # define BIO_get_conn_ip_family(b) BIO_ctrl(b,BIO_C_GET_CONNECT,3,NULL) | |||
| # define BIO_set_conn_mode(b,n) BIO_ctrl(b,BIO_C_SET_CONNECT_MODE,(n),NULL) | |||
| /* BIO_s_accept() */ | |||
| # define BIO_set_accept_name(b,name) BIO_ctrl(b,BIO_C_SET_ACCEPT,0, \ | |||
| (char *)(name)) | |||
| # define BIO_set_accept_port(b,port) BIO_ctrl(b,BIO_C_SET_ACCEPT,1, \ | |||
| (char *)(port)) | |||
| # define BIO_get_accept_name(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0)) | |||
| # define BIO_get_accept_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,1)) | |||
| # define BIO_get_peer_name(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,2)) | |||
| # define BIO_get_peer_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,3)) | |||
| /* #define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */ | |||
| # define BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(n)?(void *)"a":NULL) | |||
| # define BIO_set_accept_bios(b,bio) BIO_ctrl(b,BIO_C_SET_ACCEPT,3, \ | |||
| (char *)(bio)) | |||
| # define BIO_set_accept_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_ACCEPT,4,f) | |||
| # define BIO_get_accept_ip_family(b) BIO_ctrl(b,BIO_C_GET_ACCEPT,4,NULL) | |||
| /* Aliases kept for backward compatibility */ | |||
| # define BIO_BIND_NORMAL 0 | |||
| # define BIO_BIND_REUSEADDR BIO_SOCK_REUSEADDR | |||
| # define BIO_BIND_REUSEADDR_IF_UNUSED BIO_SOCK_REUSEADDR | |||
| # define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL) | |||
| # define BIO_get_bind_mode(b) BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL) | |||
| /* BIO_s_accept() and BIO_s_connect() */ | |||
| # define BIO_do_connect(b) BIO_do_handshake(b) | |||
| # define BIO_do_accept(b) BIO_do_handshake(b) | |||
| # endif /* OPENSSL_NO_SOCK */ | |||
| # define BIO_do_handshake(b) BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL) | |||
| /* BIO_s_datagram(), BIO_s_fd(), BIO_s_socket(), BIO_s_accept() and BIO_s_connect() */ | |||
| # define BIO_set_fd(b,fd,c) BIO_int_ctrl(b,BIO_C_SET_FD,c,fd) | |||
| # define BIO_get_fd(b,c) BIO_ctrl(b,BIO_C_GET_FD,0,(char *)(c)) | |||
| /* BIO_s_file() */ | |||
| # define BIO_set_fp(b,fp,c) BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)(fp)) | |||
| # define BIO_get_fp(b,fpp) BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)(fpp)) | |||
| /* BIO_s_fd() and BIO_s_file() */ | |||
| # define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL) | |||
| # define BIO_tell(b) (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL) | |||
| /* | |||
| * name is cast to lose const, but might be better to route through a | |||
| * function so we can do it safely | |||
| */ | |||
| # ifdef CONST_STRICT | |||
| /* | |||
| * If you are wondering why this isn't defined, its because CONST_STRICT is | |||
| * purely a compile-time kludge to allow const to be checked. | |||
| */ | |||
| int BIO_read_filename(BIO *b, const char *name); | |||
| # else | |||
| # define BIO_read_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ | |||
| BIO_CLOSE|BIO_FP_READ,(char *)(name)) | |||
| # endif | |||
| # define BIO_write_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ | |||
| BIO_CLOSE|BIO_FP_WRITE,name) | |||
| # define BIO_append_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ | |||
| BIO_CLOSE|BIO_FP_APPEND,name) | |||
| # define BIO_rw_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ | |||
| BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name) | |||
| /* | |||
| * WARNING WARNING, this ups the reference count on the read bio of the SSL | |||
| * structure. This is because the ssl read BIO is now pointed to by the | |||
| * next_bio field in the bio. So when you free the BIO, make sure you are | |||
| * doing a BIO_free_all() to catch the underlying BIO. | |||
| */ | |||
| # define BIO_set_ssl(b,ssl,c) BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)(ssl)) | |||
| # define BIO_get_ssl(b,sslp) BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)(sslp)) | |||
| # define BIO_set_ssl_mode(b,client) BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL) | |||
| # define BIO_set_ssl_renegotiate_bytes(b,num) \ | |||
| BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL) | |||
| # define BIO_get_num_renegotiates(b) \ | |||
| BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL) | |||
| # define BIO_set_ssl_renegotiate_timeout(b,seconds) \ | |||
| BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL) | |||
| /* defined in evp.h */ | |||
| /* #define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,1,(char *)(md)) */ | |||
| # define BIO_get_mem_data(b,pp) BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)(pp)) | |||
| # define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)(bm)) | |||
| # define BIO_get_mem_ptr(b,pp) BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0, \ | |||
| (char *)(pp)) | |||
| # define BIO_set_mem_eof_return(b,v) \ | |||
| BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL) | |||
| /* For the BIO_f_buffer() type */ | |||
| # define BIO_get_buffer_num_lines(b) BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL) | |||
| # define BIO_set_buffer_size(b,size) BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL) | |||
| # define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0) | |||
| # define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1) | |||
| # define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf) | |||
| /* Don't use the next one unless you know what you are doing :-) */ | |||
| # define BIO_dup_state(b,ret) BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret)) | |||
| # define BIO_reset(b) (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL) | |||
| # define BIO_eof(b) (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL) | |||
| # define BIO_set_close(b,c) (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL) | |||
| # define BIO_get_close(b) (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL) | |||
| # define BIO_pending(b) (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL) | |||
| # define BIO_wpending(b) (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL) | |||
| /* ...pending macros have inappropriate return type */ | |||
| size_t BIO_ctrl_pending(BIO *b); | |||
| size_t BIO_ctrl_wpending(BIO *b); | |||
| # define BIO_flush(b) (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL) | |||
| # define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \ | |||
| cbp) | |||
| # define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb) | |||
| /* For the BIO_f_buffer() type */ | |||
| # define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL) | |||
| # define BIO_buffer_peek(b,s,l) BIO_ctrl(b,BIO_CTRL_PEEK,(l),(s)) | |||
| /* For BIO_s_bio() */ | |||
| # define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL) | |||
| # define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL) | |||
| # define BIO_make_bio_pair(b1,b2) (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2) | |||
| # define BIO_destroy_bio_pair(b) (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL) | |||
| # define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL) | |||
| /* macros with inappropriate type -- but ...pending macros use int too: */ | |||
| # define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL) | |||
| # define BIO_get_read_request(b) (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL) | |||
| size_t BIO_ctrl_get_write_guarantee(BIO *b); | |||
| size_t BIO_ctrl_get_read_request(BIO *b); | |||
| int BIO_ctrl_reset_read_request(BIO *b); | |||
| /* ctrl macros for dgram */ | |||
| # define BIO_ctrl_dgram_connect(b,peer) \ | |||
| (int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)(peer)) | |||
| # define BIO_ctrl_set_connected(b,peer) \ | |||
| (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, 0, (char *)(peer)) | |||
| # define BIO_dgram_recv_timedout(b) \ | |||
| (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL) | |||
| # define BIO_dgram_send_timedout(b) \ | |||
| (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL) | |||
| # define BIO_dgram_get_peer(b,peer) \ | |||
| (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)(peer)) | |||
| # define BIO_dgram_set_peer(b,peer) \ | |||
| (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)(peer)) | |||
| # define BIO_dgram_get_mtu_overhead(b) \ | |||
| (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL) | |||
| #define BIO_get_ex_new_index(l, p, newf, dupf, freef) \ | |||
| CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, l, p, newf, dupf, freef) | |||
| int BIO_set_ex_data(BIO *bio, int idx, void *data); | |||
| void *BIO_get_ex_data(BIO *bio, int idx); | |||
| uint64_t BIO_number_read(BIO *bio); | |||
| uint64_t BIO_number_written(BIO *bio); | |||
| /* For BIO_f_asn1() */ | |||
| int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, | |||
| asn1_ps_func *prefix_free); | |||
| int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, | |||
| asn1_ps_func **pprefix_free); | |||
| int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, | |||
| asn1_ps_func *suffix_free); | |||
| int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, | |||
| asn1_ps_func **psuffix_free); | |||
| const BIO_METHOD *BIO_s_file(void); | |||
| BIO *BIO_new_file(const char *filename, const char *mode); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| BIO *BIO_new_fp(FILE *stream, int close_flag); | |||
| # endif | |||
| BIO *BIO_new(const BIO_METHOD *type); | |||
| int BIO_free(BIO *a); | |||
| void BIO_set_data(BIO *a, void *ptr); | |||
| void *BIO_get_data(BIO *a); | |||
| void BIO_set_init(BIO *a, int init); | |||
| int BIO_get_init(BIO *a); | |||
| void BIO_set_shutdown(BIO *a, int shut); | |||
| int BIO_get_shutdown(BIO *a); | |||
| void BIO_vfree(BIO *a); | |||
| int BIO_up_ref(BIO *a); | |||
| int BIO_read(BIO *b, void *data, int dlen); | |||
| int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes); | |||
| int BIO_gets(BIO *bp, char *buf, int size); | |||
| int BIO_write(BIO *b, const void *data, int dlen); | |||
| int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written); | |||
| int BIO_puts(BIO *bp, const char *buf); | |||
| int BIO_indent(BIO *b, int indent, int max); | |||
| long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg); | |||
| long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp); | |||
| void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg); | |||
| long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg); | |||
| BIO *BIO_push(BIO *b, BIO *append); | |||
| BIO *BIO_pop(BIO *b); | |||
| void BIO_free_all(BIO *a); | |||
| BIO *BIO_find_type(BIO *b, int bio_type); | |||
| BIO *BIO_next(BIO *b); | |||
| void BIO_set_next(BIO *b, BIO *next); | |||
| BIO *BIO_get_retry_BIO(BIO *bio, int *reason); | |||
| int BIO_get_retry_reason(BIO *bio); | |||
| void BIO_set_retry_reason(BIO *bio, int reason); | |||
| BIO *BIO_dup_chain(BIO *in); | |||
| int BIO_nread0(BIO *bio, char **buf); | |||
| int BIO_nread(BIO *bio, char **buf, int num); | |||
| int BIO_nwrite0(BIO *bio, char **buf); | |||
| int BIO_nwrite(BIO *bio, char **buf, int num); | |||
| long BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi, | |||
| long argl, long ret); | |||
| const BIO_METHOD *BIO_s_mem(void); | |||
| const BIO_METHOD *BIO_s_secmem(void); | |||
| BIO *BIO_new_mem_buf(const void *buf, int len); | |||
| # ifndef OPENSSL_NO_SOCK | |||
| const BIO_METHOD *BIO_s_socket(void); | |||
| const BIO_METHOD *BIO_s_connect(void); | |||
| const BIO_METHOD *BIO_s_accept(void); | |||
| # endif | |||
| const BIO_METHOD *BIO_s_fd(void); | |||
| const BIO_METHOD *BIO_s_log(void); | |||
| const BIO_METHOD *BIO_s_bio(void); | |||
| const BIO_METHOD *BIO_s_null(void); | |||
| const BIO_METHOD *BIO_f_null(void); | |||
| const BIO_METHOD *BIO_f_buffer(void); | |||
| const BIO_METHOD *BIO_f_linebuffer(void); | |||
| const BIO_METHOD *BIO_f_nbio_test(void); | |||
| # ifndef OPENSSL_NO_DGRAM | |||
| const BIO_METHOD *BIO_s_datagram(void); | |||
| int BIO_dgram_non_fatal_error(int error); | |||
| BIO *BIO_new_dgram(int fd, int close_flag); | |||
| # ifndef OPENSSL_NO_SCTP | |||
| const BIO_METHOD *BIO_s_datagram_sctp(void); | |||
| BIO *BIO_new_dgram_sctp(int fd, int close_flag); | |||
| int BIO_dgram_is_sctp(BIO *bio); | |||
| int BIO_dgram_sctp_notification_cb(BIO *b, | |||
| void (*handle_notifications) (BIO *bio, | |||
| void *context, | |||
| void *buf), | |||
| void *context); | |||
| int BIO_dgram_sctp_wait_for_dry(BIO *b); | |||
| int BIO_dgram_sctp_msg_waiting(BIO *b); | |||
| # endif | |||
| # endif | |||
| # ifndef OPENSSL_NO_SOCK | |||
| int BIO_sock_should_retry(int i); | |||
| int BIO_sock_non_fatal_error(int error); | |||
| # endif | |||
| int BIO_fd_should_retry(int i); | |||
| int BIO_fd_non_fatal_error(int error); | |||
| int BIO_dump_cb(int (*cb) (const void *data, size_t len, void *u), | |||
| void *u, const char *s, int len); | |||
| int BIO_dump_indent_cb(int (*cb) (const void *data, size_t len, void *u), | |||
| void *u, const char *s, int len, int indent); | |||
| int BIO_dump(BIO *b, const char *bytes, int len); | |||
| int BIO_dump_indent(BIO *b, const char *bytes, int len, int indent); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int BIO_dump_fp(FILE *fp, const char *s, int len); | |||
| int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent); | |||
| # endif | |||
| int BIO_hex_string(BIO *out, int indent, int width, unsigned char *data, | |||
| int datalen); | |||
| # ifndef OPENSSL_NO_SOCK | |||
| BIO_ADDR *BIO_ADDR_new(void); | |||
| int BIO_ADDR_rawmake(BIO_ADDR *ap, int family, | |||
| const void *where, size_t wherelen, unsigned short port); | |||
| void BIO_ADDR_free(BIO_ADDR *); | |||
| void BIO_ADDR_clear(BIO_ADDR *ap); | |||
| int BIO_ADDR_family(const BIO_ADDR *ap); | |||
| int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l); | |||
| unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap); | |||
| char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric); | |||
| char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric); | |||
| char *BIO_ADDR_path_string(const BIO_ADDR *ap); | |||
| const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai); | |||
| int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai); | |||
| int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai); | |||
| int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai); | |||
| const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai); | |||
| void BIO_ADDRINFO_free(BIO_ADDRINFO *bai); | |||
| enum BIO_hostserv_priorities { | |||
| BIO_PARSE_PRIO_HOST, BIO_PARSE_PRIO_SERV | |||
| }; | |||
| int BIO_parse_hostserv(const char *hostserv, char **host, char **service, | |||
| enum BIO_hostserv_priorities hostserv_prio); | |||
| enum BIO_lookup_type { | |||
| BIO_LOOKUP_CLIENT, BIO_LOOKUP_SERVER | |||
| }; | |||
| int BIO_lookup(const char *host, const char *service, | |||
| enum BIO_lookup_type lookup_type, | |||
| int family, int socktype, BIO_ADDRINFO **res); | |||
| int BIO_lookup_ex(const char *host, const char *service, | |||
| int lookup_type, int family, int socktype, int protocol, | |||
| BIO_ADDRINFO **res); | |||
| int BIO_sock_error(int sock); | |||
| int BIO_socket_ioctl(int fd, long type, void *arg); | |||
| int BIO_socket_nbio(int fd, int mode); | |||
| int BIO_sock_init(void); | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define BIO_sock_cleanup() while(0) continue | |||
| # endif | |||
| int BIO_set_tcp_ndelay(int sock, int turn_on); | |||
| DEPRECATEDIN_1_1_0(struct hostent *BIO_gethostbyname(const char *name)) | |||
| DEPRECATEDIN_1_1_0(int BIO_get_port(const char *str, unsigned short *port_ptr)) | |||
| DEPRECATEDIN_1_1_0(int BIO_get_host_ip(const char *str, unsigned char *ip)) | |||
| DEPRECATEDIN_1_1_0(int BIO_get_accept_socket(char *host_port, int mode)) | |||
| DEPRECATEDIN_1_1_0(int BIO_accept(int sock, char **ip_port)) | |||
| union BIO_sock_info_u { | |||
| BIO_ADDR *addr; | |||
| }; | |||
| enum BIO_sock_info_type { | |||
| BIO_SOCK_INFO_ADDRESS | |||
| }; | |||
| int BIO_sock_info(int sock, | |||
| enum BIO_sock_info_type type, union BIO_sock_info_u *info); | |||
| # define BIO_SOCK_REUSEADDR 0x01 | |||
| # define BIO_SOCK_V6_ONLY 0x02 | |||
| # define BIO_SOCK_KEEPALIVE 0x04 | |||
| # define BIO_SOCK_NONBLOCK 0x08 | |||
| # define BIO_SOCK_NODELAY 0x10 | |||
| int BIO_socket(int domain, int socktype, int protocol, int options); | |||
| int BIO_connect(int sock, const BIO_ADDR *addr, int options); | |||
| int BIO_bind(int sock, const BIO_ADDR *addr, int options); | |||
| int BIO_listen(int sock, const BIO_ADDR *addr, int options); | |||
| int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options); | |||
| int BIO_closesocket(int sock); | |||
| BIO *BIO_new_socket(int sock, int close_flag); | |||
| BIO *BIO_new_connect(const char *host_port); | |||
| BIO *BIO_new_accept(const char *host_port); | |||
| # endif /* OPENSSL_NO_SOCK*/ | |||
| BIO *BIO_new_fd(int fd, int close_flag); | |||
| int BIO_new_bio_pair(BIO **bio1, size_t writebuf1, | |||
| BIO **bio2, size_t writebuf2); | |||
| /* | |||
| * If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints. | |||
| * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default | |||
| * value. | |||
| */ | |||
| void BIO_copy_next_retry(BIO *b); | |||
| /* | |||
| * long BIO_ghbn_ctrl(int cmd,int iarg,char *parg); | |||
| */ | |||
| # define ossl_bio__attr__(x) | |||
| # if defined(__GNUC__) && defined(__STDC_VERSION__) \ | |||
| && !defined(__APPLE__) | |||
| /* | |||
| * Because we support the 'z' modifier, which made its appearance in C99, | |||
| * we can't use __attribute__ with pre C99 dialects. | |||
| */ | |||
| # if __STDC_VERSION__ >= 199901L | |||
| # undef ossl_bio__attr__ | |||
| # define ossl_bio__attr__ __attribute__ | |||
| # if __GNUC__*10 + __GNUC_MINOR__ >= 44 | |||
| # define ossl_bio__printf__ __gnu_printf__ | |||
| # else | |||
| # define ossl_bio__printf__ __printf__ | |||
| # endif | |||
| # endif | |||
| # endif | |||
| int BIO_printf(BIO *bio, const char *format, ...) | |||
| ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 3))); | |||
| int BIO_vprintf(BIO *bio, const char *format, va_list args) | |||
| ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 0))); | |||
| int BIO_snprintf(char *buf, size_t n, const char *format, ...) | |||
| ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 4))); | |||
| int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) | |||
| ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 0))); | |||
| # undef ossl_bio__attr__ | |||
| # undef ossl_bio__printf__ | |||
| BIO_METHOD *BIO_meth_new(int type, const char *name); | |||
| void BIO_meth_free(BIO_METHOD *biom); | |||
| int (*BIO_meth_get_write(const BIO_METHOD *biom)) (BIO *, const char *, int); | |||
| int (*BIO_meth_get_write_ex(const BIO_METHOD *biom)) (BIO *, const char *, size_t, | |||
| size_t *); | |||
| int BIO_meth_set_write(BIO_METHOD *biom, | |||
| int (*write) (BIO *, const char *, int)); | |||
| int BIO_meth_set_write_ex(BIO_METHOD *biom, | |||
| int (*bwrite) (BIO *, const char *, size_t, size_t *)); | |||
| int (*BIO_meth_get_read(const BIO_METHOD *biom)) (BIO *, char *, int); | |||
| int (*BIO_meth_get_read_ex(const BIO_METHOD *biom)) (BIO *, char *, size_t, size_t *); | |||
| int BIO_meth_set_read(BIO_METHOD *biom, | |||
| int (*read) (BIO *, char *, int)); | |||
| int BIO_meth_set_read_ex(BIO_METHOD *biom, | |||
| int (*bread) (BIO *, char *, size_t, size_t *)); | |||
| int (*BIO_meth_get_puts(const BIO_METHOD *biom)) (BIO *, const char *); | |||
| int BIO_meth_set_puts(BIO_METHOD *biom, | |||
| int (*puts) (BIO *, const char *)); | |||
| int (*BIO_meth_get_gets(const BIO_METHOD *biom)) (BIO *, char *, int); | |||
| int BIO_meth_set_gets(BIO_METHOD *biom, | |||
| int (*gets) (BIO *, char *, int)); | |||
| long (*BIO_meth_get_ctrl(const BIO_METHOD *biom)) (BIO *, int, long, void *); | |||
| int BIO_meth_set_ctrl(BIO_METHOD *biom, | |||
| long (*ctrl) (BIO *, int, long, void *)); | |||
| int (*BIO_meth_get_create(const BIO_METHOD *bion)) (BIO *); | |||
| int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *)); | |||
| int (*BIO_meth_get_destroy(const BIO_METHOD *biom)) (BIO *); | |||
| int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *)); | |||
| long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom)) | |||
| (BIO *, int, BIO_info_cb *); | |||
| int BIO_meth_set_callback_ctrl(BIO_METHOD *biom, | |||
| long (*callback_ctrl) (BIO *, int, | |||
| BIO_info_cb *)); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,124 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_BIOERR_H | |||
| # define HEADER_BIOERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_BIO_strings(void); | |||
| /* | |||
| * BIO function codes. | |||
| */ | |||
| # define BIO_F_ACPT_STATE 100 | |||
| # define BIO_F_ADDRINFO_WRAP 148 | |||
| # define BIO_F_ADDR_STRINGS 134 | |||
| # define BIO_F_BIO_ACCEPT 101 | |||
| # define BIO_F_BIO_ACCEPT_EX 137 | |||
| # define BIO_F_BIO_ACCEPT_NEW 152 | |||
| # define BIO_F_BIO_ADDR_NEW 144 | |||
| # define BIO_F_BIO_BIND 147 | |||
| # define BIO_F_BIO_CALLBACK_CTRL 131 | |||
| # define BIO_F_BIO_CONNECT 138 | |||
| # define BIO_F_BIO_CONNECT_NEW 153 | |||
| # define BIO_F_BIO_CTRL 103 | |||
| # define BIO_F_BIO_GETS 104 | |||
| # define BIO_F_BIO_GET_HOST_IP 106 | |||
| # define BIO_F_BIO_GET_NEW_INDEX 102 | |||
| # define BIO_F_BIO_GET_PORT 107 | |||
| # define BIO_F_BIO_LISTEN 139 | |||
| # define BIO_F_BIO_LOOKUP 135 | |||
| # define BIO_F_BIO_LOOKUP_EX 143 | |||
| # define BIO_F_BIO_MAKE_PAIR 121 | |||
| # define BIO_F_BIO_METH_NEW 146 | |||
| # define BIO_F_BIO_NEW 108 | |||
| # define BIO_F_BIO_NEW_DGRAM_SCTP 145 | |||
| # define BIO_F_BIO_NEW_FILE 109 | |||
| # define BIO_F_BIO_NEW_MEM_BUF 126 | |||
| # define BIO_F_BIO_NREAD 123 | |||
| # define BIO_F_BIO_NREAD0 124 | |||
| # define BIO_F_BIO_NWRITE 125 | |||
| # define BIO_F_BIO_NWRITE0 122 | |||
| # define BIO_F_BIO_PARSE_HOSTSERV 136 | |||
| # define BIO_F_BIO_PUTS 110 | |||
| # define BIO_F_BIO_READ 111 | |||
| # define BIO_F_BIO_READ_EX 105 | |||
| # define BIO_F_BIO_READ_INTERN 120 | |||
| # define BIO_F_BIO_SOCKET 140 | |||
| # define BIO_F_BIO_SOCKET_NBIO 142 | |||
| # define BIO_F_BIO_SOCK_INFO 141 | |||
| # define BIO_F_BIO_SOCK_INIT 112 | |||
| # define BIO_F_BIO_WRITE 113 | |||
| # define BIO_F_BIO_WRITE_EX 119 | |||
| # define BIO_F_BIO_WRITE_INTERN 128 | |||
| # define BIO_F_BUFFER_CTRL 114 | |||
| # define BIO_F_CONN_CTRL 127 | |||
| # define BIO_F_CONN_STATE 115 | |||
| # define BIO_F_DGRAM_SCTP_NEW 149 | |||
| # define BIO_F_DGRAM_SCTP_READ 132 | |||
| # define BIO_F_DGRAM_SCTP_WRITE 133 | |||
| # define BIO_F_DOAPR_OUTCH 150 | |||
| # define BIO_F_FILE_CTRL 116 | |||
| # define BIO_F_FILE_READ 130 | |||
| # define BIO_F_LINEBUFFER_CTRL 129 | |||
| # define BIO_F_LINEBUFFER_NEW 151 | |||
| # define BIO_F_MEM_WRITE 117 | |||
| # define BIO_F_NBIOF_NEW 154 | |||
| # define BIO_F_SLG_WRITE 155 | |||
| # define BIO_F_SSL_NEW 118 | |||
| /* | |||
| * BIO reason codes. | |||
| */ | |||
| # define BIO_R_ACCEPT_ERROR 100 | |||
| # define BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET 141 | |||
| # define BIO_R_AMBIGUOUS_HOST_OR_SERVICE 129 | |||
| # define BIO_R_BAD_FOPEN_MODE 101 | |||
| # define BIO_R_BROKEN_PIPE 124 | |||
| # define BIO_R_CONNECT_ERROR 103 | |||
| # define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET 107 | |||
| # define BIO_R_GETSOCKNAME_ERROR 132 | |||
| # define BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS 133 | |||
| # define BIO_R_GETTING_SOCKTYPE 134 | |||
| # define BIO_R_INVALID_ARGUMENT 125 | |||
| # define BIO_R_INVALID_SOCKET 135 | |||
| # define BIO_R_IN_USE 123 | |||
| # define BIO_R_LENGTH_TOO_LONG 102 | |||
| # define BIO_R_LISTEN_V6_ONLY 136 | |||
| # define BIO_R_LOOKUP_RETURNED_NOTHING 142 | |||
| # define BIO_R_MALFORMED_HOST_OR_SERVICE 130 | |||
| # define BIO_R_NBIO_CONNECT_ERROR 110 | |||
| # define BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED 143 | |||
| # define BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED 144 | |||
| # define BIO_R_NO_PORT_DEFINED 113 | |||
| # define BIO_R_NO_SUCH_FILE 128 | |||
| # define BIO_R_NULL_PARAMETER 115 | |||
| # define BIO_R_UNABLE_TO_BIND_SOCKET 117 | |||
| # define BIO_R_UNABLE_TO_CREATE_SOCKET 118 | |||
| # define BIO_R_UNABLE_TO_KEEPALIVE 137 | |||
| # define BIO_R_UNABLE_TO_LISTEN_SOCKET 119 | |||
| # define BIO_R_UNABLE_TO_NODELAY 138 | |||
| # define BIO_R_UNABLE_TO_REUSEADDR 139 | |||
| # define BIO_R_UNAVAILABLE_IP_FAMILY 145 | |||
| # define BIO_R_UNINITIALIZED 120 | |||
| # define BIO_R_UNKNOWN_INFO_TYPE 140 | |||
| # define BIO_R_UNSUPPORTED_IP_FAMILY 146 | |||
| # define BIO_R_UNSUPPORTED_METHOD 121 | |||
| # define BIO_R_UNSUPPORTED_PROTOCOL_FAMILY 131 | |||
| # define BIO_R_WRITE_TO_READ_ONLY_BIO 126 | |||
| # define BIO_R_WSASTARTUP 122 | |||
| #endif | |||
| @ -1,61 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_BLOWFISH_H | |||
| # define HEADER_BLOWFISH_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_BF | |||
| # include <openssl/e_os2.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| # define BF_ENCRYPT 1 | |||
| # define BF_DECRYPT 0 | |||
| /*- | |||
| * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |||
| * ! BF_LONG has to be at least 32 bits wide. ! | |||
| * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |||
| */ | |||
| # define BF_LONG unsigned int | |||
| # define BF_ROUNDS 16 | |||
| # define BF_BLOCK 8 | |||
| typedef struct bf_key_st { | |||
| BF_LONG P[BF_ROUNDS + 2]; | |||
| BF_LONG S[4 * 256]; | |||
| } BF_KEY; | |||
| void BF_set_key(BF_KEY *key, int len, const unsigned char *data); | |||
| void BF_encrypt(BF_LONG *data, const BF_KEY *key); | |||
| void BF_decrypt(BF_LONG *data, const BF_KEY *key); | |||
| void BF_ecb_encrypt(const unsigned char *in, unsigned char *out, | |||
| const BF_KEY *key, int enc); | |||
| void BF_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, | |||
| const BF_KEY *schedule, unsigned char *ivec, int enc); | |||
| void BF_cfb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, const BF_KEY *schedule, | |||
| unsigned char *ivec, int *num, int enc); | |||
| void BF_ofb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, const BF_KEY *schedule, | |||
| unsigned char *ivec, int *num); | |||
| const char *BF_options(void); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,539 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_BN_H | |||
| # define HEADER_BN_H | |||
| # include <openssl/e_os2.h> | |||
| # ifndef OPENSSL_NO_STDIO | |||
| # include <stdio.h> | |||
| # endif | |||
| # include <openssl/opensslconf.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/crypto.h> | |||
| # include <openssl/bnerr.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /* | |||
| * 64-bit processor with LP64 ABI | |||
| */ | |||
| # ifdef SIXTY_FOUR_BIT_LONG | |||
| # define BN_ULONG unsigned long | |||
| # define BN_BYTES 8 | |||
| # endif | |||
| /* | |||
| * 64-bit processor other than LP64 ABI | |||
| */ | |||
| # ifdef SIXTY_FOUR_BIT | |||
| # define BN_ULONG unsigned long long | |||
| # define BN_BYTES 8 | |||
| # endif | |||
| # ifdef THIRTY_TWO_BIT | |||
| # define BN_ULONG unsigned int | |||
| # define BN_BYTES 4 | |||
| # endif | |||
| # define BN_BITS2 (BN_BYTES * 8) | |||
| # define BN_BITS (BN_BITS2 * 2) | |||
| # define BN_TBIT ((BN_ULONG)1 << (BN_BITS2 - 1)) | |||
| # define BN_FLG_MALLOCED 0x01 | |||
| # define BN_FLG_STATIC_DATA 0x02 | |||
| /* | |||
| * avoid leaking exponent information through timing, | |||
| * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime, | |||
| * BN_div() will call BN_div_no_branch, | |||
| * BN_mod_inverse() will call bn_mod_inverse_no_branch. | |||
| */ | |||
| # define BN_FLG_CONSTTIME 0x04 | |||
| # define BN_FLG_SECURE 0x08 | |||
| # if OPENSSL_API_COMPAT < 0x00908000L | |||
| /* deprecated name for the flag */ | |||
| # define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME | |||
| # define BN_FLG_FREE 0x8000 /* used for debugging */ | |||
| # endif | |||
| void BN_set_flags(BIGNUM *b, int n); | |||
| int BN_get_flags(const BIGNUM *b, int n); | |||
| /* Values for |top| in BN_rand() */ | |||
| #define BN_RAND_TOP_ANY -1 | |||
| #define BN_RAND_TOP_ONE 0 | |||
| #define BN_RAND_TOP_TWO 1 | |||
| /* Values for |bottom| in BN_rand() */ | |||
| #define BN_RAND_BOTTOM_ANY 0 | |||
| #define BN_RAND_BOTTOM_ODD 1 | |||
| /* | |||
| * get a clone of a BIGNUM with changed flags, for *temporary* use only (the | |||
| * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The | |||
| * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that | |||
| * has not been otherwise initialised or used. | |||
| */ | |||
| void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags); | |||
| /* Wrapper function to make using BN_GENCB easier */ | |||
| int BN_GENCB_call(BN_GENCB *cb, int a, int b); | |||
| BN_GENCB *BN_GENCB_new(void); | |||
| void BN_GENCB_free(BN_GENCB *cb); | |||
| /* Populate a BN_GENCB structure with an "old"-style callback */ | |||
| void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *), | |||
| void *cb_arg); | |||
| /* Populate a BN_GENCB structure with a "new"-style callback */ | |||
| void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *), | |||
| void *cb_arg); | |||
| void *BN_GENCB_get_arg(BN_GENCB *cb); | |||
| # define BN_prime_checks 0 /* default: select number of iterations based | |||
| * on the size of the number */ | |||
| /* | |||
| * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations | |||
| * that will be done for checking that a random number is probably prime. The | |||
| * error rate for accepting a composite number as prime depends on the size of | |||
| * the prime |b|. The error rates used are for calculating an RSA key with 2 primes, | |||
| * and so the level is what you would expect for a key of double the size of the | |||
| * prime. | |||
| * | |||
| * This table is generated using the algorithm of FIPS PUB 186-4 | |||
| * Digital Signature Standard (DSS), section F.1, page 117. | |||
| * (https://dx.doi.org/10.6028/NIST.FIPS.186-4) | |||
| * | |||
| * The following magma script was used to generate the output: | |||
| * securitybits:=125; | |||
| * k:=1024; | |||
| * for t:=1 to 65 do | |||
| * for M:=3 to Floor(2*Sqrt(k-1)-1) do | |||
| * S:=0; | |||
| * // Sum over m | |||
| * for m:=3 to M do | |||
| * s:=0; | |||
| * // Sum over j | |||
| * for j:=2 to m do | |||
| * s+:=(RealField(32)!2)^-(j+(k-1)/j); | |||
| * end for; | |||
| * S+:=2^(m-(m-1)*t)*s; | |||
| * end for; | |||
| * A:=2^(k-2-M*t); | |||
| * B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S; | |||
| * pkt:=2.00743*Log(2)*k*2^-k*(A+B); | |||
| * seclevel:=Floor(-Log(2,pkt)); | |||
| * if seclevel ge securitybits then | |||
| * printf "k: %5o, security: %o bits (t: %o, M: %o)\n",k,seclevel,t,M; | |||
| * break; | |||
| * end if; | |||
| * end for; | |||
| * if seclevel ge securitybits then break; end if; | |||
| * end for; | |||
| * | |||
| * It can be run online at: | |||
| * http://magma.maths.usyd.edu.au/calc | |||
| * | |||
| * And will output: | |||
| * k: 1024, security: 129 bits (t: 6, M: 23) | |||
| * | |||
| * k is the number of bits of the prime, securitybits is the level we want to | |||
| * reach. | |||
| * | |||
| * prime length | RSA key size | # MR tests | security level | |||
| * -------------+--------------|------------+--------------- | |||
| * (b) >= 6394 | >= 12788 | 3 | 256 bit | |||
| * (b) >= 3747 | >= 7494 | 3 | 192 bit | |||
| * (b) >= 1345 | >= 2690 | 4 | 128 bit | |||
| * (b) >= 1080 | >= 2160 | 5 | 128 bit | |||
| * (b) >= 852 | >= 1704 | 5 | 112 bit | |||
| * (b) >= 476 | >= 952 | 5 | 80 bit | |||
| * (b) >= 400 | >= 800 | 6 | 80 bit | |||
| * (b) >= 347 | >= 694 | 7 | 80 bit | |||
| * (b) >= 308 | >= 616 | 8 | 80 bit | |||
| * (b) >= 55 | >= 110 | 27 | 64 bit | |||
| * (b) >= 6 | >= 12 | 34 | 64 bit | |||
| */ | |||
| # define BN_prime_checks_for_size(b) ((b) >= 3747 ? 3 : \ | |||
| (b) >= 1345 ? 4 : \ | |||
| (b) >= 476 ? 5 : \ | |||
| (b) >= 400 ? 6 : \ | |||
| (b) >= 347 ? 7 : \ | |||
| (b) >= 308 ? 8 : \ | |||
| (b) >= 55 ? 27 : \ | |||
| /* b >= 6 */ 34) | |||
| # define BN_num_bytes(a) ((BN_num_bits(a)+7)/8) | |||
| int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w); | |||
| int BN_is_zero(const BIGNUM *a); | |||
| int BN_is_one(const BIGNUM *a); | |||
| int BN_is_word(const BIGNUM *a, const BN_ULONG w); | |||
| int BN_is_odd(const BIGNUM *a); | |||
| # define BN_one(a) (BN_set_word((a),1)) | |||
| void BN_zero_ex(BIGNUM *a); | |||
| # if OPENSSL_API_COMPAT >= 0x00908000L | |||
| # define BN_zero(a) BN_zero_ex(a) | |||
| # else | |||
| # define BN_zero(a) (BN_set_word((a),0)) | |||
| # endif | |||
| const BIGNUM *BN_value_one(void); | |||
| char *BN_options(void); | |||
| BN_CTX *BN_CTX_new(void); | |||
| BN_CTX *BN_CTX_secure_new(void); | |||
| void BN_CTX_free(BN_CTX *c); | |||
| void BN_CTX_start(BN_CTX *ctx); | |||
| BIGNUM *BN_CTX_get(BN_CTX *ctx); | |||
| void BN_CTX_end(BN_CTX *ctx); | |||
| int BN_rand(BIGNUM *rnd, int bits, int top, int bottom); | |||
| int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom); | |||
| int BN_rand_range(BIGNUM *rnd, const BIGNUM *range); | |||
| int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range); | |||
| int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom); | |||
| int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range); | |||
| int BN_num_bits(const BIGNUM *a); | |||
| int BN_num_bits_word(BN_ULONG l); | |||
| int BN_security_bits(int L, int N); | |||
| BIGNUM *BN_new(void); | |||
| BIGNUM *BN_secure_new(void); | |||
| void BN_clear_free(BIGNUM *a); | |||
| BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b); | |||
| void BN_swap(BIGNUM *a, BIGNUM *b); | |||
| BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret); | |||
| int BN_bn2bin(const BIGNUM *a, unsigned char *to); | |||
| int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen); | |||
| BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret); | |||
| int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen); | |||
| BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret); | |||
| int BN_bn2mpi(const BIGNUM *a, unsigned char *to); | |||
| int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |||
| int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |||
| int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |||
| int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |||
| int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); | |||
| int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx); | |||
| /** BN_set_negative sets sign of a BIGNUM | |||
| * \param b pointer to the BIGNUM object | |||
| * \param n 0 if the BIGNUM b should be positive and a value != 0 otherwise | |||
| */ | |||
| void BN_set_negative(BIGNUM *b, int n); | |||
| /** BN_is_negative returns 1 if the BIGNUM is negative | |||
| * \param b pointer to the BIGNUM object | |||
| * \return 1 if a < 0 and 0 otherwise | |||
| */ | |||
| int BN_is_negative(const BIGNUM *b); | |||
| int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, | |||
| BN_CTX *ctx); | |||
| # define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx)) | |||
| int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx); | |||
| int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, | |||
| BN_CTX *ctx); | |||
| int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |||
| const BIGNUM *m); | |||
| int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, | |||
| BN_CTX *ctx); | |||
| int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |||
| const BIGNUM *m); | |||
| int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, | |||
| BN_CTX *ctx); | |||
| int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); | |||
| int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); | |||
| int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m); | |||
| int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m, | |||
| BN_CTX *ctx); | |||
| int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m); | |||
| BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w); | |||
| BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w); | |||
| int BN_mul_word(BIGNUM *a, BN_ULONG w); | |||
| int BN_add_word(BIGNUM *a, BN_ULONG w); | |||
| int BN_sub_word(BIGNUM *a, BN_ULONG w); | |||
| int BN_set_word(BIGNUM *a, BN_ULONG w); | |||
| BN_ULONG BN_get_word(const BIGNUM *a); | |||
| int BN_cmp(const BIGNUM *a, const BIGNUM *b); | |||
| void BN_free(BIGNUM *a); | |||
| int BN_is_bit_set(const BIGNUM *a, int n); | |||
| int BN_lshift(BIGNUM *r, const BIGNUM *a, int n); | |||
| int BN_lshift1(BIGNUM *r, const BIGNUM *a); | |||
| int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |||
| int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |||
| const BIGNUM *m, BN_CTX *ctx); | |||
| int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |||
| const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |||
| int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p, | |||
| const BIGNUM *m, BN_CTX *ctx, | |||
| BN_MONT_CTX *in_mont); | |||
| int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p, | |||
| const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |||
| int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1, | |||
| const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m, | |||
| BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |||
| int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |||
| const BIGNUM *m, BN_CTX *ctx); | |||
| int BN_mask_bits(BIGNUM *a, int n); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int BN_print_fp(FILE *fp, const BIGNUM *a); | |||
| # endif | |||
| int BN_print(BIO *bio, const BIGNUM *a); | |||
| int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx); | |||
| int BN_rshift(BIGNUM *r, const BIGNUM *a, int n); | |||
| int BN_rshift1(BIGNUM *r, const BIGNUM *a); | |||
| void BN_clear(BIGNUM *a); | |||
| BIGNUM *BN_dup(const BIGNUM *a); | |||
| int BN_ucmp(const BIGNUM *a, const BIGNUM *b); | |||
| int BN_set_bit(BIGNUM *a, int n); | |||
| int BN_clear_bit(BIGNUM *a, int n); | |||
| char *BN_bn2hex(const BIGNUM *a); | |||
| char *BN_bn2dec(const BIGNUM *a); | |||
| int BN_hex2bn(BIGNUM **a, const char *str); | |||
| int BN_dec2bn(BIGNUM **a, const char *str); | |||
| int BN_asc2bn(BIGNUM **a, const char *str); | |||
| int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); | |||
| int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns | |||
| * -2 for | |||
| * error */ | |||
| BIGNUM *BN_mod_inverse(BIGNUM *ret, | |||
| const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); | |||
| BIGNUM *BN_mod_sqrt(BIGNUM *ret, | |||
| const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); | |||
| void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords); | |||
| /* Deprecated versions */ | |||
| DEPRECATEDIN_0_9_8(BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe, | |||
| const BIGNUM *add, | |||
| const BIGNUM *rem, | |||
| void (*callback) (int, int, | |||
| void *), | |||
| void *cb_arg)) | |||
| DEPRECATEDIN_0_9_8(int | |||
| BN_is_prime(const BIGNUM *p, int nchecks, | |||
| void (*callback) (int, int, void *), | |||
| BN_CTX *ctx, void *cb_arg)) | |||
| DEPRECATEDIN_0_9_8(int | |||
| BN_is_prime_fasttest(const BIGNUM *p, int nchecks, | |||
| void (*callback) (int, int, void *), | |||
| BN_CTX *ctx, void *cb_arg, | |||
| int do_trial_division)) | |||
| /* Newer versions */ | |||
| int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add, | |||
| const BIGNUM *rem, BN_GENCB *cb); | |||
| int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb); | |||
| int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, | |||
| int do_trial_division, BN_GENCB *cb); | |||
| int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx); | |||
| int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | |||
| const BIGNUM *Xp, const BIGNUM *Xp1, | |||
| const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx, | |||
| BN_GENCB *cb); | |||
| int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1, | |||
| BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e, | |||
| BN_CTX *ctx, BN_GENCB *cb); | |||
| BN_MONT_CTX *BN_MONT_CTX_new(void); | |||
| int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |||
| BN_MONT_CTX *mont, BN_CTX *ctx); | |||
| int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, | |||
| BN_CTX *ctx); | |||
| int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, | |||
| BN_CTX *ctx); | |||
| void BN_MONT_CTX_free(BN_MONT_CTX *mont); | |||
| int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx); | |||
| BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from); | |||
| BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock, | |||
| const BIGNUM *mod, BN_CTX *ctx); | |||
| /* BN_BLINDING flags */ | |||
| # define BN_BLINDING_NO_UPDATE 0x00000001 | |||
| # define BN_BLINDING_NO_RECREATE 0x00000002 | |||
| BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod); | |||
| void BN_BLINDING_free(BN_BLINDING *b); | |||
| int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx); | |||
| int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); | |||
| int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); | |||
| int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *); | |||
| int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, | |||
| BN_CTX *); | |||
| int BN_BLINDING_is_current_thread(BN_BLINDING *b); | |||
| void BN_BLINDING_set_current_thread(BN_BLINDING *b); | |||
| int BN_BLINDING_lock(BN_BLINDING *b); | |||
| int BN_BLINDING_unlock(BN_BLINDING *b); | |||
| unsigned long BN_BLINDING_get_flags(const BN_BLINDING *); | |||
| void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long); | |||
| BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b, | |||
| const BIGNUM *e, BIGNUM *m, BN_CTX *ctx, | |||
| int (*bn_mod_exp) (BIGNUM *r, | |||
| const BIGNUM *a, | |||
| const BIGNUM *p, | |||
| const BIGNUM *m, | |||
| BN_CTX *ctx, | |||
| BN_MONT_CTX *m_ctx), | |||
| BN_MONT_CTX *m_ctx); | |||
| DEPRECATEDIN_0_9_8(void BN_set_params(int mul, int high, int low, int mont)) | |||
| DEPRECATEDIN_0_9_8(int BN_get_params(int which)) /* 0, mul, 1 high, 2 low, 3 | |||
| * mont */ | |||
| BN_RECP_CTX *BN_RECP_CTX_new(void); | |||
| void BN_RECP_CTX_free(BN_RECP_CTX *recp); | |||
| int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx); | |||
| int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y, | |||
| BN_RECP_CTX *recp, BN_CTX *ctx); | |||
| int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |||
| const BIGNUM *m, BN_CTX *ctx); | |||
| int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, | |||
| BN_RECP_CTX *recp, BN_CTX *ctx); | |||
| # ifndef OPENSSL_NO_EC2M | |||
| /* | |||
| * Functions for arithmetic over binary polynomials represented by BIGNUMs. | |||
| * The BIGNUM::neg property of BIGNUMs representing binary polynomials is | |||
| * ignored. Note that input arguments are not const so that their bit arrays | |||
| * can be expanded to the appropriate size if needed. | |||
| */ | |||
| /* | |||
| * r = a + b | |||
| */ | |||
| int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); | |||
| # define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b) | |||
| /* | |||
| * r=a mod p | |||
| */ | |||
| int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p); | |||
| /* r = (a * b) mod p */ | |||
| int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |||
| const BIGNUM *p, BN_CTX *ctx); | |||
| /* r = (a * a) mod p */ | |||
| int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |||
| /* r = (1 / b) mod p */ | |||
| int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx); | |||
| /* r = (a / b) mod p */ | |||
| int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |||
| const BIGNUM *p, BN_CTX *ctx); | |||
| /* r = (a ^ b) mod p */ | |||
| int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |||
| const BIGNUM *p, BN_CTX *ctx); | |||
| /* r = sqrt(a) mod p */ | |||
| int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |||
| BN_CTX *ctx); | |||
| /* r^2 + r = a mod p */ | |||
| int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |||
| BN_CTX *ctx); | |||
| # define BN_GF2m_cmp(a, b) BN_ucmp((a), (b)) | |||
| /*- | |||
| * Some functions allow for representation of the irreducible polynomials | |||
| * as an unsigned int[], say p. The irreducible f(t) is then of the form: | |||
| * t^p[0] + t^p[1] + ... + t^p[k] | |||
| * where m = p[0] > p[1] > ... > p[k] = 0. | |||
| */ | |||
| /* r = a mod p */ | |||
| int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]); | |||
| /* r = (a * b) mod p */ | |||
| int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |||
| const int p[], BN_CTX *ctx); | |||
| /* r = (a * a) mod p */ | |||
| int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[], | |||
| BN_CTX *ctx); | |||
| /* r = (1 / b) mod p */ | |||
| int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[], | |||
| BN_CTX *ctx); | |||
| /* r = (a / b) mod p */ | |||
| int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |||
| const int p[], BN_CTX *ctx); | |||
| /* r = (a ^ b) mod p */ | |||
| int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, | |||
| const int p[], BN_CTX *ctx); | |||
| /* r = sqrt(a) mod p */ | |||
| int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a, | |||
| const int p[], BN_CTX *ctx); | |||
| /* r^2 + r = a mod p */ | |||
| int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a, | |||
| const int p[], BN_CTX *ctx); | |||
| int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max); | |||
| int BN_GF2m_arr2poly(const int p[], BIGNUM *a); | |||
| # endif | |||
| /* | |||
| * faster mod functions for the 'NIST primes' 0 <= a < p^2 | |||
| */ | |||
| int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |||
| int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |||
| int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |||
| int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |||
| int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); | |||
| const BIGNUM *BN_get0_nist_prime_192(void); | |||
| const BIGNUM *BN_get0_nist_prime_224(void); | |||
| const BIGNUM *BN_get0_nist_prime_256(void); | |||
| const BIGNUM *BN_get0_nist_prime_384(void); | |||
| const BIGNUM *BN_get0_nist_prime_521(void); | |||
| int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a, | |||
| const BIGNUM *field, BN_CTX *ctx); | |||
| int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range, | |||
| const BIGNUM *priv, const unsigned char *message, | |||
| size_t message_len, BN_CTX *ctx); | |||
| /* Primes from RFC 2409 */ | |||
| BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn); | |||
| BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn); | |||
| /* Primes from RFC 3526 */ | |||
| BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn); | |||
| BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn); | |||
| BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn); | |||
| BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn); | |||
| BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn); | |||
| BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn); | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define get_rfc2409_prime_768 BN_get_rfc2409_prime_768 | |||
| # define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024 | |||
| # define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536 | |||
| # define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048 | |||
| # define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072 | |||
| # define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096 | |||
| # define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144 | |||
| # define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192 | |||
| # endif | |||
| int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,100 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_BNERR_H | |||
| # define HEADER_BNERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_BN_strings(void); | |||
| /* | |||
| * BN function codes. | |||
| */ | |||
| # define BN_F_BNRAND 127 | |||
| # define BN_F_BNRAND_RANGE 138 | |||
| # define BN_F_BN_BLINDING_CONVERT_EX 100 | |||
| # define BN_F_BN_BLINDING_CREATE_PARAM 128 | |||
| # define BN_F_BN_BLINDING_INVERT_EX 101 | |||
| # define BN_F_BN_BLINDING_NEW 102 | |||
| # define BN_F_BN_BLINDING_UPDATE 103 | |||
| # define BN_F_BN_BN2DEC 104 | |||
| # define BN_F_BN_BN2HEX 105 | |||
| # define BN_F_BN_COMPUTE_WNAF 142 | |||
| # define BN_F_BN_CTX_GET 116 | |||
| # define BN_F_BN_CTX_NEW 106 | |||
| # define BN_F_BN_CTX_START 129 | |||
| # define BN_F_BN_DIV 107 | |||
| # define BN_F_BN_DIV_RECP 130 | |||
| # define BN_F_BN_EXP 123 | |||
| # define BN_F_BN_EXPAND_INTERNAL 120 | |||
| # define BN_F_BN_GENCB_NEW 143 | |||
| # define BN_F_BN_GENERATE_DSA_NONCE 140 | |||
| # define BN_F_BN_GENERATE_PRIME_EX 141 | |||
| # define BN_F_BN_GF2M_MOD 131 | |||
| # define BN_F_BN_GF2M_MOD_EXP 132 | |||
| # define BN_F_BN_GF2M_MOD_MUL 133 | |||
| # define BN_F_BN_GF2M_MOD_SOLVE_QUAD 134 | |||
| # define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR 135 | |||
| # define BN_F_BN_GF2M_MOD_SQR 136 | |||
| # define BN_F_BN_GF2M_MOD_SQRT 137 | |||
| # define BN_F_BN_LSHIFT 145 | |||
| # define BN_F_BN_MOD_EXP2_MONT 118 | |||
| # define BN_F_BN_MOD_EXP_MONT 109 | |||
| # define BN_F_BN_MOD_EXP_MONT_CONSTTIME 124 | |||
| # define BN_F_BN_MOD_EXP_MONT_WORD 117 | |||
| # define BN_F_BN_MOD_EXP_RECP 125 | |||
| # define BN_F_BN_MOD_EXP_SIMPLE 126 | |||
| # define BN_F_BN_MOD_INVERSE 110 | |||
| # define BN_F_BN_MOD_INVERSE_NO_BRANCH 139 | |||
| # define BN_F_BN_MOD_LSHIFT_QUICK 119 | |||
| # define BN_F_BN_MOD_SQRT 121 | |||
| # define BN_F_BN_MONT_CTX_NEW 149 | |||
| # define BN_F_BN_MPI2BN 112 | |||
| # define BN_F_BN_NEW 113 | |||
| # define BN_F_BN_POOL_GET 147 | |||
| # define BN_F_BN_RAND 114 | |||
| # define BN_F_BN_RAND_RANGE 122 | |||
| # define BN_F_BN_RECP_CTX_NEW 150 | |||
| # define BN_F_BN_RSHIFT 146 | |||
| # define BN_F_BN_SET_WORDS 144 | |||
| # define BN_F_BN_STACK_PUSH 148 | |||
| # define BN_F_BN_USUB 115 | |||
| /* | |||
| * BN reason codes. | |||
| */ | |||
| # define BN_R_ARG2_LT_ARG3 100 | |||
| # define BN_R_BAD_RECIPROCAL 101 | |||
| # define BN_R_BIGNUM_TOO_LONG 114 | |||
| # define BN_R_BITS_TOO_SMALL 118 | |||
| # define BN_R_CALLED_WITH_EVEN_MODULUS 102 | |||
| # define BN_R_DIV_BY_ZERO 103 | |||
| # define BN_R_ENCODING_ERROR 104 | |||
| # define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105 | |||
| # define BN_R_INPUT_NOT_REDUCED 110 | |||
| # define BN_R_INVALID_LENGTH 106 | |||
| # define BN_R_INVALID_RANGE 115 | |||
| # define BN_R_INVALID_SHIFT 119 | |||
| # define BN_R_NOT_A_SQUARE 111 | |||
| # define BN_R_NOT_INITIALIZED 107 | |||
| # define BN_R_NO_INVERSE 108 | |||
| # define BN_R_NO_SOLUTION 116 | |||
| # define BN_R_PRIVATE_KEY_TOO_LARGE 117 | |||
| # define BN_R_P_IS_NOT_PRIME 112 | |||
| # define BN_R_TOO_MANY_ITERATIONS 113 | |||
| # define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109 | |||
| #endif | |||
| @ -1,58 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_BUFFER_H | |||
| # define HEADER_BUFFER_H | |||
| # include <openssl/ossl_typ.h> | |||
| # ifndef HEADER_CRYPTO_H | |||
| # include <openssl/crypto.h> | |||
| # endif | |||
| # include <openssl/buffererr.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # include <stddef.h> | |||
| # include <sys/types.h> | |||
| /* | |||
| * These names are outdated as of OpenSSL 1.1; a future release | |||
| * will move them to be deprecated. | |||
| */ | |||
| # define BUF_strdup(s) OPENSSL_strdup(s) | |||
| # define BUF_strndup(s, size) OPENSSL_strndup(s, size) | |||
| # define BUF_memdup(data, size) OPENSSL_memdup(data, size) | |||
| # define BUF_strlcpy(dst, src, size) OPENSSL_strlcpy(dst, src, size) | |||
| # define BUF_strlcat(dst, src, size) OPENSSL_strlcat(dst, src, size) | |||
| # define BUF_strnlen(str, maxlen) OPENSSL_strnlen(str, maxlen) | |||
| struct buf_mem_st { | |||
| size_t length; /* current number of bytes */ | |||
| char *data; | |||
| size_t max; /* size of buffer */ | |||
| unsigned long flags; | |||
| }; | |||
| # define BUF_MEM_FLAG_SECURE 0x01 | |||
| BUF_MEM *BUF_MEM_new(void); | |||
| BUF_MEM *BUF_MEM_new_ex(unsigned long flags); | |||
| void BUF_MEM_free(BUF_MEM *a); | |||
| size_t BUF_MEM_grow(BUF_MEM *str, size_t len); | |||
| size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len); | |||
| void BUF_reverse(unsigned char *out, const unsigned char *in, size_t siz); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,34 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_BUFERR_H | |||
| # define HEADER_BUFERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_BUF_strings(void); | |||
| /* | |||
| * BUF function codes. | |||
| */ | |||
| # define BUF_F_BUF_MEM_GROW 100 | |||
| # define BUF_F_BUF_MEM_GROW_CLEAN 105 | |||
| # define BUF_F_BUF_MEM_NEW 101 | |||
| /* | |||
| * BUF reason codes. | |||
| */ | |||
| #endif | |||
| @ -1,83 +0,0 @@ | |||
| /* | |||
| * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CAMELLIA_H | |||
| # define HEADER_CAMELLIA_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_CAMELLIA | |||
| # include <stddef.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # define CAMELLIA_ENCRYPT 1 | |||
| # define CAMELLIA_DECRYPT 0 | |||
| /* | |||
| * Because array size can't be a const in C, the following two are macros. | |||
| * Both sizes are in bytes. | |||
| */ | |||
| /* This should be a hidden type, but EVP requires that the size be known */ | |||
| # define CAMELLIA_BLOCK_SIZE 16 | |||
| # define CAMELLIA_TABLE_BYTE_LEN 272 | |||
| # define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4) | |||
| typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match | |||
| * with WORD */ | |||
| struct camellia_key_st { | |||
| union { | |||
| double d; /* ensures 64-bit align */ | |||
| KEY_TABLE_TYPE rd_key; | |||
| } u; | |||
| int grand_rounds; | |||
| }; | |||
| typedef struct camellia_key_st CAMELLIA_KEY; | |||
| int Camellia_set_key(const unsigned char *userKey, const int bits, | |||
| CAMELLIA_KEY *key); | |||
| void Camellia_encrypt(const unsigned char *in, unsigned char *out, | |||
| const CAMELLIA_KEY *key); | |||
| void Camellia_decrypt(const unsigned char *in, unsigned char *out, | |||
| const CAMELLIA_KEY *key); | |||
| void Camellia_ecb_encrypt(const unsigned char *in, unsigned char *out, | |||
| const CAMELLIA_KEY *key, const int enc); | |||
| void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const CAMELLIA_KEY *key, | |||
| unsigned char *ivec, const int enc); | |||
| void Camellia_cfb128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const CAMELLIA_KEY *key, | |||
| unsigned char *ivec, int *num, const int enc); | |||
| void Camellia_cfb1_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const CAMELLIA_KEY *key, | |||
| unsigned char *ivec, int *num, const int enc); | |||
| void Camellia_cfb8_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const CAMELLIA_KEY *key, | |||
| unsigned char *ivec, int *num, const int enc); | |||
| void Camellia_ofb128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const CAMELLIA_KEY *key, | |||
| unsigned char *ivec, int *num); | |||
| void Camellia_ctr128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const CAMELLIA_KEY *key, | |||
| unsigned char ivec[CAMELLIA_BLOCK_SIZE], | |||
| unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE], | |||
| unsigned int *num); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,53 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CAST_H | |||
| # define HEADER_CAST_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_CAST | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| # define CAST_ENCRYPT 1 | |||
| # define CAST_DECRYPT 0 | |||
| # define CAST_LONG unsigned int | |||
| # define CAST_BLOCK 8 | |||
| # define CAST_KEY_LENGTH 16 | |||
| typedef struct cast_key_st { | |||
| CAST_LONG data[32]; | |||
| int short_key; /* Use reduced rounds for short key */ | |||
| } CAST_KEY; | |||
| void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data); | |||
| void CAST_ecb_encrypt(const unsigned char *in, unsigned char *out, | |||
| const CAST_KEY *key, int enc); | |||
| void CAST_encrypt(CAST_LONG *data, const CAST_KEY *key); | |||
| void CAST_decrypt(CAST_LONG *data, const CAST_KEY *key); | |||
| void CAST_cbc_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, const CAST_KEY *ks, unsigned char *iv, | |||
| int enc); | |||
| void CAST_cfb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, const CAST_KEY *schedule, | |||
| unsigned char *ivec, int *num, int enc); | |||
| void CAST_ofb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, const CAST_KEY *schedule, | |||
| unsigned char *ivec, int *num); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,41 +0,0 @@ | |||
| /* | |||
| * Copyright 2010-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CMAC_H | |||
| # define HEADER_CMAC_H | |||
| # ifndef OPENSSL_NO_CMAC | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # include <openssl/evp.h> | |||
| /* Opaque */ | |||
| typedef struct CMAC_CTX_st CMAC_CTX; | |||
| CMAC_CTX *CMAC_CTX_new(void); | |||
| void CMAC_CTX_cleanup(CMAC_CTX *ctx); | |||
| void CMAC_CTX_free(CMAC_CTX *ctx); | |||
| EVP_CIPHER_CTX *CMAC_CTX_get0_cipher_ctx(CMAC_CTX *ctx); | |||
| int CMAC_CTX_copy(CMAC_CTX *out, const CMAC_CTX *in); | |||
| int CMAC_Init(CMAC_CTX *ctx, const void *key, size_t keylen, | |||
| const EVP_CIPHER *cipher, ENGINE *impl); | |||
| int CMAC_Update(CMAC_CTX *ctx, const void *data, size_t dlen); | |||
| int CMAC_Final(CMAC_CTX *ctx, unsigned char *out, size_t *poutlen); | |||
| int CMAC_resume(CMAC_CTX *ctx); | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| # endif | |||
| #endif | |||
| @ -1,339 +0,0 @@ | |||
| /* | |||
| * Copyright 2008-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CMS_H | |||
| # define HEADER_CMS_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_CMS | |||
| # include <openssl/x509.h> | |||
| # include <openssl/x509v3.h> | |||
| # include <openssl/cmserr.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| typedef struct CMS_ContentInfo_st CMS_ContentInfo; | |||
| typedef struct CMS_SignerInfo_st CMS_SignerInfo; | |||
| typedef struct CMS_CertificateChoices CMS_CertificateChoices; | |||
| typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice; | |||
| typedef struct CMS_RecipientInfo_st CMS_RecipientInfo; | |||
| typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest; | |||
| typedef struct CMS_Receipt_st CMS_Receipt; | |||
| typedef struct CMS_RecipientEncryptedKey_st CMS_RecipientEncryptedKey; | |||
| typedef struct CMS_OtherKeyAttribute_st CMS_OtherKeyAttribute; | |||
| DEFINE_STACK_OF(CMS_SignerInfo) | |||
| DEFINE_STACK_OF(CMS_RecipientEncryptedKey) | |||
| DEFINE_STACK_OF(CMS_RecipientInfo) | |||
| DEFINE_STACK_OF(CMS_RevocationInfoChoice) | |||
| DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo) | |||
| DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest) | |||
| DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo) | |||
| # define CMS_SIGNERINFO_ISSUER_SERIAL 0 | |||
| # define CMS_SIGNERINFO_KEYIDENTIFIER 1 | |||
| # define CMS_RECIPINFO_NONE -1 | |||
| # define CMS_RECIPINFO_TRANS 0 | |||
| # define CMS_RECIPINFO_AGREE 1 | |||
| # define CMS_RECIPINFO_KEK 2 | |||
| # define CMS_RECIPINFO_PASS 3 | |||
| # define CMS_RECIPINFO_OTHER 4 | |||
| /* S/MIME related flags */ | |||
| # define CMS_TEXT 0x1 | |||
| # define CMS_NOCERTS 0x2 | |||
| # define CMS_NO_CONTENT_VERIFY 0x4 | |||
| # define CMS_NO_ATTR_VERIFY 0x8 | |||
| # define CMS_NOSIGS \ | |||
| (CMS_NO_CONTENT_VERIFY|CMS_NO_ATTR_VERIFY) | |||
| # define CMS_NOINTERN 0x10 | |||
| # define CMS_NO_SIGNER_CERT_VERIFY 0x20 | |||
| # define CMS_NOVERIFY 0x20 | |||
| # define CMS_DETACHED 0x40 | |||
| # define CMS_BINARY 0x80 | |||
| # define CMS_NOATTR 0x100 | |||
| # define CMS_NOSMIMECAP 0x200 | |||
| # define CMS_NOOLDMIMETYPE 0x400 | |||
| # define CMS_CRLFEOL 0x800 | |||
| # define CMS_STREAM 0x1000 | |||
| # define CMS_NOCRL 0x2000 | |||
| # define CMS_PARTIAL 0x4000 | |||
| # define CMS_REUSE_DIGEST 0x8000 | |||
| # define CMS_USE_KEYID 0x10000 | |||
| # define CMS_DEBUG_DECRYPT 0x20000 | |||
| # define CMS_KEY_PARAM 0x40000 | |||
| # define CMS_ASCIICRLF 0x80000 | |||
| const ASN1_OBJECT *CMS_get0_type(const CMS_ContentInfo *cms); | |||
| BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont); | |||
| int CMS_dataFinal(CMS_ContentInfo *cms, BIO *bio); | |||
| ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms); | |||
| int CMS_is_detached(CMS_ContentInfo *cms); | |||
| int CMS_set_detached(CMS_ContentInfo *cms, int detached); | |||
| # ifdef HEADER_PEM_H | |||
| DECLARE_PEM_rw_const(CMS, CMS_ContentInfo) | |||
| # endif | |||
| int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms); | |||
| CMS_ContentInfo *d2i_CMS_bio(BIO *bp, CMS_ContentInfo **cms); | |||
| int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms); | |||
| BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms); | |||
| int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags); | |||
| int PEM_write_bio_CMS_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, | |||
| int flags); | |||
| CMS_ContentInfo *SMIME_read_CMS(BIO *bio, BIO **bcont); | |||
| int SMIME_write_CMS(BIO *bio, CMS_ContentInfo *cms, BIO *data, int flags); | |||
| int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont, | |||
| unsigned int flags); | |||
| CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey, | |||
| STACK_OF(X509) *certs, BIO *data, | |||
| unsigned int flags); | |||
| CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si, | |||
| X509 *signcert, EVP_PKEY *pkey, | |||
| STACK_OF(X509) *certs, unsigned int flags); | |||
| int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags); | |||
| CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags); | |||
| int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out, | |||
| unsigned int flags); | |||
| CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md, | |||
| unsigned int flags); | |||
| int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms, | |||
| const unsigned char *key, size_t keylen, | |||
| BIO *dcont, BIO *out, unsigned int flags); | |||
| CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher, | |||
| const unsigned char *key, | |||
| size_t keylen, unsigned int flags); | |||
| int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph, | |||
| const unsigned char *key, size_t keylen); | |||
| int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs, | |||
| X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags); | |||
| int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms, | |||
| STACK_OF(X509) *certs, | |||
| X509_STORE *store, unsigned int flags); | |||
| STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms); | |||
| CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *in, | |||
| const EVP_CIPHER *cipher, unsigned int flags); | |||
| int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pkey, X509 *cert, | |||
| BIO *dcont, BIO *out, unsigned int flags); | |||
| int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert); | |||
| int CMS_decrypt_set1_key(CMS_ContentInfo *cms, | |||
| unsigned char *key, size_t keylen, | |||
| const unsigned char *id, size_t idlen); | |||
| int CMS_decrypt_set1_password(CMS_ContentInfo *cms, | |||
| unsigned char *pass, ossl_ssize_t passlen); | |||
| STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms); | |||
| int CMS_RecipientInfo_type(CMS_RecipientInfo *ri); | |||
| EVP_PKEY_CTX *CMS_RecipientInfo_get0_pkey_ctx(CMS_RecipientInfo *ri); | |||
| CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher); | |||
| CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms, | |||
| X509 *recip, unsigned int flags); | |||
| int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey); | |||
| int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert); | |||
| int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri, | |||
| EVP_PKEY **pk, X509 **recip, | |||
| X509_ALGOR **palg); | |||
| int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri, | |||
| ASN1_OCTET_STRING **keyid, | |||
| X509_NAME **issuer, | |||
| ASN1_INTEGER **sno); | |||
| CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid, | |||
| unsigned char *key, size_t keylen, | |||
| unsigned char *id, size_t idlen, | |||
| ASN1_GENERALIZEDTIME *date, | |||
| ASN1_OBJECT *otherTypeId, | |||
| ASN1_TYPE *otherType); | |||
| int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri, | |||
| X509_ALGOR **palg, | |||
| ASN1_OCTET_STRING **pid, | |||
| ASN1_GENERALIZEDTIME **pdate, | |||
| ASN1_OBJECT **potherid, | |||
| ASN1_TYPE **pothertype); | |||
| int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri, | |||
| unsigned char *key, size_t keylen); | |||
| int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri, | |||
| const unsigned char *id, size_t idlen); | |||
| int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri, | |||
| unsigned char *pass, | |||
| ossl_ssize_t passlen); | |||
| CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms, | |||
| int iter, int wrap_nid, | |||
| int pbe_nid, | |||
| unsigned char *pass, | |||
| ossl_ssize_t passlen, | |||
| const EVP_CIPHER *kekciph); | |||
| int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri); | |||
| int CMS_RecipientInfo_encrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri); | |||
| int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out, | |||
| unsigned int flags); | |||
| CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags); | |||
| int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid); | |||
| const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms); | |||
| CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms); | |||
| int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert); | |||
| int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert); | |||
| STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms); | |||
| CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms); | |||
| int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl); | |||
| int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl); | |||
| STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms); | |||
| int CMS_SignedData_init(CMS_ContentInfo *cms); | |||
| CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms, | |||
| X509 *signer, EVP_PKEY *pk, const EVP_MD *md, | |||
| unsigned int flags); | |||
| EVP_PKEY_CTX *CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si); | |||
| EVP_MD_CTX *CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si); | |||
| STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms); | |||
| void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer); | |||
| int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si, | |||
| ASN1_OCTET_STRING **keyid, | |||
| X509_NAME **issuer, ASN1_INTEGER **sno); | |||
| int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert); | |||
| int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *certs, | |||
| unsigned int flags); | |||
| void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk, | |||
| X509 **signer, X509_ALGOR **pdig, | |||
| X509_ALGOR **psig); | |||
| ASN1_OCTET_STRING *CMS_SignerInfo_get0_signature(CMS_SignerInfo *si); | |||
| int CMS_SignerInfo_sign(CMS_SignerInfo *si); | |||
| int CMS_SignerInfo_verify(CMS_SignerInfo *si); | |||
| int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain); | |||
| int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs); | |||
| int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs, | |||
| int algnid, int keysize); | |||
| int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap); | |||
| int CMS_signed_get_attr_count(const CMS_SignerInfo *si); | |||
| int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid, | |||
| int lastpos); | |||
| int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, const ASN1_OBJECT *obj, | |||
| int lastpos); | |||
| X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc); | |||
| X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc); | |||
| int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); | |||
| int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si, | |||
| const ASN1_OBJECT *obj, int type, | |||
| const void *bytes, int len); | |||
| int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si, | |||
| int nid, int type, | |||
| const void *bytes, int len); | |||
| int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si, | |||
| const char *attrname, int type, | |||
| const void *bytes, int len); | |||
| void *CMS_signed_get0_data_by_OBJ(CMS_SignerInfo *si, const ASN1_OBJECT *oid, | |||
| int lastpos, int type); | |||
| int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si); | |||
| int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid, | |||
| int lastpos); | |||
| int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si, | |||
| const ASN1_OBJECT *obj, int lastpos); | |||
| X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc); | |||
| X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc); | |||
| int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); | |||
| int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si, | |||
| const ASN1_OBJECT *obj, int type, | |||
| const void *bytes, int len); | |||
| int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si, | |||
| int nid, int type, | |||
| const void *bytes, int len); | |||
| int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si, | |||
| const char *attrname, int type, | |||
| const void *bytes, int len); | |||
| void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid, | |||
| int lastpos, int type); | |||
| int CMS_get1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest **prr); | |||
| CMS_ReceiptRequest *CMS_ReceiptRequest_create0(unsigned char *id, int idlen, | |||
| int allorfirst, | |||
| STACK_OF(GENERAL_NAMES) | |||
| *receiptList, STACK_OF(GENERAL_NAMES) | |||
| *receiptsTo); | |||
| int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr); | |||
| void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest *rr, | |||
| ASN1_STRING **pcid, | |||
| int *pallorfirst, | |||
| STACK_OF(GENERAL_NAMES) **plist, | |||
| STACK_OF(GENERAL_NAMES) **prto); | |||
| int CMS_RecipientInfo_kari_get0_alg(CMS_RecipientInfo *ri, | |||
| X509_ALGOR **palg, | |||
| ASN1_OCTET_STRING **pukm); | |||
| STACK_OF(CMS_RecipientEncryptedKey) | |||
| *CMS_RecipientInfo_kari_get0_reks(CMS_RecipientInfo *ri); | |||
| int CMS_RecipientInfo_kari_get0_orig_id(CMS_RecipientInfo *ri, | |||
| X509_ALGOR **pubalg, | |||
| ASN1_BIT_STRING **pubkey, | |||
| ASN1_OCTET_STRING **keyid, | |||
| X509_NAME **issuer, | |||
| ASN1_INTEGER **sno); | |||
| int CMS_RecipientInfo_kari_orig_id_cmp(CMS_RecipientInfo *ri, X509 *cert); | |||
| int CMS_RecipientEncryptedKey_get0_id(CMS_RecipientEncryptedKey *rek, | |||
| ASN1_OCTET_STRING **keyid, | |||
| ASN1_GENERALIZEDTIME **tm, | |||
| CMS_OtherKeyAttribute **other, | |||
| X509_NAME **issuer, ASN1_INTEGER **sno); | |||
| int CMS_RecipientEncryptedKey_cert_cmp(CMS_RecipientEncryptedKey *rek, | |||
| X509 *cert); | |||
| int CMS_RecipientInfo_kari_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pk); | |||
| EVP_CIPHER_CTX *CMS_RecipientInfo_kari_get0_ctx(CMS_RecipientInfo *ri); | |||
| int CMS_RecipientInfo_kari_decrypt(CMS_ContentInfo *cms, | |||
| CMS_RecipientInfo *ri, | |||
| CMS_RecipientEncryptedKey *rek); | |||
| int CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg, | |||
| ASN1_OCTET_STRING *ukm, int keylen); | |||
| /* Backward compatibility for spelling errors. */ | |||
| # define CMS_R_UNKNOWN_DIGEST_ALGORITM CMS_R_UNKNOWN_DIGEST_ALGORITHM | |||
| # define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE \ | |||
| CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,202 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CMSERR_H | |||
| # define HEADER_CMSERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_CMS | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_CMS_strings(void); | |||
| /* | |||
| * CMS function codes. | |||
| */ | |||
| # define CMS_F_CHECK_CONTENT 99 | |||
| # define CMS_F_CMS_ADD0_CERT 164 | |||
| # define CMS_F_CMS_ADD0_RECIPIENT_KEY 100 | |||
| # define CMS_F_CMS_ADD0_RECIPIENT_PASSWORD 165 | |||
| # define CMS_F_CMS_ADD1_RECEIPTREQUEST 158 | |||
| # define CMS_F_CMS_ADD1_RECIPIENT_CERT 101 | |||
| # define CMS_F_CMS_ADD1_SIGNER 102 | |||
| # define CMS_F_CMS_ADD1_SIGNINGTIME 103 | |||
| # define CMS_F_CMS_COMPRESS 104 | |||
| # define CMS_F_CMS_COMPRESSEDDATA_CREATE 105 | |||
| # define CMS_F_CMS_COMPRESSEDDATA_INIT_BIO 106 | |||
| # define CMS_F_CMS_COPY_CONTENT 107 | |||
| # define CMS_F_CMS_COPY_MESSAGEDIGEST 108 | |||
| # define CMS_F_CMS_DATA 109 | |||
| # define CMS_F_CMS_DATAFINAL 110 | |||
| # define CMS_F_CMS_DATAINIT 111 | |||
| # define CMS_F_CMS_DECRYPT 112 | |||
| # define CMS_F_CMS_DECRYPT_SET1_KEY 113 | |||
| # define CMS_F_CMS_DECRYPT_SET1_PASSWORD 166 | |||
| # define CMS_F_CMS_DECRYPT_SET1_PKEY 114 | |||
| # define CMS_F_CMS_DIGESTALGORITHM_FIND_CTX 115 | |||
| # define CMS_F_CMS_DIGESTALGORITHM_INIT_BIO 116 | |||
| # define CMS_F_CMS_DIGESTEDDATA_DO_FINAL 117 | |||
| # define CMS_F_CMS_DIGEST_VERIFY 118 | |||
| # define CMS_F_CMS_ENCODE_RECEIPT 161 | |||
| # define CMS_F_CMS_ENCRYPT 119 | |||
| # define CMS_F_CMS_ENCRYPTEDCONTENT_INIT 179 | |||
| # define CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO 120 | |||
| # define CMS_F_CMS_ENCRYPTEDDATA_DECRYPT 121 | |||
| # define CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT 122 | |||
| # define CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY 123 | |||
| # define CMS_F_CMS_ENVELOPEDDATA_CREATE 124 | |||
| # define CMS_F_CMS_ENVELOPEDDATA_INIT_BIO 125 | |||
| # define CMS_F_CMS_ENVELOPED_DATA_INIT 126 | |||
| # define CMS_F_CMS_ENV_ASN1_CTRL 171 | |||
| # define CMS_F_CMS_FINAL 127 | |||
| # define CMS_F_CMS_GET0_CERTIFICATE_CHOICES 128 | |||
| # define CMS_F_CMS_GET0_CONTENT 129 | |||
| # define CMS_F_CMS_GET0_ECONTENT_TYPE 130 | |||
| # define CMS_F_CMS_GET0_ENVELOPED 131 | |||
| # define CMS_F_CMS_GET0_REVOCATION_CHOICES 132 | |||
| # define CMS_F_CMS_GET0_SIGNED 133 | |||
| # define CMS_F_CMS_MSGSIGDIGEST_ADD1 162 | |||
| # define CMS_F_CMS_RECEIPTREQUEST_CREATE0 159 | |||
| # define CMS_F_CMS_RECEIPT_VERIFY 160 | |||
| # define CMS_F_CMS_RECIPIENTINFO_DECRYPT 134 | |||
| # define CMS_F_CMS_RECIPIENTINFO_ENCRYPT 169 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KARI_ENCRYPT 178 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ALG 175 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ORIG_ID 173 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_REKS 172 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KARI_ORIG_ID_CMP 174 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT 135 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT 136 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID 137 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP 138 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP 139 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT 140 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT 141 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS 142 | |||
| # define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID 143 | |||
| # define CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT 167 | |||
| # define CMS_F_CMS_RECIPIENTINFO_SET0_KEY 144 | |||
| # define CMS_F_CMS_RECIPIENTINFO_SET0_PASSWORD 168 | |||
| # define CMS_F_CMS_RECIPIENTINFO_SET0_PKEY 145 | |||
| # define CMS_F_CMS_SD_ASN1_CTRL 170 | |||
| # define CMS_F_CMS_SET1_IAS 176 | |||
| # define CMS_F_CMS_SET1_KEYID 177 | |||
| # define CMS_F_CMS_SET1_SIGNERIDENTIFIER 146 | |||
| # define CMS_F_CMS_SET_DETACHED 147 | |||
| # define CMS_F_CMS_SIGN 148 | |||
| # define CMS_F_CMS_SIGNED_DATA_INIT 149 | |||
| # define CMS_F_CMS_SIGNERINFO_CONTENT_SIGN 150 | |||
| # define CMS_F_CMS_SIGNERINFO_SIGN 151 | |||
| # define CMS_F_CMS_SIGNERINFO_VERIFY 152 | |||
| # define CMS_F_CMS_SIGNERINFO_VERIFY_CERT 153 | |||
| # define CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT 154 | |||
| # define CMS_F_CMS_SIGN_RECEIPT 163 | |||
| # define CMS_F_CMS_SI_CHECK_ATTRIBUTES 183 | |||
| # define CMS_F_CMS_STREAM 155 | |||
| # define CMS_F_CMS_UNCOMPRESS 156 | |||
| # define CMS_F_CMS_VERIFY 157 | |||
| # define CMS_F_KEK_UNWRAP_KEY 180 | |||
| /* | |||
| * CMS reason codes. | |||
| */ | |||
| # define CMS_R_ADD_SIGNER_ERROR 99 | |||
| # define CMS_R_ATTRIBUTE_ERROR 161 | |||
| # define CMS_R_CERTIFICATE_ALREADY_PRESENT 175 | |||
| # define CMS_R_CERTIFICATE_HAS_NO_KEYID 160 | |||
| # define CMS_R_CERTIFICATE_VERIFY_ERROR 100 | |||
| # define CMS_R_CIPHER_INITIALISATION_ERROR 101 | |||
| # define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR 102 | |||
| # define CMS_R_CMS_DATAFINAL_ERROR 103 | |||
| # define CMS_R_CMS_LIB 104 | |||
| # define CMS_R_CONTENTIDENTIFIER_MISMATCH 170 | |||
| # define CMS_R_CONTENT_NOT_FOUND 105 | |||
| # define CMS_R_CONTENT_TYPE_MISMATCH 171 | |||
| # define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA 106 | |||
| # define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA 107 | |||
| # define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA 108 | |||
| # define CMS_R_CONTENT_VERIFY_ERROR 109 | |||
| # define CMS_R_CTRL_ERROR 110 | |||
| # define CMS_R_CTRL_FAILURE 111 | |||
| # define CMS_R_DECRYPT_ERROR 112 | |||
| # define CMS_R_ERROR_GETTING_PUBLIC_KEY 113 | |||
| # define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE 114 | |||
| # define CMS_R_ERROR_SETTING_KEY 115 | |||
| # define CMS_R_ERROR_SETTING_RECIPIENTINFO 116 | |||
| # define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH 117 | |||
| # define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER 176 | |||
| # define CMS_R_INVALID_KEY_LENGTH 118 | |||
| # define CMS_R_MD_BIO_INIT_ERROR 119 | |||
| # define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH 120 | |||
| # define CMS_R_MESSAGEDIGEST_WRONG_LENGTH 121 | |||
| # define CMS_R_MSGSIGDIGEST_ERROR 172 | |||
| # define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE 162 | |||
| # define CMS_R_MSGSIGDIGEST_WRONG_LENGTH 163 | |||
| # define CMS_R_NEED_ONE_SIGNER 164 | |||
| # define CMS_R_NOT_A_SIGNED_RECEIPT 165 | |||
| # define CMS_R_NOT_ENCRYPTED_DATA 122 | |||
| # define CMS_R_NOT_KEK 123 | |||
| # define CMS_R_NOT_KEY_AGREEMENT 181 | |||
| # define CMS_R_NOT_KEY_TRANSPORT 124 | |||
| # define CMS_R_NOT_PWRI 177 | |||
| # define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 125 | |||
| # define CMS_R_NO_CIPHER 126 | |||
| # define CMS_R_NO_CONTENT 127 | |||
| # define CMS_R_NO_CONTENT_TYPE 173 | |||
| # define CMS_R_NO_DEFAULT_DIGEST 128 | |||
| # define CMS_R_NO_DIGEST_SET 129 | |||
| # define CMS_R_NO_KEY 130 | |||
| # define CMS_R_NO_KEY_OR_CERT 174 | |||
| # define CMS_R_NO_MATCHING_DIGEST 131 | |||
| # define CMS_R_NO_MATCHING_RECIPIENT 132 | |||
| # define CMS_R_NO_MATCHING_SIGNATURE 166 | |||
| # define CMS_R_NO_MSGSIGDIGEST 167 | |||
| # define CMS_R_NO_PASSWORD 178 | |||
| # define CMS_R_NO_PRIVATE_KEY 133 | |||
| # define CMS_R_NO_PUBLIC_KEY 134 | |||
| # define CMS_R_NO_RECEIPT_REQUEST 168 | |||
| # define CMS_R_NO_SIGNERS 135 | |||
| # define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 136 | |||
| # define CMS_R_RECEIPT_DECODE_ERROR 169 | |||
| # define CMS_R_RECIPIENT_ERROR 137 | |||
| # define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND 138 | |||
| # define CMS_R_SIGNFINAL_ERROR 139 | |||
| # define CMS_R_SMIME_TEXT_ERROR 140 | |||
| # define CMS_R_STORE_INIT_ERROR 141 | |||
| # define CMS_R_TYPE_NOT_COMPRESSED_DATA 142 | |||
| # define CMS_R_TYPE_NOT_DATA 143 | |||
| # define CMS_R_TYPE_NOT_DIGESTED_DATA 144 | |||
| # define CMS_R_TYPE_NOT_ENCRYPTED_DATA 145 | |||
| # define CMS_R_TYPE_NOT_ENVELOPED_DATA 146 | |||
| # define CMS_R_UNABLE_TO_FINALIZE_CONTEXT 147 | |||
| # define CMS_R_UNKNOWN_CIPHER 148 | |||
| # define CMS_R_UNKNOWN_DIGEST_ALGORITHM 149 | |||
| # define CMS_R_UNKNOWN_ID 150 | |||
| # define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM 151 | |||
| # define CMS_R_UNSUPPORTED_CONTENT_TYPE 152 | |||
| # define CMS_R_UNSUPPORTED_KEK_ALGORITHM 153 | |||
| # define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM 179 | |||
| # define CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE 155 | |||
| # define CMS_R_UNSUPPORTED_RECIPIENT_TYPE 154 | |||
| # define CMS_R_UNSUPPORTED_TYPE 156 | |||
| # define CMS_R_UNWRAP_ERROR 157 | |||
| # define CMS_R_UNWRAP_FAILURE 180 | |||
| # define CMS_R_VERIFICATION_FAILURE 158 | |||
| # define CMS_R_WRAP_ERROR 159 | |||
| # endif | |||
| #endif | |||
| @ -1,53 +0,0 @@ | |||
| /* | |||
| * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_COMP_H | |||
| # define HEADER_COMP_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_COMP | |||
| # include <openssl/crypto.h> | |||
| # include <openssl/comperr.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| COMP_CTX *COMP_CTX_new(COMP_METHOD *meth); | |||
| const COMP_METHOD *COMP_CTX_get_method(const COMP_CTX *ctx); | |||
| int COMP_CTX_get_type(const COMP_CTX* comp); | |||
| int COMP_get_type(const COMP_METHOD *meth); | |||
| const char *COMP_get_name(const COMP_METHOD *meth); | |||
| void COMP_CTX_free(COMP_CTX *ctx); | |||
| int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen, | |||
| unsigned char *in, int ilen); | |||
| int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen, | |||
| unsigned char *in, int ilen); | |||
| COMP_METHOD *COMP_zlib(void); | |||
| #if OPENSSL_API_COMPAT < 0x10100000L | |||
| #define COMP_zlib_cleanup() while(0) continue | |||
| #endif | |||
| # ifdef HEADER_BIO_H | |||
| # ifdef ZLIB | |||
| const BIO_METHOD *BIO_f_zlib(void); | |||
| # endif | |||
| # endif | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,44 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_COMPERR_H | |||
| # define HEADER_COMPERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_COMP | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_COMP_strings(void); | |||
| /* | |||
| * COMP function codes. | |||
| */ | |||
| # define COMP_F_BIO_ZLIB_FLUSH 99 | |||
| # define COMP_F_BIO_ZLIB_NEW 100 | |||
| # define COMP_F_BIO_ZLIB_READ 101 | |||
| # define COMP_F_BIO_ZLIB_WRITE 102 | |||
| # define COMP_F_COMP_CTX_NEW 103 | |||
| /* | |||
| * COMP reason codes. | |||
| */ | |||
| # define COMP_R_ZLIB_DEFLATE_ERROR 99 | |||
| # define COMP_R_ZLIB_INFLATE_ERROR 100 | |||
| # define COMP_R_ZLIB_NOT_SUPPORTED 101 | |||
| # endif | |||
| #endif | |||
| @ -1,168 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CONF_H | |||
| # define HEADER_CONF_H | |||
| # include <openssl/bio.h> | |||
| # include <openssl/lhash.h> | |||
| # include <openssl/safestack.h> | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/conferr.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| typedef struct { | |||
| char *section; | |||
| char *name; | |||
| char *value; | |||
| } CONF_VALUE; | |||
| DEFINE_STACK_OF(CONF_VALUE) | |||
| DEFINE_LHASH_OF(CONF_VALUE); | |||
| struct conf_st; | |||
| struct conf_method_st; | |||
| typedef struct conf_method_st CONF_METHOD; | |||
| struct conf_method_st { | |||
| const char *name; | |||
| CONF *(*create) (CONF_METHOD *meth); | |||
| int (*init) (CONF *conf); | |||
| int (*destroy) (CONF *conf); | |||
| int (*destroy_data) (CONF *conf); | |||
| int (*load_bio) (CONF *conf, BIO *bp, long *eline); | |||
| int (*dump) (const CONF *conf, BIO *bp); | |||
| int (*is_number) (const CONF *conf, char c); | |||
| int (*to_int) (const CONF *conf, char c); | |||
| int (*load) (CONF *conf, const char *name, long *eline); | |||
| }; | |||
| /* Module definitions */ | |||
| typedef struct conf_imodule_st CONF_IMODULE; | |||
| typedef struct conf_module_st CONF_MODULE; | |||
| DEFINE_STACK_OF(CONF_MODULE) | |||
| DEFINE_STACK_OF(CONF_IMODULE) | |||
| /* DSO module function typedefs */ | |||
| typedef int conf_init_func (CONF_IMODULE *md, const CONF *cnf); | |||
| typedef void conf_finish_func (CONF_IMODULE *md); | |||
| # define CONF_MFLAGS_IGNORE_ERRORS 0x1 | |||
| # define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2 | |||
| # define CONF_MFLAGS_SILENT 0x4 | |||
| # define CONF_MFLAGS_NO_DSO 0x8 | |||
| # define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10 | |||
| # define CONF_MFLAGS_DEFAULT_SECTION 0x20 | |||
| int CONF_set_default_method(CONF_METHOD *meth); | |||
| void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash); | |||
| LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file, | |||
| long *eline); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp, | |||
| long *eline); | |||
| # endif | |||
| LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp, | |||
| long *eline); | |||
| STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf, | |||
| const char *section); | |||
| char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf, const char *group, | |||
| const char *name); | |||
| long CONF_get_number(LHASH_OF(CONF_VALUE) *conf, const char *group, | |||
| const char *name); | |||
| void CONF_free(LHASH_OF(CONF_VALUE) *conf); | |||
| #ifndef OPENSSL_NO_STDIO | |||
| int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out); | |||
| #endif | |||
| int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out); | |||
| DEPRECATEDIN_1_1_0(void OPENSSL_config(const char *config_name)) | |||
| #if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define OPENSSL_no_config() \ | |||
| OPENSSL_init_crypto(OPENSSL_INIT_NO_LOAD_CONFIG, NULL) | |||
| #endif | |||
| /* | |||
| * New conf code. The semantics are different from the functions above. If | |||
| * that wasn't the case, the above functions would have been replaced | |||
| */ | |||
| struct conf_st { | |||
| CONF_METHOD *meth; | |||
| void *meth_data; | |||
| LHASH_OF(CONF_VALUE) *data; | |||
| }; | |||
| CONF *NCONF_new(CONF_METHOD *meth); | |||
| CONF_METHOD *NCONF_default(void); | |||
| CONF_METHOD *NCONF_WIN32(void); | |||
| void NCONF_free(CONF *conf); | |||
| void NCONF_free_data(CONF *conf); | |||
| int NCONF_load(CONF *conf, const char *file, long *eline); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int NCONF_load_fp(CONF *conf, FILE *fp, long *eline); | |||
| # endif | |||
| int NCONF_load_bio(CONF *conf, BIO *bp, long *eline); | |||
| STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf, | |||
| const char *section); | |||
| char *NCONF_get_string(const CONF *conf, const char *group, const char *name); | |||
| int NCONF_get_number_e(const CONF *conf, const char *group, const char *name, | |||
| long *result); | |||
| #ifndef OPENSSL_NO_STDIO | |||
| int NCONF_dump_fp(const CONF *conf, FILE *out); | |||
| #endif | |||
| int NCONF_dump_bio(const CONF *conf, BIO *out); | |||
| #define NCONF_get_number(c,g,n,r) NCONF_get_number_e(c,g,n,r) | |||
| /* Module functions */ | |||
| int CONF_modules_load(const CONF *cnf, const char *appname, | |||
| unsigned long flags); | |||
| int CONF_modules_load_file(const char *filename, const char *appname, | |||
| unsigned long flags); | |||
| void CONF_modules_unload(int all); | |||
| void CONF_modules_finish(void); | |||
| #if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define CONF_modules_free() while(0) continue | |||
| #endif | |||
| int CONF_module_add(const char *name, conf_init_func *ifunc, | |||
| conf_finish_func *ffunc); | |||
| const char *CONF_imodule_get_name(const CONF_IMODULE *md); | |||
| const char *CONF_imodule_get_value(const CONF_IMODULE *md); | |||
| void *CONF_imodule_get_usr_data(const CONF_IMODULE *md); | |||
| void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data); | |||
| CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md); | |||
| unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md); | |||
| void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags); | |||
| void *CONF_module_get_usr_data(CONF_MODULE *pmod); | |||
| void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data); | |||
| char *CONF_get1_default_config_file(void); | |||
| int CONF_parse_list(const char *list, int sep, int nospc, | |||
| int (*list_cb) (const char *elem, int len, void *usr), | |||
| void *arg); | |||
| void OPENSSL_load_builtin_modules(void); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,40 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CONF_API_H | |||
| # define HEADER_CONF_API_H | |||
| # include <openssl/lhash.h> | |||
| # include <openssl/conf.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /* Up until OpenSSL 0.9.5a, this was new_section */ | |||
| CONF_VALUE *_CONF_new_section(CONF *conf, const char *section); | |||
| /* Up until OpenSSL 0.9.5a, this was get_section */ | |||
| CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section); | |||
| /* Up until OpenSSL 0.9.5a, this was CONF_get_section */ | |||
| STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf, | |||
| const char *section); | |||
| int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value); | |||
| char *_CONF_get_string(const CONF *conf, const char *section, | |||
| const char *name); | |||
| long _CONF_get_number(const CONF *conf, const char *section, | |||
| const char *name); | |||
| int _CONF_new_data(CONF *conf); | |||
| void _CONF_free_data(CONF *conf); | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,76 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CONFERR_H | |||
| # define HEADER_CONFERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_CONF_strings(void); | |||
| /* | |||
| * CONF function codes. | |||
| */ | |||
| # define CONF_F_CONF_DUMP_FP 104 | |||
| # define CONF_F_CONF_LOAD 100 | |||
| # define CONF_F_CONF_LOAD_FP 103 | |||
| # define CONF_F_CONF_PARSE_LIST 119 | |||
| # define CONF_F_DEF_LOAD 120 | |||
| # define CONF_F_DEF_LOAD_BIO 121 | |||
| # define CONF_F_GET_NEXT_FILE 107 | |||
| # define CONF_F_MODULE_ADD 122 | |||
| # define CONF_F_MODULE_INIT 115 | |||
| # define CONF_F_MODULE_LOAD_DSO 117 | |||
| # define CONF_F_MODULE_RUN 118 | |||
| # define CONF_F_NCONF_DUMP_BIO 105 | |||
| # define CONF_F_NCONF_DUMP_FP 106 | |||
| # define CONF_F_NCONF_GET_NUMBER_E 112 | |||
| # define CONF_F_NCONF_GET_SECTION 108 | |||
| # define CONF_F_NCONF_GET_STRING 109 | |||
| # define CONF_F_NCONF_LOAD 113 | |||
| # define CONF_F_NCONF_LOAD_BIO 110 | |||
| # define CONF_F_NCONF_LOAD_FP 114 | |||
| # define CONF_F_NCONF_NEW 111 | |||
| # define CONF_F_PROCESS_INCLUDE 116 | |||
| # define CONF_F_SSL_MODULE_INIT 123 | |||
| # define CONF_F_STR_COPY 101 | |||
| /* | |||
| * CONF reason codes. | |||
| */ | |||
| # define CONF_R_ERROR_LOADING_DSO 110 | |||
| # define CONF_R_LIST_CANNOT_BE_NULL 115 | |||
| # define CONF_R_MISSING_CLOSE_SQUARE_BRACKET 100 | |||
| # define CONF_R_MISSING_EQUAL_SIGN 101 | |||
| # define CONF_R_MISSING_INIT_FUNCTION 112 | |||
| # define CONF_R_MODULE_INITIALIZATION_ERROR 109 | |||
| # define CONF_R_NO_CLOSE_BRACE 102 | |||
| # define CONF_R_NO_CONF 105 | |||
| # define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE 106 | |||
| # define CONF_R_NO_SECTION 107 | |||
| # define CONF_R_NO_SUCH_FILE 114 | |||
| # define CONF_R_NO_VALUE 108 | |||
| # define CONF_R_NUMBER_TOO_LARGE 121 | |||
| # define CONF_R_RECURSIVE_DIRECTORY_INCLUDE 111 | |||
| # define CONF_R_SSL_COMMAND_SECTION_EMPTY 117 | |||
| # define CONF_R_SSL_COMMAND_SECTION_NOT_FOUND 118 | |||
| # define CONF_R_SSL_SECTION_EMPTY 119 | |||
| # define CONF_R_SSL_SECTION_NOT_FOUND 120 | |||
| # define CONF_R_UNABLE_TO_CREATE_NEW_SECTION 103 | |||
| # define CONF_R_UNKNOWN_MODULE_NAME 113 | |||
| # define CONF_R_VARIABLE_EXPANSION_TOO_LONG 116 | |||
| # define CONF_R_VARIABLE_HAS_NO_VALUE 104 | |||
| #endif | |||
| @ -1,445 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CRYPTO_H | |||
| # define HEADER_CRYPTO_H | |||
| # include <stdlib.h> | |||
| # include <time.h> | |||
| # include <openssl/e_os2.h> | |||
| # ifndef OPENSSL_NO_STDIO | |||
| # include <stdio.h> | |||
| # endif | |||
| # include <openssl/safestack.h> | |||
| # include <openssl/opensslv.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/opensslconf.h> | |||
| # include <openssl/cryptoerr.h> | |||
| # ifdef CHARSET_EBCDIC | |||
| # include <openssl/ebcdic.h> | |||
| # endif | |||
| /* | |||
| * Resolve problems on some operating systems with symbol names that clash | |||
| * one way or another | |||
| */ | |||
| # include <openssl/symhacks.h> | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # include <openssl/opensslv.h> | |||
| # endif | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define SSLeay OpenSSL_version_num | |||
| # define SSLeay_version OpenSSL_version | |||
| # define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER | |||
| # define SSLEAY_VERSION OPENSSL_VERSION | |||
| # define SSLEAY_CFLAGS OPENSSL_CFLAGS | |||
| # define SSLEAY_BUILT_ON OPENSSL_BUILT_ON | |||
| # define SSLEAY_PLATFORM OPENSSL_PLATFORM | |||
| # define SSLEAY_DIR OPENSSL_DIR | |||
| /* | |||
| * Old type for allocating dynamic locks. No longer used. Use the new thread | |||
| * API instead. | |||
| */ | |||
| typedef struct { | |||
| int dummy; | |||
| } CRYPTO_dynlock; | |||
| # endif /* OPENSSL_API_COMPAT */ | |||
| typedef void CRYPTO_RWLOCK; | |||
| CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void); | |||
| int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock); | |||
| int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock); | |||
| int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock); | |||
| void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock); | |||
| int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock); | |||
| /* | |||
| * The following can be used to detect memory leaks in the library. If | |||
| * used, it turns on malloc checking | |||
| */ | |||
| # define CRYPTO_MEM_CHECK_OFF 0x0 /* Control only */ | |||
| # define CRYPTO_MEM_CHECK_ON 0x1 /* Control and mode bit */ | |||
| # define CRYPTO_MEM_CHECK_ENABLE 0x2 /* Control and mode bit */ | |||
| # define CRYPTO_MEM_CHECK_DISABLE 0x3 /* Control only */ | |||
| struct crypto_ex_data_st { | |||
| STACK_OF(void) *sk; | |||
| }; | |||
| DEFINE_STACK_OF(void) | |||
| /* | |||
| * Per class, we have a STACK of function pointers. | |||
| */ | |||
| # define CRYPTO_EX_INDEX_SSL 0 | |||
| # define CRYPTO_EX_INDEX_SSL_CTX 1 | |||
| # define CRYPTO_EX_INDEX_SSL_SESSION 2 | |||
| # define CRYPTO_EX_INDEX_X509 3 | |||
| # define CRYPTO_EX_INDEX_X509_STORE 4 | |||
| # define CRYPTO_EX_INDEX_X509_STORE_CTX 5 | |||
| # define CRYPTO_EX_INDEX_DH 6 | |||
| # define CRYPTO_EX_INDEX_DSA 7 | |||
| # define CRYPTO_EX_INDEX_EC_KEY 8 | |||
| # define CRYPTO_EX_INDEX_RSA 9 | |||
| # define CRYPTO_EX_INDEX_ENGINE 10 | |||
| # define CRYPTO_EX_INDEX_UI 11 | |||
| # define CRYPTO_EX_INDEX_BIO 12 | |||
| # define CRYPTO_EX_INDEX_APP 13 | |||
| # define CRYPTO_EX_INDEX_UI_METHOD 14 | |||
| # define CRYPTO_EX_INDEX_DRBG 15 | |||
| # define CRYPTO_EX_INDEX__COUNT 16 | |||
| /* No longer needed, so this is a no-op */ | |||
| #define OPENSSL_malloc_init() while(0) continue | |||
| int CRYPTO_mem_ctrl(int mode); | |||
| # define OPENSSL_malloc(num) \ | |||
| CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_zalloc(num) \ | |||
| CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_realloc(addr, num) \ | |||
| CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_clear_realloc(addr, old_num, num) \ | |||
| CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_clear_free(addr, num) \ | |||
| CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_free(addr) \ | |||
| CRYPTO_free(addr, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_memdup(str, s) \ | |||
| CRYPTO_memdup((str), s, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_strdup(str) \ | |||
| CRYPTO_strdup(str, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_strndup(str, n) \ | |||
| CRYPTO_strndup(str, n, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_secure_malloc(num) \ | |||
| CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_secure_zalloc(num) \ | |||
| CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_secure_free(addr) \ | |||
| CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_secure_clear_free(addr, num) \ | |||
| CRYPTO_secure_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_secure_actual_size(ptr) \ | |||
| CRYPTO_secure_actual_size(ptr) | |||
| size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz); | |||
| size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz); | |||
| size_t OPENSSL_strnlen(const char *str, size_t maxlen); | |||
| char *OPENSSL_buf2hexstr(const unsigned char *buffer, long len); | |||
| unsigned char *OPENSSL_hexstr2buf(const char *str, long *len); | |||
| int OPENSSL_hexchar2int(unsigned char c); | |||
| # define OPENSSL_MALLOC_MAX_NELEMS(type) (((1U<<(sizeof(int)*8-1))-1)/sizeof(type)) | |||
| unsigned long OpenSSL_version_num(void); | |||
| const char *OpenSSL_version(int type); | |||
| # define OPENSSL_VERSION 0 | |||
| # define OPENSSL_CFLAGS 1 | |||
| # define OPENSSL_BUILT_ON 2 | |||
| # define OPENSSL_PLATFORM 3 | |||
| # define OPENSSL_DIR 4 | |||
| # define OPENSSL_ENGINES_DIR 5 | |||
| int OPENSSL_issetugid(void); | |||
| typedef void CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad, | |||
| int idx, long argl, void *argp); | |||
| typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad, | |||
| int idx, long argl, void *argp); | |||
| typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from, | |||
| void *from_d, int idx, long argl, void *argp); | |||
| __owur int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp, | |||
| CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, | |||
| CRYPTO_EX_free *free_func); | |||
| /* No longer use an index. */ | |||
| int CRYPTO_free_ex_index(int class_index, int idx); | |||
| /* | |||
| * Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a | |||
| * given class (invokes whatever per-class callbacks are applicable) | |||
| */ | |||
| int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); | |||
| int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to, | |||
| const CRYPTO_EX_DATA *from); | |||
| void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); | |||
| /* | |||
| * Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular | |||
| * index (relative to the class type involved) | |||
| */ | |||
| int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val); | |||
| void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx); | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| /* | |||
| * This function cleans up all "ex_data" state. It mustn't be called under | |||
| * potential race-conditions. | |||
| */ | |||
| # define CRYPTO_cleanup_all_ex_data() while(0) continue | |||
| /* | |||
| * The old locking functions have been removed completely without compatibility | |||
| * macros. This is because the old functions either could not properly report | |||
| * errors, or the returned error values were not clearly documented. | |||
| * Replacing the locking functions with no-ops would cause race condition | |||
| * issues in the affected applications. It is far better for them to fail at | |||
| * compile time. | |||
| * On the other hand, the locking callbacks are no longer used. Consequently, | |||
| * the callback management functions can be safely replaced with no-op macros. | |||
| */ | |||
| # define CRYPTO_num_locks() (1) | |||
| # define CRYPTO_set_locking_callback(func) | |||
| # define CRYPTO_get_locking_callback() (NULL) | |||
| # define CRYPTO_set_add_lock_callback(func) | |||
| # define CRYPTO_get_add_lock_callback() (NULL) | |||
| /* | |||
| * These defines where used in combination with the old locking callbacks, | |||
| * they are not called anymore, but old code that's not called might still | |||
| * use them. | |||
| */ | |||
| # define CRYPTO_LOCK 1 | |||
| # define CRYPTO_UNLOCK 2 | |||
| # define CRYPTO_READ 4 | |||
| # define CRYPTO_WRITE 8 | |||
| /* This structure is no longer used */ | |||
| typedef struct crypto_threadid_st { | |||
| int dummy; | |||
| } CRYPTO_THREADID; | |||
| /* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */ | |||
| # define CRYPTO_THREADID_set_numeric(id, val) | |||
| # define CRYPTO_THREADID_set_pointer(id, ptr) | |||
| # define CRYPTO_THREADID_set_callback(threadid_func) (0) | |||
| # define CRYPTO_THREADID_get_callback() (NULL) | |||
| # define CRYPTO_THREADID_current(id) | |||
| # define CRYPTO_THREADID_cmp(a, b) (-1) | |||
| # define CRYPTO_THREADID_cpy(dest, src) | |||
| # define CRYPTO_THREADID_hash(id) (0UL) | |||
| # if OPENSSL_API_COMPAT < 0x10000000L | |||
| # define CRYPTO_set_id_callback(func) | |||
| # define CRYPTO_get_id_callback() (NULL) | |||
| # define CRYPTO_thread_id() (0UL) | |||
| # endif /* OPENSSL_API_COMPAT < 0x10000000L */ | |||
| # define CRYPTO_set_dynlock_create_callback(dyn_create_function) | |||
| # define CRYPTO_set_dynlock_lock_callback(dyn_lock_function) | |||
| # define CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function) | |||
| # define CRYPTO_get_dynlock_create_callback() (NULL) | |||
| # define CRYPTO_get_dynlock_lock_callback() (NULL) | |||
| # define CRYPTO_get_dynlock_destroy_callback() (NULL) | |||
| # endif /* OPENSSL_API_COMPAT < 0x10100000L */ | |||
| int CRYPTO_set_mem_functions( | |||
| void *(*m) (size_t, const char *, int), | |||
| void *(*r) (void *, size_t, const char *, int), | |||
| void (*f) (void *, const char *, int)); | |||
| int CRYPTO_set_mem_debug(int flag); | |||
| void CRYPTO_get_mem_functions( | |||
| void *(**m) (size_t, const char *, int), | |||
| void *(**r) (void *, size_t, const char *, int), | |||
| void (**f) (void *, const char *, int)); | |||
| void *CRYPTO_malloc(size_t num, const char *file, int line); | |||
| void *CRYPTO_zalloc(size_t num, const char *file, int line); | |||
| void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line); | |||
| char *CRYPTO_strdup(const char *str, const char *file, int line); | |||
| char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line); | |||
| void CRYPTO_free(void *ptr, const char *file, int line); | |||
| void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line); | |||
| void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line); | |||
| void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num, | |||
| const char *file, int line); | |||
| int CRYPTO_secure_malloc_init(size_t sz, int minsize); | |||
| int CRYPTO_secure_malloc_done(void); | |||
| void *CRYPTO_secure_malloc(size_t num, const char *file, int line); | |||
| void *CRYPTO_secure_zalloc(size_t num, const char *file, int line); | |||
| void CRYPTO_secure_free(void *ptr, const char *file, int line); | |||
| void CRYPTO_secure_clear_free(void *ptr, size_t num, | |||
| const char *file, int line); | |||
| int CRYPTO_secure_allocated(const void *ptr); | |||
| int CRYPTO_secure_malloc_initialized(void); | |||
| size_t CRYPTO_secure_actual_size(void *ptr); | |||
| size_t CRYPTO_secure_used(void); | |||
| void OPENSSL_cleanse(void *ptr, size_t len); | |||
| # ifndef OPENSSL_NO_CRYPTO_MDEBUG | |||
| # define OPENSSL_mem_debug_push(info) \ | |||
| CRYPTO_mem_debug_push(info, OPENSSL_FILE, OPENSSL_LINE) | |||
| # define OPENSSL_mem_debug_pop() \ | |||
| CRYPTO_mem_debug_pop() | |||
| int CRYPTO_mem_debug_push(const char *info, const char *file, int line); | |||
| int CRYPTO_mem_debug_pop(void); | |||
| void CRYPTO_get_alloc_counts(int *mcount, int *rcount, int *fcount); | |||
| /*- | |||
| * Debugging functions (enabled by CRYPTO_set_mem_debug(1)) | |||
| * The flag argument has the following significance: | |||
| * 0: called before the actual memory allocation has taken place | |||
| * 1: called after the actual memory allocation has taken place | |||
| */ | |||
| void CRYPTO_mem_debug_malloc(void *addr, size_t num, int flag, | |||
| const char *file, int line); | |||
| void CRYPTO_mem_debug_realloc(void *addr1, void *addr2, size_t num, int flag, | |||
| const char *file, int line); | |||
| void CRYPTO_mem_debug_free(void *addr, int flag, | |||
| const char *file, int line); | |||
| int CRYPTO_mem_leaks_cb(int (*cb) (const char *str, size_t len, void *u), | |||
| void *u); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int CRYPTO_mem_leaks_fp(FILE *); | |||
| # endif | |||
| int CRYPTO_mem_leaks(BIO *bio); | |||
| # endif | |||
| /* die if we have to */ | |||
| ossl_noreturn void OPENSSL_die(const char *assertion, const char *file, int line); | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define OpenSSLDie(f,l,a) OPENSSL_die((a),(f),(l)) | |||
| # endif | |||
| # define OPENSSL_assert(e) \ | |||
| (void)((e) ? 0 : (OPENSSL_die("assertion failed: " #e, OPENSSL_FILE, OPENSSL_LINE), 1)) | |||
| int OPENSSL_isservice(void); | |||
| int FIPS_mode(void); | |||
| int FIPS_mode_set(int r); | |||
| void OPENSSL_init(void); | |||
| # ifdef OPENSSL_SYS_UNIX | |||
| void OPENSSL_fork_prepare(void); | |||
| void OPENSSL_fork_parent(void); | |||
| void OPENSSL_fork_child(void); | |||
| # endif | |||
| struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result); | |||
| int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec); | |||
| int OPENSSL_gmtime_diff(int *pday, int *psec, | |||
| const struct tm *from, const struct tm *to); | |||
| /* | |||
| * CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal. | |||
| * It takes an amount of time dependent on |len|, but independent of the | |||
| * contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements | |||
| * into a defined order as the return value when a != b is undefined, other | |||
| * than to be non-zero. | |||
| */ | |||
| int CRYPTO_memcmp(const void * in_a, const void * in_b, size_t len); | |||
| /* Standard initialisation options */ | |||
| # define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0x00000001L | |||
| # define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0x00000002L | |||
| # define OPENSSL_INIT_ADD_ALL_CIPHERS 0x00000004L | |||
| # define OPENSSL_INIT_ADD_ALL_DIGESTS 0x00000008L | |||
| # define OPENSSL_INIT_NO_ADD_ALL_CIPHERS 0x00000010L | |||
| # define OPENSSL_INIT_NO_ADD_ALL_DIGESTS 0x00000020L | |||
| # define OPENSSL_INIT_LOAD_CONFIG 0x00000040L | |||
| # define OPENSSL_INIT_NO_LOAD_CONFIG 0x00000080L | |||
| # define OPENSSL_INIT_ASYNC 0x00000100L | |||
| # define OPENSSL_INIT_ENGINE_RDRAND 0x00000200L | |||
| # define OPENSSL_INIT_ENGINE_DYNAMIC 0x00000400L | |||
| # define OPENSSL_INIT_ENGINE_OPENSSL 0x00000800L | |||
| # define OPENSSL_INIT_ENGINE_CRYPTODEV 0x00001000L | |||
| # define OPENSSL_INIT_ENGINE_CAPI 0x00002000L | |||
| # define OPENSSL_INIT_ENGINE_PADLOCK 0x00004000L | |||
| # define OPENSSL_INIT_ENGINE_AFALG 0x00008000L | |||
| /* OPENSSL_INIT_ZLIB 0x00010000L */ | |||
| # define OPENSSL_INIT_ATFORK 0x00020000L | |||
| /* OPENSSL_INIT_BASE_ONLY 0x00040000L */ | |||
| # define OPENSSL_INIT_NO_ATEXIT 0x00080000L | |||
| /* OPENSSL_INIT flag range 0xfff00000 reserved for OPENSSL_init_ssl() */ | |||
| /* Max OPENSSL_INIT flag value is 0x80000000 */ | |||
| /* openssl and dasync not counted as builtin */ | |||
| # define OPENSSL_INIT_ENGINE_ALL_BUILTIN \ | |||
| (OPENSSL_INIT_ENGINE_RDRAND | OPENSSL_INIT_ENGINE_DYNAMIC \ | |||
| | OPENSSL_INIT_ENGINE_CRYPTODEV | OPENSSL_INIT_ENGINE_CAPI | \ | |||
| OPENSSL_INIT_ENGINE_PADLOCK) | |||
| /* Library initialisation functions */ | |||
| void OPENSSL_cleanup(void); | |||
| int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings); | |||
| int OPENSSL_atexit(void (*handler)(void)); | |||
| void OPENSSL_thread_stop(void); | |||
| /* Low-level control of initialization */ | |||
| OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS *settings, | |||
| const char *config_filename); | |||
| void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS *settings, | |||
| unsigned long flags); | |||
| int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings, | |||
| const char *config_appname); | |||
| # endif | |||
| void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings); | |||
| # if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) | |||
| # if defined(_WIN32) | |||
| # if defined(BASETYPES) || defined(_WINDEF_H) | |||
| /* application has to include <windows.h> in order to use this */ | |||
| typedef DWORD CRYPTO_THREAD_LOCAL; | |||
| typedef DWORD CRYPTO_THREAD_ID; | |||
| typedef LONG CRYPTO_ONCE; | |||
| # define CRYPTO_ONCE_STATIC_INIT 0 | |||
| # endif | |||
| # else | |||
| # include <pthread.h> | |||
| typedef pthread_once_t CRYPTO_ONCE; | |||
| typedef pthread_key_t CRYPTO_THREAD_LOCAL; | |||
| typedef pthread_t CRYPTO_THREAD_ID; | |||
| # define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT | |||
| # endif | |||
| # endif | |||
| # if !defined(CRYPTO_ONCE_STATIC_INIT) | |||
| typedef unsigned int CRYPTO_ONCE; | |||
| typedef unsigned int CRYPTO_THREAD_LOCAL; | |||
| typedef unsigned int CRYPTO_THREAD_ID; | |||
| # define CRYPTO_ONCE_STATIC_INIT 0 | |||
| # endif | |||
| int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void)); | |||
| int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *)); | |||
| void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key); | |||
| int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val); | |||
| int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key); | |||
| CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void); | |||
| int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,57 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CRYPTOERR_H | |||
| # define HEADER_CRYPTOERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_CRYPTO_strings(void); | |||
| /* | |||
| * CRYPTO function codes. | |||
| */ | |||
| # define CRYPTO_F_CMAC_CTX_NEW 120 | |||
| # define CRYPTO_F_CRYPTO_DUP_EX_DATA 110 | |||
| # define CRYPTO_F_CRYPTO_FREE_EX_DATA 111 | |||
| # define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 100 | |||
| # define CRYPTO_F_CRYPTO_MEMDUP 115 | |||
| # define CRYPTO_F_CRYPTO_NEW_EX_DATA 112 | |||
| # define CRYPTO_F_CRYPTO_OCB128_COPY_CTX 121 | |||
| # define CRYPTO_F_CRYPTO_OCB128_INIT 122 | |||
| # define CRYPTO_F_CRYPTO_SET_EX_DATA 102 | |||
| # define CRYPTO_F_FIPS_MODE_SET 109 | |||
| # define CRYPTO_F_GET_AND_LOCK 113 | |||
| # define CRYPTO_F_OPENSSL_ATEXIT 114 | |||
| # define CRYPTO_F_OPENSSL_BUF2HEXSTR 117 | |||
| # define CRYPTO_F_OPENSSL_FOPEN 119 | |||
| # define CRYPTO_F_OPENSSL_HEXSTR2BUF 118 | |||
| # define CRYPTO_F_OPENSSL_INIT_CRYPTO 116 | |||
| # define CRYPTO_F_OPENSSL_LH_NEW 126 | |||
| # define CRYPTO_F_OPENSSL_SK_DEEP_COPY 127 | |||
| # define CRYPTO_F_OPENSSL_SK_DUP 128 | |||
| # define CRYPTO_F_PKEY_HMAC_INIT 123 | |||
| # define CRYPTO_F_PKEY_POLY1305_INIT 124 | |||
| # define CRYPTO_F_PKEY_SIPHASH_INIT 125 | |||
| # define CRYPTO_F_SK_RESERVE 129 | |||
| /* | |||
| * CRYPTO reason codes. | |||
| */ | |||
| # define CRYPTO_R_FIPS_MODE_NOT_SUPPORTED 101 | |||
| # define CRYPTO_R_ILLEGAL_HEX_DIGIT 102 | |||
| # define CRYPTO_R_ODD_NUMBER_OF_DIGITS 103 | |||
| #endif | |||
| @ -1,474 +0,0 @@ | |||
| /* | |||
| * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CT_H | |||
| # define HEADER_CT_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_CT | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/safestack.h> | |||
| # include <openssl/x509.h> | |||
| # include <openssl/cterr.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| /* Minimum RSA key size, from RFC6962 */ | |||
| # define SCT_MIN_RSA_BITS 2048 | |||
| /* All hashes are SHA256 in v1 of Certificate Transparency */ | |||
| # define CT_V1_HASHLEN SHA256_DIGEST_LENGTH | |||
| typedef enum { | |||
| CT_LOG_ENTRY_TYPE_NOT_SET = -1, | |||
| CT_LOG_ENTRY_TYPE_X509 = 0, | |||
| CT_LOG_ENTRY_TYPE_PRECERT = 1 | |||
| } ct_log_entry_type_t; | |||
| typedef enum { | |||
| SCT_VERSION_NOT_SET = -1, | |||
| SCT_VERSION_V1 = 0 | |||
| } sct_version_t; | |||
| typedef enum { | |||
| SCT_SOURCE_UNKNOWN, | |||
| SCT_SOURCE_TLS_EXTENSION, | |||
| SCT_SOURCE_X509V3_EXTENSION, | |||
| SCT_SOURCE_OCSP_STAPLED_RESPONSE | |||
| } sct_source_t; | |||
| typedef enum { | |||
| SCT_VALIDATION_STATUS_NOT_SET, | |||
| SCT_VALIDATION_STATUS_UNKNOWN_LOG, | |||
| SCT_VALIDATION_STATUS_VALID, | |||
| SCT_VALIDATION_STATUS_INVALID, | |||
| SCT_VALIDATION_STATUS_UNVERIFIED, | |||
| SCT_VALIDATION_STATUS_UNKNOWN_VERSION | |||
| } sct_validation_status_t; | |||
| DEFINE_STACK_OF(SCT) | |||
| DEFINE_STACK_OF(CTLOG) | |||
| /****************************************** | |||
| * CT policy evaluation context functions * | |||
| ******************************************/ | |||
| /* | |||
| * Creates a new, empty policy evaluation context. | |||
| * The caller is responsible for calling CT_POLICY_EVAL_CTX_free when finished | |||
| * with the CT_POLICY_EVAL_CTX. | |||
| */ | |||
| CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new(void); | |||
| /* Deletes a policy evaluation context and anything it owns. */ | |||
| void CT_POLICY_EVAL_CTX_free(CT_POLICY_EVAL_CTX *ctx); | |||
| /* Gets the peer certificate that the SCTs are for */ | |||
| X509* CT_POLICY_EVAL_CTX_get0_cert(const CT_POLICY_EVAL_CTX *ctx); | |||
| /* | |||
| * Sets the certificate associated with the received SCTs. | |||
| * Increments the reference count of cert. | |||
| * Returns 1 on success, 0 otherwise. | |||
| */ | |||
| int CT_POLICY_EVAL_CTX_set1_cert(CT_POLICY_EVAL_CTX *ctx, X509 *cert); | |||
| /* Gets the issuer of the aforementioned certificate */ | |||
| X509* CT_POLICY_EVAL_CTX_get0_issuer(const CT_POLICY_EVAL_CTX *ctx); | |||
| /* | |||
| * Sets the issuer of the certificate associated with the received SCTs. | |||
| * Increments the reference count of issuer. | |||
| * Returns 1 on success, 0 otherwise. | |||
| */ | |||
| int CT_POLICY_EVAL_CTX_set1_issuer(CT_POLICY_EVAL_CTX *ctx, X509 *issuer); | |||
| /* Gets the CT logs that are trusted sources of SCTs */ | |||
| const CTLOG_STORE *CT_POLICY_EVAL_CTX_get0_log_store(const CT_POLICY_EVAL_CTX *ctx); | |||
| /* Sets the log store that is in use. It must outlive the CT_POLICY_EVAL_CTX. */ | |||
| void CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(CT_POLICY_EVAL_CTX *ctx, | |||
| CTLOG_STORE *log_store); | |||
| /* | |||
| * Gets the time, in milliseconds since the Unix epoch, that will be used as the | |||
| * current time when checking whether an SCT was issued in the future. | |||
| * Such SCTs will fail validation, as required by RFC6962. | |||
| */ | |||
| uint64_t CT_POLICY_EVAL_CTX_get_time(const CT_POLICY_EVAL_CTX *ctx); | |||
| /* | |||
| * Sets the time to evaluate SCTs against, in milliseconds since the Unix epoch. | |||
| * If an SCT's timestamp is after this time, it will be interpreted as having | |||
| * been issued in the future. RFC6962 states that "TLS clients MUST reject SCTs | |||
| * whose timestamp is in the future", so an SCT will not validate in this case. | |||
| */ | |||
| void CT_POLICY_EVAL_CTX_set_time(CT_POLICY_EVAL_CTX *ctx, uint64_t time_in_ms); | |||
| /***************** | |||
| * SCT functions * | |||
| *****************/ | |||
| /* | |||
| * Creates a new, blank SCT. | |||
| * The caller is responsible for calling SCT_free when finished with the SCT. | |||
| */ | |||
| SCT *SCT_new(void); | |||
| /* | |||
| * Creates a new SCT from some base64-encoded strings. | |||
| * The caller is responsible for calling SCT_free when finished with the SCT. | |||
| */ | |||
| SCT *SCT_new_from_base64(unsigned char version, | |||
| const char *logid_base64, | |||
| ct_log_entry_type_t entry_type, | |||
| uint64_t timestamp, | |||
| const char *extensions_base64, | |||
| const char *signature_base64); | |||
| /* | |||
| * Frees the SCT and the underlying data structures. | |||
| */ | |||
| void SCT_free(SCT *sct); | |||
| /* | |||
| * Free a stack of SCTs, and the underlying SCTs themselves. | |||
| * Intended to be compatible with X509V3_EXT_FREE. | |||
| */ | |||
| void SCT_LIST_free(STACK_OF(SCT) *a); | |||
| /* | |||
| * Returns the version of the SCT. | |||
| */ | |||
| sct_version_t SCT_get_version(const SCT *sct); | |||
| /* | |||
| * Set the version of an SCT. | |||
| * Returns 1 on success, 0 if the version is unrecognized. | |||
| */ | |||
| __owur int SCT_set_version(SCT *sct, sct_version_t version); | |||
| /* | |||
| * Returns the log entry type of the SCT. | |||
| */ | |||
| ct_log_entry_type_t SCT_get_log_entry_type(const SCT *sct); | |||
| /* | |||
| * Set the log entry type of an SCT. | |||
| * Returns 1 on success, 0 otherwise. | |||
| */ | |||
| __owur int SCT_set_log_entry_type(SCT *sct, ct_log_entry_type_t entry_type); | |||
| /* | |||
| * Gets the ID of the log that an SCT came from. | |||
| * Ownership of the log ID remains with the SCT. | |||
| * Returns the length of the log ID. | |||
| */ | |||
| size_t SCT_get0_log_id(const SCT *sct, unsigned char **log_id); | |||
| /* | |||
| * Set the log ID of an SCT to point directly to the *log_id specified. | |||
| * The SCT takes ownership of the specified pointer. | |||
| * Returns 1 on success, 0 otherwise. | |||
| */ | |||
| __owur int SCT_set0_log_id(SCT *sct, unsigned char *log_id, size_t log_id_len); | |||
| /* | |||
| * Set the log ID of an SCT. | |||
| * This makes a copy of the log_id. | |||
| * Returns 1 on success, 0 otherwise. | |||
| */ | |||
| __owur int SCT_set1_log_id(SCT *sct, const unsigned char *log_id, | |||
| size_t log_id_len); | |||
| /* | |||
| * Returns the timestamp for the SCT (epoch time in milliseconds). | |||
| */ | |||
| uint64_t SCT_get_timestamp(const SCT *sct); | |||
| /* | |||
| * Set the timestamp of an SCT (epoch time in milliseconds). | |||
| */ | |||
| void SCT_set_timestamp(SCT *sct, uint64_t timestamp); | |||
| /* | |||
| * Return the NID for the signature used by the SCT. | |||
| * For CT v1, this will be either NID_sha256WithRSAEncryption or | |||
| * NID_ecdsa_with_SHA256 (or NID_undef if incorrect/unset). | |||
| */ | |||
| int SCT_get_signature_nid(const SCT *sct); | |||
| /* | |||
| * Set the signature type of an SCT | |||
| * For CT v1, this should be either NID_sha256WithRSAEncryption or | |||
| * NID_ecdsa_with_SHA256. | |||
| * Returns 1 on success, 0 otherwise. | |||
| */ | |||
| __owur int SCT_set_signature_nid(SCT *sct, int nid); | |||
| /* | |||
| * Set *ext to point to the extension data for the SCT. ext must not be NULL. | |||
| * The SCT retains ownership of this pointer. | |||
| * Returns length of the data pointed to. | |||
| */ | |||
| size_t SCT_get0_extensions(const SCT *sct, unsigned char **ext); | |||
| /* | |||
| * Set the extensions of an SCT to point directly to the *ext specified. | |||
| * The SCT takes ownership of the specified pointer. | |||
| */ | |||
| void SCT_set0_extensions(SCT *sct, unsigned char *ext, size_t ext_len); | |||
| /* | |||
| * Set the extensions of an SCT. | |||
| * This takes a copy of the ext. | |||
| * Returns 1 on success, 0 otherwise. | |||
| */ | |||
| __owur int SCT_set1_extensions(SCT *sct, const unsigned char *ext, | |||
| size_t ext_len); | |||
| /* | |||
| * Set *sig to point to the signature for the SCT. sig must not be NULL. | |||
| * The SCT retains ownership of this pointer. | |||
| * Returns length of the data pointed to. | |||
| */ | |||
| size_t SCT_get0_signature(const SCT *sct, unsigned char **sig); | |||
| /* | |||
| * Set the signature of an SCT to point directly to the *sig specified. | |||
| * The SCT takes ownership of the specified pointer. | |||
| */ | |||
| void SCT_set0_signature(SCT *sct, unsigned char *sig, size_t sig_len); | |||
| /* | |||
| * Set the signature of an SCT to be a copy of the *sig specified. | |||
| * Returns 1 on success, 0 otherwise. | |||
| */ | |||
| __owur int SCT_set1_signature(SCT *sct, const unsigned char *sig, | |||
| size_t sig_len); | |||
| /* | |||
| * The origin of this SCT, e.g. TLS extension, OCSP response, etc. | |||
| */ | |||
| sct_source_t SCT_get_source(const SCT *sct); | |||
| /* | |||
| * Set the origin of this SCT, e.g. TLS extension, OCSP response, etc. | |||
| * Returns 1 on success, 0 otherwise. | |||
| */ | |||
| __owur int SCT_set_source(SCT *sct, sct_source_t source); | |||
| /* | |||
| * Returns a text string describing the validation status of |sct|. | |||
| */ | |||
| const char *SCT_validation_status_string(const SCT *sct); | |||
| /* | |||
| * Pretty-prints an |sct| to |out|. | |||
| * It will be indented by the number of spaces specified by |indent|. | |||
| * If |logs| is not NULL, it will be used to lookup the CT log that the SCT came | |||
| * from, so that the log name can be printed. | |||
| */ | |||
| void SCT_print(const SCT *sct, BIO *out, int indent, const CTLOG_STORE *logs); | |||
| /* | |||
| * Pretty-prints an |sct_list| to |out|. | |||
| * It will be indented by the number of spaces specified by |indent|. | |||
| * SCTs will be delimited by |separator|. | |||
| * If |logs| is not NULL, it will be used to lookup the CT log that each SCT | |||
| * came from, so that the log names can be printed. | |||
| */ | |||
| void SCT_LIST_print(const STACK_OF(SCT) *sct_list, BIO *out, int indent, | |||
| const char *separator, const CTLOG_STORE *logs); | |||
| /* | |||
| * Gets the last result of validating this SCT. | |||
| * If it has not been validated yet, returns SCT_VALIDATION_STATUS_NOT_SET. | |||
| */ | |||
| sct_validation_status_t SCT_get_validation_status(const SCT *sct); | |||
| /* | |||
| * Validates the given SCT with the provided context. | |||
| * Sets the "validation_status" field of the SCT. | |||
| * Returns 1 if the SCT is valid and the signature verifies. | |||
| * Returns 0 if the SCT is invalid or could not be verified. | |||
| * Returns -1 if an error occurs. | |||
| */ | |||
| __owur int SCT_validate(SCT *sct, const CT_POLICY_EVAL_CTX *ctx); | |||
| /* | |||
| * Validates the given list of SCTs with the provided context. | |||
| * Sets the "validation_status" field of each SCT. | |||
| * Returns 1 if there are no invalid SCTs and all signatures verify. | |||
| * Returns 0 if at least one SCT is invalid or could not be verified. | |||
| * Returns a negative integer if an error occurs. | |||
| */ | |||
| __owur int SCT_LIST_validate(const STACK_OF(SCT) *scts, | |||
| CT_POLICY_EVAL_CTX *ctx); | |||
| /********************************* | |||
| * SCT parsing and serialisation * | |||
| *********************************/ | |||
| /* | |||
| * Serialize (to TLS format) a stack of SCTs and return the length. | |||
| * "a" must not be NULL. | |||
| * If "pp" is NULL, just return the length of what would have been serialized. | |||
| * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer | |||
| * for data that caller is responsible for freeing (only if function returns | |||
| * successfully). | |||
| * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring | |||
| * that "*pp" is large enough to accept all of the serialized data. | |||
| * Returns < 0 on error, >= 0 indicating bytes written (or would have been) | |||
| * on success. | |||
| */ | |||
| __owur int i2o_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp); | |||
| /* | |||
| * Convert TLS format SCT list to a stack of SCTs. | |||
| * If "a" or "*a" is NULL, a new stack will be created that the caller is | |||
| * responsible for freeing (by calling SCT_LIST_free). | |||
| * "**pp" and "*pp" must not be NULL. | |||
| * Upon success, "*pp" will point to after the last bytes read, and a stack | |||
| * will be returned. | |||
| * Upon failure, a NULL pointer will be returned, and the position of "*pp" is | |||
| * not defined. | |||
| */ | |||
| STACK_OF(SCT) *o2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp, | |||
| size_t len); | |||
| /* | |||
| * Serialize (to DER format) a stack of SCTs and return the length. | |||
| * "a" must not be NULL. | |||
| * If "pp" is NULL, just returns the length of what would have been serialized. | |||
| * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer | |||
| * for data that caller is responsible for freeing (only if function returns | |||
| * successfully). | |||
| * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring | |||
| * that "*pp" is large enough to accept all of the serialized data. | |||
| * Returns < 0 on error, >= 0 indicating bytes written (or would have been) | |||
| * on success. | |||
| */ | |||
| __owur int i2d_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp); | |||
| /* | |||
| * Parses an SCT list in DER format and returns it. | |||
| * If "a" or "*a" is NULL, a new stack will be created that the caller is | |||
| * responsible for freeing (by calling SCT_LIST_free). | |||
| * "**pp" and "*pp" must not be NULL. | |||
| * Upon success, "*pp" will point to after the last bytes read, and a stack | |||
| * will be returned. | |||
| * Upon failure, a NULL pointer will be returned, and the position of "*pp" is | |||
| * not defined. | |||
| */ | |||
| STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp, | |||
| long len); | |||
| /* | |||
| * Serialize (to TLS format) an |sct| and write it to |out|. | |||
| * If |out| is null, no SCT will be output but the length will still be returned. | |||
| * If |out| points to a null pointer, a string will be allocated to hold the | |||
| * TLS-format SCT. It is the responsibility of the caller to free it. | |||
| * If |out| points to an allocated string, the TLS-format SCT will be written | |||
| * to it. | |||
| * The length of the SCT in TLS format will be returned. | |||
| */ | |||
| __owur int i2o_SCT(const SCT *sct, unsigned char **out); | |||
| /* | |||
| * Parses an SCT in TLS format and returns it. | |||
| * If |psct| is not null, it will end up pointing to the parsed SCT. If it | |||
| * already points to a non-null pointer, the pointer will be free'd. | |||
| * |in| should be a pointer to a string containing the TLS-format SCT. | |||
| * |in| will be advanced to the end of the SCT if parsing succeeds. | |||
| * |len| should be the length of the SCT in |in|. | |||
| * Returns NULL if an error occurs. | |||
| * If the SCT is an unsupported version, only the SCT's 'sct' and 'sct_len' | |||
| * fields will be populated (with |in| and |len| respectively). | |||
| */ | |||
| SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len); | |||
| /******************** | |||
| * CT log functions * | |||
| ********************/ | |||
| /* | |||
| * Creates a new CT log instance with the given |public_key| and |name|. | |||
| * Takes ownership of |public_key| but copies |name|. | |||
| * Returns NULL if malloc fails or if |public_key| cannot be converted to DER. | |||
| * Should be deleted by the caller using CTLOG_free when no longer needed. | |||
| */ | |||
| CTLOG *CTLOG_new(EVP_PKEY *public_key, const char *name); | |||
| /* | |||
| * Creates a new CTLOG instance with the base64-encoded SubjectPublicKeyInfo DER | |||
| * in |pkey_base64|. The |name| is a string to help users identify this log. | |||
| * Returns 1 on success, 0 on failure. | |||
| * Should be deleted by the caller using CTLOG_free when no longer needed. | |||
| */ | |||
| int CTLOG_new_from_base64(CTLOG ** ct_log, | |||
| const char *pkey_base64, const char *name); | |||
| /* | |||
| * Deletes a CT log instance and its fields. | |||
| */ | |||
| void CTLOG_free(CTLOG *log); | |||
| /* Gets the name of the CT log */ | |||
| const char *CTLOG_get0_name(const CTLOG *log); | |||
| /* Gets the ID of the CT log */ | |||
| void CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id, | |||
| size_t *log_id_len); | |||
| /* Gets the public key of the CT log */ | |||
| EVP_PKEY *CTLOG_get0_public_key(const CTLOG *log); | |||
| /************************** | |||
| * CT log store functions * | |||
| **************************/ | |||
| /* | |||
| * Creates a new CT log store. | |||
| * Should be deleted by the caller using CTLOG_STORE_free when no longer needed. | |||
| */ | |||
| CTLOG_STORE *CTLOG_STORE_new(void); | |||
| /* | |||
| * Deletes a CT log store and all of the CT log instances held within. | |||
| */ | |||
| void CTLOG_STORE_free(CTLOG_STORE *store); | |||
| /* | |||
| * Finds a CT log in the store based on its log ID. | |||
| * Returns the CT log, or NULL if no match is found. | |||
| */ | |||
| const CTLOG *CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store, | |||
| const uint8_t *log_id, | |||
| size_t log_id_len); | |||
| /* | |||
| * Loads a CT log list into a |store| from a |file|. | |||
| * Returns 1 if loading is successful, or 0 otherwise. | |||
| */ | |||
| __owur int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file); | |||
| /* | |||
| * Loads the default CT log list into a |store|. | |||
| * Returns 1 if loading is successful, or 0 otherwise. | |||
| */ | |||
| __owur int CTLOG_STORE_load_default_file(CTLOG_STORE *store); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,80 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_CTERR_H | |||
| # define HEADER_CTERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_CT | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_CT_strings(void); | |||
| /* | |||
| * CT function codes. | |||
| */ | |||
| # define CT_F_CTLOG_NEW 117 | |||
| # define CT_F_CTLOG_NEW_FROM_BASE64 118 | |||
| # define CT_F_CTLOG_NEW_FROM_CONF 119 | |||
| # define CT_F_CTLOG_STORE_LOAD_CTX_NEW 122 | |||
| # define CT_F_CTLOG_STORE_LOAD_FILE 123 | |||
| # define CT_F_CTLOG_STORE_LOAD_LOG 130 | |||
| # define CT_F_CTLOG_STORE_NEW 131 | |||
| # define CT_F_CT_BASE64_DECODE 124 | |||
| # define CT_F_CT_POLICY_EVAL_CTX_NEW 133 | |||
| # define CT_F_CT_V1_LOG_ID_FROM_PKEY 125 | |||
| # define CT_F_I2O_SCT 107 | |||
| # define CT_F_I2O_SCT_LIST 108 | |||
| # define CT_F_I2O_SCT_SIGNATURE 109 | |||
| # define CT_F_O2I_SCT 110 | |||
| # define CT_F_O2I_SCT_LIST 111 | |||
| # define CT_F_O2I_SCT_SIGNATURE 112 | |||
| # define CT_F_SCT_CTX_NEW 126 | |||
| # define CT_F_SCT_CTX_VERIFY 128 | |||
| # define CT_F_SCT_NEW 100 | |||
| # define CT_F_SCT_NEW_FROM_BASE64 127 | |||
| # define CT_F_SCT_SET0_LOG_ID 101 | |||
| # define CT_F_SCT_SET1_EXTENSIONS 114 | |||
| # define CT_F_SCT_SET1_LOG_ID 115 | |||
| # define CT_F_SCT_SET1_SIGNATURE 116 | |||
| # define CT_F_SCT_SET_LOG_ENTRY_TYPE 102 | |||
| # define CT_F_SCT_SET_SIGNATURE_NID 103 | |||
| # define CT_F_SCT_SET_VERSION 104 | |||
| /* | |||
| * CT reason codes. | |||
| */ | |||
| # define CT_R_BASE64_DECODE_ERROR 108 | |||
| # define CT_R_INVALID_LOG_ID_LENGTH 100 | |||
| # define CT_R_LOG_CONF_INVALID 109 | |||
| # define CT_R_LOG_CONF_INVALID_KEY 110 | |||
| # define CT_R_LOG_CONF_MISSING_DESCRIPTION 111 | |||
| # define CT_R_LOG_CONF_MISSING_KEY 112 | |||
| # define CT_R_LOG_KEY_INVALID 113 | |||
| # define CT_R_SCT_FUTURE_TIMESTAMP 116 | |||
| # define CT_R_SCT_INVALID 104 | |||
| # define CT_R_SCT_INVALID_SIGNATURE 107 | |||
| # define CT_R_SCT_LIST_INVALID 105 | |||
| # define CT_R_SCT_LOG_ID_MISMATCH 114 | |||
| # define CT_R_SCT_NOT_SET 106 | |||
| # define CT_R_SCT_UNSUPPORTED_VERSION 115 | |||
| # define CT_R_UNRECOGNIZED_SIGNATURE_NID 101 | |||
| # define CT_R_UNSUPPORTED_ENTRY_TYPE 102 | |||
| # define CT_R_UNSUPPORTED_VERSION 103 | |||
| # endif | |||
| #endif | |||
| @ -1,174 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_DES_H | |||
| # define HEADER_DES_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_DES | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| # include <openssl/e_os2.h> | |||
| typedef unsigned int DES_LONG; | |||
| # ifdef OPENSSL_BUILD_SHLIBCRYPTO | |||
| # undef OPENSSL_EXTERN | |||
| # define OPENSSL_EXTERN OPENSSL_EXPORT | |||
| # endif | |||
| typedef unsigned char DES_cblock[8]; | |||
| typedef /* const */ unsigned char const_DES_cblock[8]; | |||
| /* | |||
| * With "const", gcc 2.8.1 on Solaris thinks that DES_cblock * and | |||
| * const_DES_cblock * are incompatible pointer types. | |||
| */ | |||
| typedef struct DES_ks { | |||
| union { | |||
| DES_cblock cblock; | |||
| /* | |||
| * make sure things are correct size on machines with 8 byte longs | |||
| */ | |||
| DES_LONG deslong[2]; | |||
| } ks[16]; | |||
| } DES_key_schedule; | |||
| # define DES_KEY_SZ (sizeof(DES_cblock)) | |||
| # define DES_SCHEDULE_SZ (sizeof(DES_key_schedule)) | |||
| # define DES_ENCRYPT 1 | |||
| # define DES_DECRYPT 0 | |||
| # define DES_CBC_MODE 0 | |||
| # define DES_PCBC_MODE 1 | |||
| # define DES_ecb2_encrypt(i,o,k1,k2,e) \ | |||
| DES_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e)) | |||
| # define DES_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \ | |||
| DES_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e)) | |||
| # define DES_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \ | |||
| DES_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e)) | |||
| # define DES_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \ | |||
| DES_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n)) | |||
| OPENSSL_DECLARE_GLOBAL(int, DES_check_key); /* defaults to false */ | |||
| # define DES_check_key OPENSSL_GLOBAL_REF(DES_check_key) | |||
| const char *DES_options(void); | |||
| void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output, | |||
| DES_key_schedule *ks1, DES_key_schedule *ks2, | |||
| DES_key_schedule *ks3, int enc); | |||
| DES_LONG DES_cbc_cksum(const unsigned char *input, DES_cblock *output, | |||
| long length, DES_key_schedule *schedule, | |||
| const_DES_cblock *ivec); | |||
| /* DES_cbc_encrypt does not update the IV! Use DES_ncbc_encrypt instead. */ | |||
| void DES_cbc_encrypt(const unsigned char *input, unsigned char *output, | |||
| long length, DES_key_schedule *schedule, | |||
| DES_cblock *ivec, int enc); | |||
| void DES_ncbc_encrypt(const unsigned char *input, unsigned char *output, | |||
| long length, DES_key_schedule *schedule, | |||
| DES_cblock *ivec, int enc); | |||
| void DES_xcbc_encrypt(const unsigned char *input, unsigned char *output, | |||
| long length, DES_key_schedule *schedule, | |||
| DES_cblock *ivec, const_DES_cblock *inw, | |||
| const_DES_cblock *outw, int enc); | |||
| void DES_cfb_encrypt(const unsigned char *in, unsigned char *out, int numbits, | |||
| long length, DES_key_schedule *schedule, | |||
| DES_cblock *ivec, int enc); | |||
| void DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output, | |||
| DES_key_schedule *ks, int enc); | |||
| /* | |||
| * This is the DES encryption function that gets called by just about every | |||
| * other DES routine in the library. You should not use this function except | |||
| * to implement 'modes' of DES. I say this because the functions that call | |||
| * this routine do the conversion from 'char *' to long, and this needs to be | |||
| * done to make sure 'non-aligned' memory access do not occur. The | |||
| * characters are loaded 'little endian'. Data is a pointer to 2 unsigned | |||
| * long's and ks is the DES_key_schedule to use. enc, is non zero specifies | |||
| * encryption, zero if decryption. | |||
| */ | |||
| void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc); | |||
| /* | |||
| * This functions is the same as DES_encrypt1() except that the DES initial | |||
| * permutation (IP) and final permutation (FP) have been left out. As for | |||
| * DES_encrypt1(), you should not use this function. It is used by the | |||
| * routines in the library that implement triple DES. IP() DES_encrypt2() | |||
| * DES_encrypt2() DES_encrypt2() FP() is the same as DES_encrypt1() | |||
| * DES_encrypt1() DES_encrypt1() except faster :-). | |||
| */ | |||
| void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc); | |||
| void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1, | |||
| DES_key_schedule *ks2, DES_key_schedule *ks3); | |||
| void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1, | |||
| DES_key_schedule *ks2, DES_key_schedule *ks3); | |||
| void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output, | |||
| long length, | |||
| DES_key_schedule *ks1, DES_key_schedule *ks2, | |||
| DES_key_schedule *ks3, DES_cblock *ivec, int enc); | |||
| void DES_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, DES_key_schedule *ks1, | |||
| DES_key_schedule *ks2, DES_key_schedule *ks3, | |||
| DES_cblock *ivec, int *num, int enc); | |||
| void DES_ede3_cfb_encrypt(const unsigned char *in, unsigned char *out, | |||
| int numbits, long length, DES_key_schedule *ks1, | |||
| DES_key_schedule *ks2, DES_key_schedule *ks3, | |||
| DES_cblock *ivec, int enc); | |||
| void DES_ede3_ofb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, DES_key_schedule *ks1, | |||
| DES_key_schedule *ks2, DES_key_schedule *ks3, | |||
| DES_cblock *ivec, int *num); | |||
| char *DES_fcrypt(const char *buf, const char *salt, char *ret); | |||
| char *DES_crypt(const char *buf, const char *salt); | |||
| void DES_ofb_encrypt(const unsigned char *in, unsigned char *out, int numbits, | |||
| long length, DES_key_schedule *schedule, | |||
| DES_cblock *ivec); | |||
| void DES_pcbc_encrypt(const unsigned char *input, unsigned char *output, | |||
| long length, DES_key_schedule *schedule, | |||
| DES_cblock *ivec, int enc); | |||
| DES_LONG DES_quad_cksum(const unsigned char *input, DES_cblock output[], | |||
| long length, int out_count, DES_cblock *seed); | |||
| int DES_random_key(DES_cblock *ret); | |||
| void DES_set_odd_parity(DES_cblock *key); | |||
| int DES_check_key_parity(const_DES_cblock *key); | |||
| int DES_is_weak_key(const_DES_cblock *key); | |||
| /* | |||
| * DES_set_key (= set_key = DES_key_sched = key_sched) calls | |||
| * DES_set_key_checked if global variable DES_check_key is set, | |||
| * DES_set_key_unchecked otherwise. | |||
| */ | |||
| int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule); | |||
| int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule); | |||
| int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule); | |||
| void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule); | |||
| void DES_string_to_key(const char *str, DES_cblock *key); | |||
| void DES_string_to_2keys(const char *str, DES_cblock *key1, DES_cblock *key2); | |||
| void DES_cfb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, DES_key_schedule *schedule, | |||
| DES_cblock *ivec, int *num, int enc); | |||
| void DES_ofb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, DES_key_schedule *schedule, | |||
| DES_cblock *ivec, int *num); | |||
| # define DES_fixup_key_parity DES_set_odd_parity | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,340 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_DH_H | |||
| # define HEADER_DH_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_DH | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/bio.h> | |||
| # include <openssl/asn1.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # include <openssl/bn.h> | |||
| # endif | |||
| # include <openssl/dherr.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| # ifndef OPENSSL_DH_MAX_MODULUS_BITS | |||
| # define OPENSSL_DH_MAX_MODULUS_BITS 10000 | |||
| # endif | |||
| # define OPENSSL_DH_FIPS_MIN_MODULUS_BITS 1024 | |||
| # define DH_FLAG_CACHE_MONT_P 0x01 | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| /* | |||
| * Does nothing. Previously this switched off constant time behaviour. | |||
| */ | |||
| # define DH_FLAG_NO_EXP_CONSTTIME 0x00 | |||
| # endif | |||
| /* | |||
| * If this flag is set the DH method is FIPS compliant and can be used in | |||
| * FIPS mode. This is set in the validated module method. If an application | |||
| * sets this flag in its own methods it is its responsibility to ensure the | |||
| * result is compliant. | |||
| */ | |||
| # define DH_FLAG_FIPS_METHOD 0x0400 | |||
| /* | |||
| * If this flag is set the operations normally disabled in FIPS mode are | |||
| * permitted it is then the applications responsibility to ensure that the | |||
| * usage is compliant. | |||
| */ | |||
| # define DH_FLAG_NON_FIPS_ALLOW 0x0400 | |||
| /* Already defined in ossl_typ.h */ | |||
| /* typedef struct dh_st DH; */ | |||
| /* typedef struct dh_method DH_METHOD; */ | |||
| DECLARE_ASN1_ITEM(DHparams) | |||
| # define DH_GENERATOR_2 2 | |||
| /* #define DH_GENERATOR_3 3 */ | |||
| # define DH_GENERATOR_5 5 | |||
| /* DH_check error codes */ | |||
| # define DH_CHECK_P_NOT_PRIME 0x01 | |||
| # define DH_CHECK_P_NOT_SAFE_PRIME 0x02 | |||
| # define DH_UNABLE_TO_CHECK_GENERATOR 0x04 | |||
| # define DH_NOT_SUITABLE_GENERATOR 0x08 | |||
| # define DH_CHECK_Q_NOT_PRIME 0x10 | |||
| # define DH_CHECK_INVALID_Q_VALUE 0x20 | |||
| # define DH_CHECK_INVALID_J_VALUE 0x40 | |||
| /* DH_check_pub_key error codes */ | |||
| # define DH_CHECK_PUBKEY_TOO_SMALL 0x01 | |||
| # define DH_CHECK_PUBKEY_TOO_LARGE 0x02 | |||
| # define DH_CHECK_PUBKEY_INVALID 0x04 | |||
| /* | |||
| * primes p where (p-1)/2 is prime too are called "safe"; we define this for | |||
| * backward compatibility: | |||
| */ | |||
| # define DH_CHECK_P_NOT_STRONG_PRIME DH_CHECK_P_NOT_SAFE_PRIME | |||
| # define d2i_DHparams_fp(fp,x) \ | |||
| (DH *)ASN1_d2i_fp((char *(*)())DH_new, \ | |||
| (char *(*)())d2i_DHparams, \ | |||
| (fp), \ | |||
| (unsigned char **)(x)) | |||
| # define i2d_DHparams_fp(fp,x) \ | |||
| ASN1_i2d_fp(i2d_DHparams,(fp), (unsigned char *)(x)) | |||
| # define d2i_DHparams_bio(bp,x) \ | |||
| ASN1_d2i_bio_of(DH, DH_new, d2i_DHparams, bp, x) | |||
| # define i2d_DHparams_bio(bp,x) \ | |||
| ASN1_i2d_bio_of_const(DH,i2d_DHparams,bp,x) | |||
| # define d2i_DHxparams_fp(fp,x) \ | |||
| (DH *)ASN1_d2i_fp((char *(*)())DH_new, \ | |||
| (char *(*)())d2i_DHxparams, \ | |||
| (fp), \ | |||
| (unsigned char **)(x)) | |||
| # define i2d_DHxparams_fp(fp,x) \ | |||
| ASN1_i2d_fp(i2d_DHxparams,(fp), (unsigned char *)(x)) | |||
| # define d2i_DHxparams_bio(bp,x) \ | |||
| ASN1_d2i_bio_of(DH, DH_new, d2i_DHxparams, bp, x) | |||
| # define i2d_DHxparams_bio(bp,x) \ | |||
| ASN1_i2d_bio_of_const(DH, i2d_DHxparams, bp, x) | |||
| DH *DHparams_dup(DH *); | |||
| const DH_METHOD *DH_OpenSSL(void); | |||
| void DH_set_default_method(const DH_METHOD *meth); | |||
| const DH_METHOD *DH_get_default_method(void); | |||
| int DH_set_method(DH *dh, const DH_METHOD *meth); | |||
| DH *DH_new_method(ENGINE *engine); | |||
| DH *DH_new(void); | |||
| void DH_free(DH *dh); | |||
| int DH_up_ref(DH *dh); | |||
| int DH_bits(const DH *dh); | |||
| int DH_size(const DH *dh); | |||
| int DH_security_bits(const DH *dh); | |||
| #define DH_get_ex_new_index(l, p, newf, dupf, freef) \ | |||
| CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DH, l, p, newf, dupf, freef) | |||
| int DH_set_ex_data(DH *d, int idx, void *arg); | |||
| void *DH_get_ex_data(DH *d, int idx); | |||
| /* Deprecated version */ | |||
| DEPRECATEDIN_0_9_8(DH *DH_generate_parameters(int prime_len, int generator, | |||
| void (*callback) (int, int, | |||
| void *), | |||
| void *cb_arg)) | |||
| /* New version */ | |||
| int DH_generate_parameters_ex(DH *dh, int prime_len, int generator, | |||
| BN_GENCB *cb); | |||
| int DH_check_params_ex(const DH *dh); | |||
| int DH_check_ex(const DH *dh); | |||
| int DH_check_pub_key_ex(const DH *dh, const BIGNUM *pub_key); | |||
| int DH_check_params(const DH *dh, int *ret); | |||
| int DH_check(const DH *dh, int *codes); | |||
| int DH_check_pub_key(const DH *dh, const BIGNUM *pub_key, int *codes); | |||
| int DH_generate_key(DH *dh); | |||
| int DH_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh); | |||
| int DH_compute_key_padded(unsigned char *key, const BIGNUM *pub_key, DH *dh); | |||
| DH *d2i_DHparams(DH **a, const unsigned char **pp, long length); | |||
| int i2d_DHparams(const DH *a, unsigned char **pp); | |||
| DH *d2i_DHxparams(DH **a, const unsigned char **pp, long length); | |||
| int i2d_DHxparams(const DH *a, unsigned char **pp); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int DHparams_print_fp(FILE *fp, const DH *x); | |||
| # endif | |||
| int DHparams_print(BIO *bp, const DH *x); | |||
| /* RFC 5114 parameters */ | |||
| DH *DH_get_1024_160(void); | |||
| DH *DH_get_2048_224(void); | |||
| DH *DH_get_2048_256(void); | |||
| /* Named parameters, currently RFC7919 */ | |||
| DH *DH_new_by_nid(int nid); | |||
| int DH_get_nid(const DH *dh); | |||
| # ifndef OPENSSL_NO_CMS | |||
| /* RFC2631 KDF */ | |||
| int DH_KDF_X9_42(unsigned char *out, size_t outlen, | |||
| const unsigned char *Z, size_t Zlen, | |||
| ASN1_OBJECT *key_oid, | |||
| const unsigned char *ukm, size_t ukmlen, const EVP_MD *md); | |||
| # endif | |||
| void DH_get0_pqg(const DH *dh, | |||
| const BIGNUM **p, const BIGNUM **q, const BIGNUM **g); | |||
| int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g); | |||
| void DH_get0_key(const DH *dh, | |||
| const BIGNUM **pub_key, const BIGNUM **priv_key); | |||
| int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key); | |||
| const BIGNUM *DH_get0_p(const DH *dh); | |||
| const BIGNUM *DH_get0_q(const DH *dh); | |||
| const BIGNUM *DH_get0_g(const DH *dh); | |||
| const BIGNUM *DH_get0_priv_key(const DH *dh); | |||
| const BIGNUM *DH_get0_pub_key(const DH *dh); | |||
| void DH_clear_flags(DH *dh, int flags); | |||
| int DH_test_flags(const DH *dh, int flags); | |||
| void DH_set_flags(DH *dh, int flags); | |||
| ENGINE *DH_get0_engine(DH *d); | |||
| long DH_get_length(const DH *dh); | |||
| int DH_set_length(DH *dh, long length); | |||
| DH_METHOD *DH_meth_new(const char *name, int flags); | |||
| void DH_meth_free(DH_METHOD *dhm); | |||
| DH_METHOD *DH_meth_dup(const DH_METHOD *dhm); | |||
| const char *DH_meth_get0_name(const DH_METHOD *dhm); | |||
| int DH_meth_set1_name(DH_METHOD *dhm, const char *name); | |||
| int DH_meth_get_flags(const DH_METHOD *dhm); | |||
| int DH_meth_set_flags(DH_METHOD *dhm, int flags); | |||
| void *DH_meth_get0_app_data(const DH_METHOD *dhm); | |||
| int DH_meth_set0_app_data(DH_METHOD *dhm, void *app_data); | |||
| int (*DH_meth_get_generate_key(const DH_METHOD *dhm)) (DH *); | |||
| int DH_meth_set_generate_key(DH_METHOD *dhm, int (*generate_key) (DH *)); | |||
| int (*DH_meth_get_compute_key(const DH_METHOD *dhm)) | |||
| (unsigned char *key, const BIGNUM *pub_key, DH *dh); | |||
| int DH_meth_set_compute_key(DH_METHOD *dhm, | |||
| int (*compute_key) (unsigned char *key, const BIGNUM *pub_key, DH *dh)); | |||
| int (*DH_meth_get_bn_mod_exp(const DH_METHOD *dhm)) | |||
| (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, | |||
| BN_CTX *, BN_MONT_CTX *); | |||
| int DH_meth_set_bn_mod_exp(DH_METHOD *dhm, | |||
| int (*bn_mod_exp) (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, | |||
| const BIGNUM *, BN_CTX *, BN_MONT_CTX *)); | |||
| int (*DH_meth_get_init(const DH_METHOD *dhm))(DH *); | |||
| int DH_meth_set_init(DH_METHOD *dhm, int (*init)(DH *)); | |||
| int (*DH_meth_get_finish(const DH_METHOD *dhm)) (DH *); | |||
| int DH_meth_set_finish(DH_METHOD *dhm, int (*finish) (DH *)); | |||
| int (*DH_meth_get_generate_params(const DH_METHOD *dhm)) | |||
| (DH *, int, int, BN_GENCB *); | |||
| int DH_meth_set_generate_params(DH_METHOD *dhm, | |||
| int (*generate_params) (DH *, int, int, BN_GENCB *)); | |||
| # define EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ | |||
| EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, len, NULL) | |||
| # define EVP_PKEY_CTX_set_dh_paramgen_subprime_len(ctx, len) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ | |||
| EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN, len, NULL) | |||
| # define EVP_PKEY_CTX_set_dh_paramgen_type(ctx, typ) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ | |||
| EVP_PKEY_CTRL_DH_PARAMGEN_TYPE, typ, NULL) | |||
| # define EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, gen) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ | |||
| EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR, gen, NULL) | |||
| # define EVP_PKEY_CTX_set_dh_rfc5114(ctx, gen) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_PARAMGEN, \ | |||
| EVP_PKEY_CTRL_DH_RFC5114, gen, NULL) | |||
| # define EVP_PKEY_CTX_set_dhx_rfc5114(ctx, gen) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_PARAMGEN, \ | |||
| EVP_PKEY_CTRL_DH_RFC5114, gen, NULL) | |||
| # define EVP_PKEY_CTX_set_dh_nid(ctx, nid) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, \ | |||
| EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN, \ | |||
| EVP_PKEY_CTRL_DH_NID, nid, NULL) | |||
| # define EVP_PKEY_CTX_set_dh_pad(ctx, pad) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_DH_PAD, pad, NULL) | |||
| # define EVP_PKEY_CTX_set_dh_kdf_type(ctx, kdf) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_DH_KDF_TYPE, kdf, NULL) | |||
| # define EVP_PKEY_CTX_get_dh_kdf_type(ctx) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_DH_KDF_TYPE, -2, NULL) | |||
| # define EVP_PKEY_CTX_set0_dh_kdf_oid(ctx, oid) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_DH_KDF_OID, 0, (void *)(oid)) | |||
| # define EVP_PKEY_CTX_get0_dh_kdf_oid(ctx, poid) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_GET_DH_KDF_OID, 0, (void *)(poid)) | |||
| # define EVP_PKEY_CTX_set_dh_kdf_md(ctx, md) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_DH_KDF_MD, 0, (void *)(md)) | |||
| # define EVP_PKEY_CTX_get_dh_kdf_md(ctx, pmd) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_GET_DH_KDF_MD, 0, (void *)(pmd)) | |||
| # define EVP_PKEY_CTX_set_dh_kdf_outlen(ctx, len) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_DH_KDF_OUTLEN, len, NULL) | |||
| # define EVP_PKEY_CTX_get_dh_kdf_outlen(ctx, plen) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN, 0, (void *)(plen)) | |||
| # define EVP_PKEY_CTX_set0_dh_kdf_ukm(ctx, p, plen) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_DH_KDF_UKM, plen, (void *)(p)) | |||
| # define EVP_PKEY_CTX_get0_dh_kdf_ukm(ctx, p) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ | |||
| EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_GET_DH_KDF_UKM, 0, (void *)(p)) | |||
| # define EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN (EVP_PKEY_ALG_CTRL + 1) | |||
| # define EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR (EVP_PKEY_ALG_CTRL + 2) | |||
| # define EVP_PKEY_CTRL_DH_RFC5114 (EVP_PKEY_ALG_CTRL + 3) | |||
| # define EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN (EVP_PKEY_ALG_CTRL + 4) | |||
| # define EVP_PKEY_CTRL_DH_PARAMGEN_TYPE (EVP_PKEY_ALG_CTRL + 5) | |||
| # define EVP_PKEY_CTRL_DH_KDF_TYPE (EVP_PKEY_ALG_CTRL + 6) | |||
| # define EVP_PKEY_CTRL_DH_KDF_MD (EVP_PKEY_ALG_CTRL + 7) | |||
| # define EVP_PKEY_CTRL_GET_DH_KDF_MD (EVP_PKEY_ALG_CTRL + 8) | |||
| # define EVP_PKEY_CTRL_DH_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 9) | |||
| # define EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 10) | |||
| # define EVP_PKEY_CTRL_DH_KDF_UKM (EVP_PKEY_ALG_CTRL + 11) | |||
| # define EVP_PKEY_CTRL_GET_DH_KDF_UKM (EVP_PKEY_ALG_CTRL + 12) | |||
| # define EVP_PKEY_CTRL_DH_KDF_OID (EVP_PKEY_ALG_CTRL + 13) | |||
| # define EVP_PKEY_CTRL_GET_DH_KDF_OID (EVP_PKEY_ALG_CTRL + 14) | |||
| # define EVP_PKEY_CTRL_DH_NID (EVP_PKEY_ALG_CTRL + 15) | |||
| # define EVP_PKEY_CTRL_DH_PAD (EVP_PKEY_ALG_CTRL + 16) | |||
| /* KDF types */ | |||
| # define EVP_PKEY_DH_KDF_NONE 1 | |||
| # ifndef OPENSSL_NO_CMS | |||
| # define EVP_PKEY_DH_KDF_X9_42 2 | |||
| # endif | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,88 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_DHERR_H | |||
| # define HEADER_DHERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_DH | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_DH_strings(void); | |||
| /* | |||
| * DH function codes. | |||
| */ | |||
| # define DH_F_COMPUTE_KEY 102 | |||
| # define DH_F_DHPARAMS_PRINT_FP 101 | |||
| # define DH_F_DH_BUILTIN_GENPARAMS 106 | |||
| # define DH_F_DH_CHECK_EX 121 | |||
| # define DH_F_DH_CHECK_PARAMS_EX 122 | |||
| # define DH_F_DH_CHECK_PUB_KEY_EX 123 | |||
| # define DH_F_DH_CMS_DECRYPT 114 | |||
| # define DH_F_DH_CMS_SET_PEERKEY 115 | |||
| # define DH_F_DH_CMS_SET_SHARED_INFO 116 | |||
| # define DH_F_DH_METH_DUP 117 | |||
| # define DH_F_DH_METH_NEW 118 | |||
| # define DH_F_DH_METH_SET1_NAME 119 | |||
| # define DH_F_DH_NEW_BY_NID 104 | |||
| # define DH_F_DH_NEW_METHOD 105 | |||
| # define DH_F_DH_PARAM_DECODE 107 | |||
| # define DH_F_DH_PKEY_PUBLIC_CHECK 124 | |||
| # define DH_F_DH_PRIV_DECODE 110 | |||
| # define DH_F_DH_PRIV_ENCODE 111 | |||
| # define DH_F_DH_PUB_DECODE 108 | |||
| # define DH_F_DH_PUB_ENCODE 109 | |||
| # define DH_F_DO_DH_PRINT 100 | |||
| # define DH_F_GENERATE_KEY 103 | |||
| # define DH_F_PKEY_DH_CTRL_STR 120 | |||
| # define DH_F_PKEY_DH_DERIVE 112 | |||
| # define DH_F_PKEY_DH_INIT 125 | |||
| # define DH_F_PKEY_DH_KEYGEN 113 | |||
| /* | |||
| * DH reason codes. | |||
| */ | |||
| # define DH_R_BAD_GENERATOR 101 | |||
| # define DH_R_BN_DECODE_ERROR 109 | |||
| # define DH_R_BN_ERROR 106 | |||
| # define DH_R_CHECK_INVALID_J_VALUE 115 | |||
| # define DH_R_CHECK_INVALID_Q_VALUE 116 | |||
| # define DH_R_CHECK_PUBKEY_INVALID 122 | |||
| # define DH_R_CHECK_PUBKEY_TOO_LARGE 123 | |||
| # define DH_R_CHECK_PUBKEY_TOO_SMALL 124 | |||
| # define DH_R_CHECK_P_NOT_PRIME 117 | |||
| # define DH_R_CHECK_P_NOT_SAFE_PRIME 118 | |||
| # define DH_R_CHECK_Q_NOT_PRIME 119 | |||
| # define DH_R_DECODE_ERROR 104 | |||
| # define DH_R_INVALID_PARAMETER_NAME 110 | |||
| # define DH_R_INVALID_PARAMETER_NID 114 | |||
| # define DH_R_INVALID_PUBKEY 102 | |||
| # define DH_R_KDF_PARAMETER_ERROR 112 | |||
| # define DH_R_KEYS_NOT_SET 108 | |||
| # define DH_R_MISSING_PUBKEY 125 | |||
| # define DH_R_MODULUS_TOO_LARGE 103 | |||
| # define DH_R_NOT_SUITABLE_GENERATOR 120 | |||
| # define DH_R_NO_PARAMETERS_SET 107 | |||
| # define DH_R_NO_PRIVATE_VALUE 100 | |||
| # define DH_R_PARAMETER_ENCODING_ERROR 105 | |||
| # define DH_R_PEER_KEY_ERROR 111 | |||
| # define DH_R_SHARED_INFO_ERROR 113 | |||
| # define DH_R_UNABLE_TO_CHECK_GENERATOR 121 | |||
| # endif | |||
| #endif | |||
| @ -1,244 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_DSA_H | |||
| # define HEADER_DSA_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_DSA | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/bio.h> | |||
| # include <openssl/crypto.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/bn.h> | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # include <openssl/dh.h> | |||
| # endif | |||
| # include <openssl/dsaerr.h> | |||
| # ifndef OPENSSL_DSA_MAX_MODULUS_BITS | |||
| # define OPENSSL_DSA_MAX_MODULUS_BITS 10000 | |||
| # endif | |||
| # define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS 1024 | |||
| # define DSA_FLAG_CACHE_MONT_P 0x01 | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| /* | |||
| * Does nothing. Previously this switched off constant time behaviour. | |||
| */ | |||
| # define DSA_FLAG_NO_EXP_CONSTTIME 0x00 | |||
| # endif | |||
| /* | |||
| * If this flag is set the DSA method is FIPS compliant and can be used in | |||
| * FIPS mode. This is set in the validated module method. If an application | |||
| * sets this flag in its own methods it is its responsibility to ensure the | |||
| * result is compliant. | |||
| */ | |||
| # define DSA_FLAG_FIPS_METHOD 0x0400 | |||
| /* | |||
| * If this flag is set the operations normally disabled in FIPS mode are | |||
| * permitted it is then the applications responsibility to ensure that the | |||
| * usage is compliant. | |||
| */ | |||
| # define DSA_FLAG_NON_FIPS_ALLOW 0x0400 | |||
| # define DSA_FLAG_FIPS_CHECKED 0x0800 | |||
| /* Already defined in ossl_typ.h */ | |||
| /* typedef struct dsa_st DSA; */ | |||
| /* typedef struct dsa_method DSA_METHOD; */ | |||
| typedef struct DSA_SIG_st DSA_SIG; | |||
| # define d2i_DSAparams_fp(fp,x) (DSA *)ASN1_d2i_fp((char *(*)())DSA_new, \ | |||
| (char *(*)())d2i_DSAparams,(fp),(unsigned char **)(x)) | |||
| # define i2d_DSAparams_fp(fp,x) ASN1_i2d_fp(i2d_DSAparams,(fp), \ | |||
| (unsigned char *)(x)) | |||
| # define d2i_DSAparams_bio(bp,x) ASN1_d2i_bio_of(DSA,DSA_new,d2i_DSAparams,bp,x) | |||
| # define i2d_DSAparams_bio(bp,x) ASN1_i2d_bio_of_const(DSA,i2d_DSAparams,bp,x) | |||
| DSA *DSAparams_dup(DSA *x); | |||
| DSA_SIG *DSA_SIG_new(void); | |||
| void DSA_SIG_free(DSA_SIG *a); | |||
| int i2d_DSA_SIG(const DSA_SIG *a, unsigned char **pp); | |||
| DSA_SIG *d2i_DSA_SIG(DSA_SIG **v, const unsigned char **pp, long length); | |||
| void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps); | |||
| int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s); | |||
| DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa); | |||
| int DSA_do_verify(const unsigned char *dgst, int dgst_len, | |||
| DSA_SIG *sig, DSA *dsa); | |||
| const DSA_METHOD *DSA_OpenSSL(void); | |||
| void DSA_set_default_method(const DSA_METHOD *); | |||
| const DSA_METHOD *DSA_get_default_method(void); | |||
| int DSA_set_method(DSA *dsa, const DSA_METHOD *); | |||
| const DSA_METHOD *DSA_get_method(DSA *d); | |||
| DSA *DSA_new(void); | |||
| DSA *DSA_new_method(ENGINE *engine); | |||
| void DSA_free(DSA *r); | |||
| /* "up" the DSA object's reference count */ | |||
| int DSA_up_ref(DSA *r); | |||
| int DSA_size(const DSA *); | |||
| int DSA_bits(const DSA *d); | |||
| int DSA_security_bits(const DSA *d); | |||
| /* next 4 return -1 on error */ | |||
| DEPRECATEDIN_1_2_0(int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)) | |||
| int DSA_sign(int type, const unsigned char *dgst, int dlen, | |||
| unsigned char *sig, unsigned int *siglen, DSA *dsa); | |||
| int DSA_verify(int type, const unsigned char *dgst, int dgst_len, | |||
| const unsigned char *sigbuf, int siglen, DSA *dsa); | |||
| #define DSA_get_ex_new_index(l, p, newf, dupf, freef) \ | |||
| CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DSA, l, p, newf, dupf, freef) | |||
| int DSA_set_ex_data(DSA *d, int idx, void *arg); | |||
| void *DSA_get_ex_data(DSA *d, int idx); | |||
| DSA *d2i_DSAPublicKey(DSA **a, const unsigned char **pp, long length); | |||
| DSA *d2i_DSAPrivateKey(DSA **a, const unsigned char **pp, long length); | |||
| DSA *d2i_DSAparams(DSA **a, const unsigned char **pp, long length); | |||
| /* Deprecated version */ | |||
| DEPRECATEDIN_0_9_8(DSA *DSA_generate_parameters(int bits, | |||
| unsigned char *seed, | |||
| int seed_len, | |||
| int *counter_ret, | |||
| unsigned long *h_ret, void | |||
| (*callback) (int, int, | |||
| void *), | |||
| void *cb_arg)) | |||
| /* New version */ | |||
| int DSA_generate_parameters_ex(DSA *dsa, int bits, | |||
| const unsigned char *seed, int seed_len, | |||
| int *counter_ret, unsigned long *h_ret, | |||
| BN_GENCB *cb); | |||
| int DSA_generate_key(DSA *a); | |||
| int i2d_DSAPublicKey(const DSA *a, unsigned char **pp); | |||
| int i2d_DSAPrivateKey(const DSA *a, unsigned char **pp); | |||
| int i2d_DSAparams(const DSA *a, unsigned char **pp); | |||
| int DSAparams_print(BIO *bp, const DSA *x); | |||
| int DSA_print(BIO *bp, const DSA *x, int off); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int DSAparams_print_fp(FILE *fp, const DSA *x); | |||
| int DSA_print_fp(FILE *bp, const DSA *x, int off); | |||
| # endif | |||
| # define DSS_prime_checks 64 | |||
| /* | |||
| * Primality test according to FIPS PUB 186-4, Appendix C.3. Since we only | |||
| * have one value here we set the number of checks to 64 which is the 128 bit | |||
| * security level that is the highest level and valid for creating a 3072 bit | |||
| * DSA key. | |||
| */ | |||
| # define DSA_is_prime(n, callback, cb_arg) \ | |||
| BN_is_prime(n, DSS_prime_checks, callback, NULL, cb_arg) | |||
| # ifndef OPENSSL_NO_DH | |||
| /* | |||
| * Convert DSA structure (key or just parameters) into DH structure (be | |||
| * careful to avoid small subgroup attacks when using this!) | |||
| */ | |||
| DH *DSA_dup_DH(const DSA *r); | |||
| # endif | |||
| # define EVP_PKEY_CTX_set_dsa_paramgen_bits(ctx, nbits) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ | |||
| EVP_PKEY_CTRL_DSA_PARAMGEN_BITS, nbits, NULL) | |||
| # define EVP_PKEY_CTX_set_dsa_paramgen_q_bits(ctx, qbits) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ | |||
| EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS, qbits, NULL) | |||
| # define EVP_PKEY_CTX_set_dsa_paramgen_md(ctx, md) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ | |||
| EVP_PKEY_CTRL_DSA_PARAMGEN_MD, 0, (void *)(md)) | |||
| # define EVP_PKEY_CTRL_DSA_PARAMGEN_BITS (EVP_PKEY_ALG_CTRL + 1) | |||
| # define EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS (EVP_PKEY_ALG_CTRL + 2) | |||
| # define EVP_PKEY_CTRL_DSA_PARAMGEN_MD (EVP_PKEY_ALG_CTRL + 3) | |||
| void DSA_get0_pqg(const DSA *d, | |||
| const BIGNUM **p, const BIGNUM **q, const BIGNUM **g); | |||
| int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g); | |||
| void DSA_get0_key(const DSA *d, | |||
| const BIGNUM **pub_key, const BIGNUM **priv_key); | |||
| int DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key); | |||
| const BIGNUM *DSA_get0_p(const DSA *d); | |||
| const BIGNUM *DSA_get0_q(const DSA *d); | |||
| const BIGNUM *DSA_get0_g(const DSA *d); | |||
| const BIGNUM *DSA_get0_pub_key(const DSA *d); | |||
| const BIGNUM *DSA_get0_priv_key(const DSA *d); | |||
| void DSA_clear_flags(DSA *d, int flags); | |||
| int DSA_test_flags(const DSA *d, int flags); | |||
| void DSA_set_flags(DSA *d, int flags); | |||
| ENGINE *DSA_get0_engine(DSA *d); | |||
| DSA_METHOD *DSA_meth_new(const char *name, int flags); | |||
| void DSA_meth_free(DSA_METHOD *dsam); | |||
| DSA_METHOD *DSA_meth_dup(const DSA_METHOD *dsam); | |||
| const char *DSA_meth_get0_name(const DSA_METHOD *dsam); | |||
| int DSA_meth_set1_name(DSA_METHOD *dsam, const char *name); | |||
| int DSA_meth_get_flags(const DSA_METHOD *dsam); | |||
| int DSA_meth_set_flags(DSA_METHOD *dsam, int flags); | |||
| void *DSA_meth_get0_app_data(const DSA_METHOD *dsam); | |||
| int DSA_meth_set0_app_data(DSA_METHOD *dsam, void *app_data); | |||
| DSA_SIG *(*DSA_meth_get_sign(const DSA_METHOD *dsam)) | |||
| (const unsigned char *, int, DSA *); | |||
| int DSA_meth_set_sign(DSA_METHOD *dsam, | |||
| DSA_SIG *(*sign) (const unsigned char *, int, DSA *)); | |||
| int (*DSA_meth_get_sign_setup(const DSA_METHOD *dsam)) | |||
| (DSA *, BN_CTX *, BIGNUM **, BIGNUM **); | |||
| int DSA_meth_set_sign_setup(DSA_METHOD *dsam, | |||
| int (*sign_setup) (DSA *, BN_CTX *, BIGNUM **, BIGNUM **)); | |||
| int (*DSA_meth_get_verify(const DSA_METHOD *dsam)) | |||
| (const unsigned char *, int, DSA_SIG *, DSA *); | |||
| int DSA_meth_set_verify(DSA_METHOD *dsam, | |||
| int (*verify) (const unsigned char *, int, DSA_SIG *, DSA *)); | |||
| int (*DSA_meth_get_mod_exp(const DSA_METHOD *dsam)) | |||
| (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, | |||
| const BIGNUM *, const BIGNUM *, BN_CTX *, BN_MONT_CTX *); | |||
| int DSA_meth_set_mod_exp(DSA_METHOD *dsam, | |||
| int (*mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, | |||
| const BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *, | |||
| BN_MONT_CTX *)); | |||
| int (*DSA_meth_get_bn_mod_exp(const DSA_METHOD *dsam)) | |||
| (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, | |||
| BN_CTX *, BN_MONT_CTX *); | |||
| int DSA_meth_set_bn_mod_exp(DSA_METHOD *dsam, | |||
| int (*bn_mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, | |||
| const BIGNUM *, BN_CTX *, BN_MONT_CTX *)); | |||
| int (*DSA_meth_get_init(const DSA_METHOD *dsam))(DSA *); | |||
| int DSA_meth_set_init(DSA_METHOD *dsam, int (*init)(DSA *)); | |||
| int (*DSA_meth_get_finish(const DSA_METHOD *dsam)) (DSA *); | |||
| int DSA_meth_set_finish(DSA_METHOD *dsam, int (*finish) (DSA *)); | |||
| int (*DSA_meth_get_paramgen(const DSA_METHOD *dsam)) | |||
| (DSA *, int, const unsigned char *, int, int *, unsigned long *, | |||
| BN_GENCB *); | |||
| int DSA_meth_set_paramgen(DSA_METHOD *dsam, | |||
| int (*paramgen) (DSA *, int, const unsigned char *, int, int *, | |||
| unsigned long *, BN_GENCB *)); | |||
| int (*DSA_meth_get_keygen(const DSA_METHOD *dsam)) (DSA *); | |||
| int DSA_meth_set_keygen(DSA_METHOD *dsam, int (*keygen) (DSA *)); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,72 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_DSAERR_H | |||
| # define HEADER_DSAERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_DSA | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_DSA_strings(void); | |||
| /* | |||
| * DSA function codes. | |||
| */ | |||
| # define DSA_F_DSAPARAMS_PRINT 100 | |||
| # define DSA_F_DSAPARAMS_PRINT_FP 101 | |||
| # define DSA_F_DSA_BUILTIN_PARAMGEN 125 | |||
| # define DSA_F_DSA_BUILTIN_PARAMGEN2 126 | |||
| # define DSA_F_DSA_DO_SIGN 112 | |||
| # define DSA_F_DSA_DO_VERIFY 113 | |||
| # define DSA_F_DSA_METH_DUP 127 | |||
| # define DSA_F_DSA_METH_NEW 128 | |||
| # define DSA_F_DSA_METH_SET1_NAME 129 | |||
| # define DSA_F_DSA_NEW_METHOD 103 | |||
| # define DSA_F_DSA_PARAM_DECODE 119 | |||
| # define DSA_F_DSA_PRINT_FP 105 | |||
| # define DSA_F_DSA_PRIV_DECODE 115 | |||
| # define DSA_F_DSA_PRIV_ENCODE 116 | |||
| # define DSA_F_DSA_PUB_DECODE 117 | |||
| # define DSA_F_DSA_PUB_ENCODE 118 | |||
| # define DSA_F_DSA_SIGN 106 | |||
| # define DSA_F_DSA_SIGN_SETUP 107 | |||
| # define DSA_F_DSA_SIG_NEW 102 | |||
| # define DSA_F_OLD_DSA_PRIV_DECODE 122 | |||
| # define DSA_F_PKEY_DSA_CTRL 120 | |||
| # define DSA_F_PKEY_DSA_CTRL_STR 104 | |||
| # define DSA_F_PKEY_DSA_KEYGEN 121 | |||
| /* | |||
| * DSA reason codes. | |||
| */ | |||
| # define DSA_R_BAD_Q_VALUE 102 | |||
| # define DSA_R_BN_DECODE_ERROR 108 | |||
| # define DSA_R_BN_ERROR 109 | |||
| # define DSA_R_DECODE_ERROR 104 | |||
| # define DSA_R_INVALID_DIGEST_TYPE 106 | |||
| # define DSA_R_INVALID_PARAMETERS 112 | |||
| # define DSA_R_MISSING_PARAMETERS 101 | |||
| # define DSA_R_MISSING_PRIVATE_KEY 111 | |||
| # define DSA_R_MODULUS_TOO_LARGE 103 | |||
| # define DSA_R_NO_PARAMETERS_SET 107 | |||
| # define DSA_R_PARAMETER_ENCODING_ERROR 105 | |||
| # define DSA_R_Q_NOT_PRIME 113 | |||
| # define DSA_R_SEED_LEN_SMALL 110 | |||
| # endif | |||
| #endif | |||
| @ -1,55 +0,0 @@ | |||
| /* | |||
| * Copyright 2005-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_DTLS1_H | |||
| # define HEADER_DTLS1_H | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # define DTLS1_VERSION 0xFEFF | |||
| # define DTLS1_2_VERSION 0xFEFD | |||
| # define DTLS_MIN_VERSION DTLS1_VERSION | |||
| # define DTLS_MAX_VERSION DTLS1_2_VERSION | |||
| # define DTLS1_VERSION_MAJOR 0xFE | |||
| # define DTLS1_BAD_VER 0x0100 | |||
| /* Special value for method supporting multiple versions */ | |||
| # define DTLS_ANY_VERSION 0x1FFFF | |||
| /* lengths of messages */ | |||
| /* | |||
| * Actually the max cookie length in DTLS is 255. But we can't change this now | |||
| * due to compatibility concerns. | |||
| */ | |||
| # define DTLS1_COOKIE_LENGTH 256 | |||
| # define DTLS1_RT_HEADER_LENGTH 13 | |||
| # define DTLS1_HM_HEADER_LENGTH 12 | |||
| # define DTLS1_HM_BAD_FRAGMENT -2 | |||
| # define DTLS1_HM_FRAGMENT_RETRY -3 | |||
| # define DTLS1_CCS_HEADER_LENGTH 1 | |||
| # define DTLS1_AL_HEADER_LENGTH 2 | |||
| /* Timeout multipliers */ | |||
| # define DTLS1_TMO_READ_COUNT 2 | |||
| # define DTLS1_TMO_WRITE_COUNT 2 | |||
| # define DTLS1_TMO_ALERT_COUNT 12 | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,300 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_E_OS2_H | |||
| # define HEADER_E_OS2_H | |||
| # include <openssl/opensslconf.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /****************************************************************************** | |||
| * Detect operating systems. This probably needs completing. | |||
| * The result is that at least one OPENSSL_SYS_os macro should be defined. | |||
| * However, if none is defined, Unix is assumed. | |||
| **/ | |||
| # define OPENSSL_SYS_UNIX | |||
| /* --------------------- Microsoft operating systems ---------------------- */ | |||
| /* | |||
| * Note that MSDOS actually denotes 32-bit environments running on top of | |||
| * MS-DOS, such as DJGPP one. | |||
| */ | |||
| # if defined(OPENSSL_SYS_MSDOS) | |||
| # undef OPENSSL_SYS_UNIX | |||
| # endif | |||
| /* | |||
| * For 32 bit environment, there seems to be the CygWin environment and then | |||
| * all the others that try to do the same thing Microsoft does... | |||
| */ | |||
| /* | |||
| * UEFI lives here because it might be built with a Microsoft toolchain and | |||
| * we need to avoid the false positive match on Windows. | |||
| */ | |||
| # if defined(OPENSSL_SYS_UEFI) | |||
| # undef OPENSSL_SYS_UNIX | |||
| # elif defined(OPENSSL_SYS_UWIN) | |||
| # undef OPENSSL_SYS_UNIX | |||
| # define OPENSSL_SYS_WIN32_UWIN | |||
| # else | |||
| # if defined(__CYGWIN__) || defined(OPENSSL_SYS_CYGWIN) | |||
| # define OPENSSL_SYS_WIN32_CYGWIN | |||
| # else | |||
| # if defined(_WIN32) || defined(OPENSSL_SYS_WIN32) | |||
| # undef OPENSSL_SYS_UNIX | |||
| # if !defined(OPENSSL_SYS_WIN32) | |||
| # define OPENSSL_SYS_WIN32 | |||
| # endif | |||
| # endif | |||
| # if defined(_WIN64) || defined(OPENSSL_SYS_WIN64) | |||
| # undef OPENSSL_SYS_UNIX | |||
| # if !defined(OPENSSL_SYS_WIN64) | |||
| # define OPENSSL_SYS_WIN64 | |||
| # endif | |||
| # endif | |||
| # if defined(OPENSSL_SYS_WINNT) | |||
| # undef OPENSSL_SYS_UNIX | |||
| # endif | |||
| # if defined(OPENSSL_SYS_WINCE) | |||
| # undef OPENSSL_SYS_UNIX | |||
| # endif | |||
| # endif | |||
| # endif | |||
| /* Anything that tries to look like Microsoft is "Windows" */ | |||
| # if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN64) || defined(OPENSSL_SYS_WINNT) || defined(OPENSSL_SYS_WINCE) | |||
| # undef OPENSSL_SYS_UNIX | |||
| # define OPENSSL_SYS_WINDOWS | |||
| # ifndef OPENSSL_SYS_MSDOS | |||
| # define OPENSSL_SYS_MSDOS | |||
| # endif | |||
| # endif | |||
| /* | |||
| * DLL settings. This part is a bit tough, because it's up to the | |||
| * application implementor how he or she will link the application, so it | |||
| * requires some macro to be used. | |||
| */ | |||
| # ifdef OPENSSL_SYS_WINDOWS | |||
| # ifndef OPENSSL_OPT_WINDLL | |||
| # if defined(_WINDLL) /* This is used when building OpenSSL to | |||
| * indicate that DLL linkage should be used */ | |||
| # define OPENSSL_OPT_WINDLL | |||
| # endif | |||
| # endif | |||
| # endif | |||
| /* ------------------------------- OpenVMS -------------------------------- */ | |||
| # if defined(__VMS) || defined(VMS) || defined(OPENSSL_SYS_VMS) | |||
| # if !defined(OPENSSL_SYS_VMS) | |||
| # undef OPENSSL_SYS_UNIX | |||
| # endif | |||
| # define OPENSSL_SYS_VMS | |||
| # if defined(__DECC) | |||
| # define OPENSSL_SYS_VMS_DECC | |||
| # elif defined(__DECCXX) | |||
| # define OPENSSL_SYS_VMS_DECC | |||
| # define OPENSSL_SYS_VMS_DECCXX | |||
| # else | |||
| # define OPENSSL_SYS_VMS_NODECC | |||
| # endif | |||
| # endif | |||
| /* -------------------------------- Unix ---------------------------------- */ | |||
| # ifdef OPENSSL_SYS_UNIX | |||
| # if defined(linux) || defined(__linux__) && !defined(OPENSSL_SYS_LINUX) | |||
| # define OPENSSL_SYS_LINUX | |||
| # endif | |||
| # if defined(_AIX) && !defined(OPENSSL_SYS_AIX) | |||
| # define OPENSSL_SYS_AIX | |||
| # endif | |||
| # endif | |||
| /* -------------------------------- VOS ----------------------------------- */ | |||
| # if defined(__VOS__) && !defined(OPENSSL_SYS_VOS) | |||
| # define OPENSSL_SYS_VOS | |||
| # ifdef __HPPA__ | |||
| # define OPENSSL_SYS_VOS_HPPA | |||
| # endif | |||
| # ifdef __IA32__ | |||
| # define OPENSSL_SYS_VOS_IA32 | |||
| # endif | |||
| # endif | |||
| /** | |||
| * That's it for OS-specific stuff | |||
| *****************************************************************************/ | |||
| /* Specials for I/O an exit */ | |||
| # ifdef OPENSSL_SYS_MSDOS | |||
| # define OPENSSL_UNISTD_IO <io.h> | |||
| # define OPENSSL_DECLARE_EXIT extern void exit(int); | |||
| # else | |||
| # define OPENSSL_UNISTD_IO OPENSSL_UNISTD | |||
| # define OPENSSL_DECLARE_EXIT /* declared in unistd.h */ | |||
| # endif | |||
| /*- | |||
| * OPENSSL_EXTERN is normally used to declare a symbol with possible extra | |||
| * attributes to handle its presence in a shared library. | |||
| * OPENSSL_EXPORT is used to define a symbol with extra possible attributes | |||
| * to make it visible in a shared library. | |||
| * Care needs to be taken when a header file is used both to declare and | |||
| * define symbols. Basically, for any library that exports some global | |||
| * variables, the following code must be present in the header file that | |||
| * declares them, before OPENSSL_EXTERN is used: | |||
| * | |||
| * #ifdef SOME_BUILD_FLAG_MACRO | |||
| * # undef OPENSSL_EXTERN | |||
| * # define OPENSSL_EXTERN OPENSSL_EXPORT | |||
| * #endif | |||
| * | |||
| * The default is to have OPENSSL_EXPORT and OPENSSL_EXTERN | |||
| * have some generally sensible values. | |||
| */ | |||
| # if defined(OPENSSL_SYS_WINDOWS) && defined(OPENSSL_OPT_WINDLL) | |||
| # define OPENSSL_EXPORT extern __declspec(dllexport) | |||
| # define OPENSSL_EXTERN extern __declspec(dllimport) | |||
| # else | |||
| # define OPENSSL_EXPORT extern | |||
| # define OPENSSL_EXTERN extern | |||
| # endif | |||
| /*- | |||
| * Macros to allow global variables to be reached through function calls when | |||
| * required (if a shared library version requires it, for example. | |||
| * The way it's done allows definitions like this: | |||
| * | |||
| * // in foobar.c | |||
| * OPENSSL_IMPLEMENT_GLOBAL(int,foobar,0) | |||
| * // in foobar.h | |||
| * OPENSSL_DECLARE_GLOBAL(int,foobar); | |||
| * #define foobar OPENSSL_GLOBAL_REF(foobar) | |||
| */ | |||
| # ifdef OPENSSL_EXPORT_VAR_AS_FUNCTION | |||
| # define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) \ | |||
| type *_shadow_##name(void) \ | |||
| { static type _hide_##name=value; return &_hide_##name; } | |||
| # define OPENSSL_DECLARE_GLOBAL(type,name) type *_shadow_##name(void) | |||
| # define OPENSSL_GLOBAL_REF(name) (*(_shadow_##name())) | |||
| # else | |||
| # define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) type _shadow_##name=value; | |||
| # define OPENSSL_DECLARE_GLOBAL(type,name) OPENSSL_EXPORT type _shadow_##name | |||
| # define OPENSSL_GLOBAL_REF(name) _shadow_##name | |||
| # endif | |||
| # ifdef _WIN32 | |||
| # ifdef _WIN64 | |||
| # define ossl_ssize_t __int64 | |||
| # define OSSL_SSIZE_MAX _I64_MAX | |||
| # else | |||
| # define ossl_ssize_t int | |||
| # define OSSL_SSIZE_MAX INT_MAX | |||
| # endif | |||
| # endif | |||
| # if defined(OPENSSL_SYS_UEFI) && !defined(ossl_ssize_t) | |||
| # define ossl_ssize_t INTN | |||
| # define OSSL_SSIZE_MAX MAX_INTN | |||
| # endif | |||
| # ifndef ossl_ssize_t | |||
| # define ossl_ssize_t ssize_t | |||
| # if defined(SSIZE_MAX) | |||
| # define OSSL_SSIZE_MAX SSIZE_MAX | |||
| # elif defined(_POSIX_SSIZE_MAX) | |||
| # define OSSL_SSIZE_MAX _POSIX_SSIZE_MAX | |||
| # else | |||
| # define OSSL_SSIZE_MAX ((ssize_t)(SIZE_MAX>>1)) | |||
| # endif | |||
| # endif | |||
| # ifdef DEBUG_UNUSED | |||
| # define __owur __attribute__((__warn_unused_result__)) | |||
| # else | |||
| # define __owur | |||
| # endif | |||
| /* Standard integer types */ | |||
| # if defined(OPENSSL_SYS_UEFI) | |||
| typedef INT8 int8_t; | |||
| typedef UINT8 uint8_t; | |||
| typedef INT16 int16_t; | |||
| typedef UINT16 uint16_t; | |||
| typedef INT32 int32_t; | |||
| typedef UINT32 uint32_t; | |||
| typedef INT64 int64_t; | |||
| typedef UINT64 uint64_t; | |||
| # elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \ | |||
| defined(__osf__) || defined(__sgi) || defined(__hpux) || \ | |||
| defined(OPENSSL_SYS_VMS) || defined (__OpenBSD__) | |||
| # include <inttypes.h> | |||
| # elif defined(_MSC_VER) && _MSC_VER<1600 | |||
| /* | |||
| * minimally required typdefs for systems not supporting inttypes.h or | |||
| * stdint.h: currently just older VC++ | |||
| */ | |||
| typedef signed char int8_t; | |||
| typedef unsigned char uint8_t; | |||
| typedef short int16_t; | |||
| typedef unsigned short uint16_t; | |||
| typedef int int32_t; | |||
| typedef unsigned int uint32_t; | |||
| typedef __int64 int64_t; | |||
| typedef unsigned __int64 uint64_t; | |||
| # else | |||
| # include <stdint.h> | |||
| # endif | |||
| /* ossl_inline: portable inline definition usable in public headers */ | |||
| # if !defined(inline) && !defined(__cplusplus) | |||
| # if defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L | |||
| /* just use inline */ | |||
| # define ossl_inline inline | |||
| # elif defined(__GNUC__) && __GNUC__>=2 | |||
| # define ossl_inline __inline__ | |||
| # elif defined(_MSC_VER) | |||
| /* | |||
| * Visual Studio: inline is available in C++ only, however | |||
| * __inline is available for C, see | |||
| * http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx | |||
| */ | |||
| # define ossl_inline __inline | |||
| # else | |||
| # define ossl_inline | |||
| # endif | |||
| # else | |||
| # define ossl_inline inline | |||
| # endif | |||
| # if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L | |||
| # define ossl_noreturn _Noreturn | |||
| # elif defined(__GNUC__) && __GNUC__ >= 2 | |||
| # define ossl_noreturn __attribute__((noreturn)) | |||
| # else | |||
| # define ossl_noreturn | |||
| # endif | |||
| /* ossl_unused: portable unused attribute for use in public headers */ | |||
| # if defined(__GNUC__) | |||
| # define ossl_unused __attribute__((unused)) | |||
| # else | |||
| # define ossl_unused | |||
| # endif | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,33 +0,0 @@ | |||
| /* | |||
| * Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_EBCDIC_H | |||
| # define HEADER_EBCDIC_H | |||
| # include <stdlib.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /* Avoid name clashes with other applications */ | |||
| # define os_toascii _openssl_os_toascii | |||
| # define os_toebcdic _openssl_os_toebcdic | |||
| # define ebcdic2ascii _openssl_ebcdic2ascii | |||
| # define ascii2ebcdic _openssl_ascii2ebcdic | |||
| extern const unsigned char os_toascii[256]; | |||
| extern const unsigned char os_toebcdic[256]; | |||
| void *ebcdic2ascii(void *dest, const void *srce, size_t count); | |||
| void *ascii2ebcdic(void *dest, const void *srce, size_t count); | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,10 +0,0 @@ | |||
| /* | |||
| * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #include <openssl/ec.h> | |||
| @ -1,10 +0,0 @@ | |||
| /* | |||
| * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #include <openssl/ec.h> | |||
| @ -1,276 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_ECERR_H | |||
| # define HEADER_ECERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_EC | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_EC_strings(void); | |||
| /* | |||
| * EC function codes. | |||
| */ | |||
| # define EC_F_BN_TO_FELEM 224 | |||
| # define EC_F_D2I_ECPARAMETERS 144 | |||
| # define EC_F_D2I_ECPKPARAMETERS 145 | |||
| # define EC_F_D2I_ECPRIVATEKEY 146 | |||
| # define EC_F_DO_EC_KEY_PRINT 221 | |||
| # define EC_F_ECDH_CMS_DECRYPT 238 | |||
| # define EC_F_ECDH_CMS_SET_SHARED_INFO 239 | |||
| # define EC_F_ECDH_COMPUTE_KEY 246 | |||
| # define EC_F_ECDH_SIMPLE_COMPUTE_KEY 257 | |||
| # define EC_F_ECDSA_DO_SIGN_EX 251 | |||
| # define EC_F_ECDSA_DO_VERIFY 252 | |||
| # define EC_F_ECDSA_SIGN_EX 254 | |||
| # define EC_F_ECDSA_SIGN_SETUP 248 | |||
| # define EC_F_ECDSA_SIG_NEW 265 | |||
| # define EC_F_ECDSA_VERIFY 253 | |||
| # define EC_F_ECD_ITEM_VERIFY 270 | |||
| # define EC_F_ECKEY_PARAM2TYPE 223 | |||
| # define EC_F_ECKEY_PARAM_DECODE 212 | |||
| # define EC_F_ECKEY_PRIV_DECODE 213 | |||
| # define EC_F_ECKEY_PRIV_ENCODE 214 | |||
| # define EC_F_ECKEY_PUB_DECODE 215 | |||
| # define EC_F_ECKEY_PUB_ENCODE 216 | |||
| # define EC_F_ECKEY_TYPE2PARAM 220 | |||
| # define EC_F_ECPARAMETERS_PRINT 147 | |||
| # define EC_F_ECPARAMETERS_PRINT_FP 148 | |||
| # define EC_F_ECPKPARAMETERS_PRINT 149 | |||
| # define EC_F_ECPKPARAMETERS_PRINT_FP 150 | |||
| # define EC_F_ECP_NISTZ256_GET_AFFINE 240 | |||
| # define EC_F_ECP_NISTZ256_INV_MOD_ORD 275 | |||
| # define EC_F_ECP_NISTZ256_MULT_PRECOMPUTE 243 | |||
| # define EC_F_ECP_NISTZ256_POINTS_MUL 241 | |||
| # define EC_F_ECP_NISTZ256_PRE_COMP_NEW 244 | |||
| # define EC_F_ECP_NISTZ256_WINDOWED_MUL 242 | |||
| # define EC_F_ECX_KEY_OP 266 | |||
| # define EC_F_ECX_PRIV_ENCODE 267 | |||
| # define EC_F_ECX_PUB_ENCODE 268 | |||
| # define EC_F_EC_ASN1_GROUP2CURVE 153 | |||
| # define EC_F_EC_ASN1_GROUP2FIELDID 154 | |||
| # define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY 208 | |||
| # define EC_F_EC_GF2M_SIMPLE_FIELD_INV 296 | |||
| # define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT 159 | |||
| # define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE 195 | |||
| # define EC_F_EC_GF2M_SIMPLE_LADDER_POST 285 | |||
| # define EC_F_EC_GF2M_SIMPLE_LADDER_PRE 288 | |||
| # define EC_F_EC_GF2M_SIMPLE_OCT2POINT 160 | |||
| # define EC_F_EC_GF2M_SIMPLE_POINT2OCT 161 | |||
| # define EC_F_EC_GF2M_SIMPLE_POINTS_MUL 289 | |||
| # define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 162 | |||
| # define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 163 | |||
| # define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES 164 | |||
| # define EC_F_EC_GFP_MONT_FIELD_DECODE 133 | |||
| # define EC_F_EC_GFP_MONT_FIELD_ENCODE 134 | |||
| # define EC_F_EC_GFP_MONT_FIELD_INV 297 | |||
| # define EC_F_EC_GFP_MONT_FIELD_MUL 131 | |||
| # define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE 209 | |||
| # define EC_F_EC_GFP_MONT_FIELD_SQR 132 | |||
| # define EC_F_EC_GFP_MONT_GROUP_SET_CURVE 189 | |||
| # define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE 225 | |||
| # define EC_F_EC_GFP_NISTP224_POINTS_MUL 228 | |||
| # define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 226 | |||
| # define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE 230 | |||
| # define EC_F_EC_GFP_NISTP256_POINTS_MUL 231 | |||
| # define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 232 | |||
| # define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE 233 | |||
| # define EC_F_EC_GFP_NISTP521_POINTS_MUL 234 | |||
| # define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 235 | |||
| # define EC_F_EC_GFP_NIST_FIELD_MUL 200 | |||
| # define EC_F_EC_GFP_NIST_FIELD_SQR 201 | |||
| # define EC_F_EC_GFP_NIST_GROUP_SET_CURVE 202 | |||
| # define EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES 287 | |||
| # define EC_F_EC_GFP_SIMPLE_FIELD_INV 298 | |||
| # define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT 165 | |||
| # define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE 166 | |||
| # define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE 102 | |||
| # define EC_F_EC_GFP_SIMPLE_OCT2POINT 103 | |||
| # define EC_F_EC_GFP_SIMPLE_POINT2OCT 104 | |||
| # define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE 137 | |||
| # define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 167 | |||
| # define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 168 | |||
| # define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 169 | |||
| # define EC_F_EC_GROUP_CHECK 170 | |||
| # define EC_F_EC_GROUP_CHECK_DISCRIMINANT 171 | |||
| # define EC_F_EC_GROUP_COPY 106 | |||
| # define EC_F_EC_GROUP_GET_CURVE 291 | |||
| # define EC_F_EC_GROUP_GET_CURVE_GF2M 172 | |||
| # define EC_F_EC_GROUP_GET_CURVE_GFP 130 | |||
| # define EC_F_EC_GROUP_GET_DEGREE 173 | |||
| # define EC_F_EC_GROUP_GET_ECPARAMETERS 261 | |||
| # define EC_F_EC_GROUP_GET_ECPKPARAMETERS 262 | |||
| # define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS 193 | |||
| # define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS 194 | |||
| # define EC_F_EC_GROUP_NEW 108 | |||
| # define EC_F_EC_GROUP_NEW_BY_CURVE_NAME 174 | |||
| # define EC_F_EC_GROUP_NEW_FROM_DATA 175 | |||
| # define EC_F_EC_GROUP_NEW_FROM_ECPARAMETERS 263 | |||
| # define EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS 264 | |||
| # define EC_F_EC_GROUP_SET_CURVE 292 | |||
| # define EC_F_EC_GROUP_SET_CURVE_GF2M 176 | |||
| # define EC_F_EC_GROUP_SET_CURVE_GFP 109 | |||
| # define EC_F_EC_GROUP_SET_GENERATOR 111 | |||
| # define EC_F_EC_GROUP_SET_SEED 286 | |||
| # define EC_F_EC_KEY_CHECK_KEY 177 | |||
| # define EC_F_EC_KEY_COPY 178 | |||
| # define EC_F_EC_KEY_GENERATE_KEY 179 | |||
| # define EC_F_EC_KEY_NEW 182 | |||
| # define EC_F_EC_KEY_NEW_METHOD 245 | |||
| # define EC_F_EC_KEY_OCT2PRIV 255 | |||
| # define EC_F_EC_KEY_PRINT 180 | |||
| # define EC_F_EC_KEY_PRINT_FP 181 | |||
| # define EC_F_EC_KEY_PRIV2BUF 279 | |||
| # define EC_F_EC_KEY_PRIV2OCT 256 | |||
| # define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES 229 | |||
| # define EC_F_EC_KEY_SIMPLE_CHECK_KEY 258 | |||
| # define EC_F_EC_KEY_SIMPLE_OCT2PRIV 259 | |||
| # define EC_F_EC_KEY_SIMPLE_PRIV2OCT 260 | |||
| # define EC_F_EC_PKEY_CHECK 273 | |||
| # define EC_F_EC_PKEY_PARAM_CHECK 274 | |||
| # define EC_F_EC_POINTS_MAKE_AFFINE 136 | |||
| # define EC_F_EC_POINTS_MUL 290 | |||
| # define EC_F_EC_POINT_ADD 112 | |||
| # define EC_F_EC_POINT_BN2POINT 280 | |||
| # define EC_F_EC_POINT_CMP 113 | |||
| # define EC_F_EC_POINT_COPY 114 | |||
| # define EC_F_EC_POINT_DBL 115 | |||
| # define EC_F_EC_POINT_GET_AFFINE_COORDINATES 293 | |||
| # define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M 183 | |||
| # define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP 116 | |||
| # define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP 117 | |||
| # define EC_F_EC_POINT_INVERT 210 | |||
| # define EC_F_EC_POINT_IS_AT_INFINITY 118 | |||
| # define EC_F_EC_POINT_IS_ON_CURVE 119 | |||
| # define EC_F_EC_POINT_MAKE_AFFINE 120 | |||
| # define EC_F_EC_POINT_NEW 121 | |||
| # define EC_F_EC_POINT_OCT2POINT 122 | |||
| # define EC_F_EC_POINT_POINT2BUF 281 | |||
| # define EC_F_EC_POINT_POINT2OCT 123 | |||
| # define EC_F_EC_POINT_SET_AFFINE_COORDINATES 294 | |||
| # define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M 185 | |||
| # define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP 124 | |||
| # define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES 295 | |||
| # define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M 186 | |||
| # define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP 125 | |||
| # define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP 126 | |||
| # define EC_F_EC_POINT_SET_TO_INFINITY 127 | |||
| # define EC_F_EC_PRE_COMP_NEW 196 | |||
| # define EC_F_EC_SCALAR_MUL_LADDER 284 | |||
| # define EC_F_EC_WNAF_MUL 187 | |||
| # define EC_F_EC_WNAF_PRECOMPUTE_MULT 188 | |||
| # define EC_F_I2D_ECPARAMETERS 190 | |||
| # define EC_F_I2D_ECPKPARAMETERS 191 | |||
| # define EC_F_I2D_ECPRIVATEKEY 192 | |||
| # define EC_F_I2O_ECPUBLICKEY 151 | |||
| # define EC_F_NISTP224_PRE_COMP_NEW 227 | |||
| # define EC_F_NISTP256_PRE_COMP_NEW 236 | |||
| # define EC_F_NISTP521_PRE_COMP_NEW 237 | |||
| # define EC_F_O2I_ECPUBLICKEY 152 | |||
| # define EC_F_OLD_EC_PRIV_DECODE 222 | |||
| # define EC_F_OSSL_ECDH_COMPUTE_KEY 247 | |||
| # define EC_F_OSSL_ECDSA_SIGN_SIG 249 | |||
| # define EC_F_OSSL_ECDSA_VERIFY_SIG 250 | |||
| # define EC_F_PKEY_ECD_CTRL 271 | |||
| # define EC_F_PKEY_ECD_DIGESTSIGN 272 | |||
| # define EC_F_PKEY_ECD_DIGESTSIGN25519 276 | |||
| # define EC_F_PKEY_ECD_DIGESTSIGN448 277 | |||
| # define EC_F_PKEY_ECX_DERIVE 269 | |||
| # define EC_F_PKEY_EC_CTRL 197 | |||
| # define EC_F_PKEY_EC_CTRL_STR 198 | |||
| # define EC_F_PKEY_EC_DERIVE 217 | |||
| # define EC_F_PKEY_EC_INIT 282 | |||
| # define EC_F_PKEY_EC_KDF_DERIVE 283 | |||
| # define EC_F_PKEY_EC_KEYGEN 199 | |||
| # define EC_F_PKEY_EC_PARAMGEN 219 | |||
| # define EC_F_PKEY_EC_SIGN 218 | |||
| # define EC_F_VALIDATE_ECX_DERIVE 278 | |||
| /* | |||
| * EC reason codes. | |||
| */ | |||
| # define EC_R_ASN1_ERROR 115 | |||
| # define EC_R_BAD_SIGNATURE 156 | |||
| # define EC_R_BIGNUM_OUT_OF_RANGE 144 | |||
| # define EC_R_BUFFER_TOO_SMALL 100 | |||
| # define EC_R_CANNOT_INVERT 165 | |||
| # define EC_R_COORDINATES_OUT_OF_RANGE 146 | |||
| # define EC_R_CURVE_DOES_NOT_SUPPORT_ECDH 160 | |||
| # define EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING 159 | |||
| # define EC_R_D2I_ECPKPARAMETERS_FAILURE 117 | |||
| # define EC_R_DECODE_ERROR 142 | |||
| # define EC_R_DISCRIMINANT_IS_ZERO 118 | |||
| # define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE 119 | |||
| # define EC_R_FIELD_TOO_LARGE 143 | |||
| # define EC_R_GF2M_NOT_SUPPORTED 147 | |||
| # define EC_R_GROUP2PKPARAMETERS_FAILURE 120 | |||
| # define EC_R_I2D_ECPKPARAMETERS_FAILURE 121 | |||
| # define EC_R_INCOMPATIBLE_OBJECTS 101 | |||
| # define EC_R_INVALID_ARGUMENT 112 | |||
| # define EC_R_INVALID_COMPRESSED_POINT 110 | |||
| # define EC_R_INVALID_COMPRESSION_BIT 109 | |||
| # define EC_R_INVALID_CURVE 141 | |||
| # define EC_R_INVALID_DIGEST 151 | |||
| # define EC_R_INVALID_DIGEST_TYPE 138 | |||
| # define EC_R_INVALID_ENCODING 102 | |||
| # define EC_R_INVALID_FIELD 103 | |||
| # define EC_R_INVALID_FORM 104 | |||
| # define EC_R_INVALID_GROUP_ORDER 122 | |||
| # define EC_R_INVALID_KEY 116 | |||
| # define EC_R_INVALID_OUTPUT_LENGTH 161 | |||
| # define EC_R_INVALID_PEER_KEY 133 | |||
| # define EC_R_INVALID_PENTANOMIAL_BASIS 132 | |||
| # define EC_R_INVALID_PRIVATE_KEY 123 | |||
| # define EC_R_INVALID_TRINOMIAL_BASIS 137 | |||
| # define EC_R_KDF_PARAMETER_ERROR 148 | |||
| # define EC_R_KEYS_NOT_SET 140 | |||
| # define EC_R_LADDER_POST_FAILURE 136 | |||
| # define EC_R_LADDER_PRE_FAILURE 153 | |||
| # define EC_R_LADDER_STEP_FAILURE 162 | |||
| # define EC_R_MISSING_OID 167 | |||
| # define EC_R_MISSING_PARAMETERS 124 | |||
| # define EC_R_MISSING_PRIVATE_KEY 125 | |||
| # define EC_R_NEED_NEW_SETUP_VALUES 157 | |||
| # define EC_R_NOT_A_NIST_PRIME 135 | |||
| # define EC_R_NOT_IMPLEMENTED 126 | |||
| # define EC_R_NOT_INITIALIZED 111 | |||
| # define EC_R_NO_PARAMETERS_SET 139 | |||
| # define EC_R_NO_PRIVATE_VALUE 154 | |||
| # define EC_R_OPERATION_NOT_SUPPORTED 152 | |||
| # define EC_R_PASSED_NULL_PARAMETER 134 | |||
| # define EC_R_PEER_KEY_ERROR 149 | |||
| # define EC_R_PKPARAMETERS2GROUP_FAILURE 127 | |||
| # define EC_R_POINT_ARITHMETIC_FAILURE 155 | |||
| # define EC_R_POINT_AT_INFINITY 106 | |||
| # define EC_R_POINT_COORDINATES_BLIND_FAILURE 163 | |||
| # define EC_R_POINT_IS_NOT_ON_CURVE 107 | |||
| # define EC_R_RANDOM_NUMBER_GENERATION_FAILED 158 | |||
| # define EC_R_SHARED_INFO_ERROR 150 | |||
| # define EC_R_SLOT_FULL 108 | |||
| # define EC_R_UNDEFINED_GENERATOR 113 | |||
| # define EC_R_UNDEFINED_ORDER 128 | |||
| # define EC_R_UNKNOWN_COFACTOR 164 | |||
| # define EC_R_UNKNOWN_GROUP 129 | |||
| # define EC_R_UNKNOWN_ORDER 114 | |||
| # define EC_R_UNSUPPORTED_FIELD 131 | |||
| # define EC_R_WRONG_CURVE_PARAMETERS 145 | |||
| # define EC_R_WRONG_ORDER 130 | |||
| # endif | |||
| #endif | |||
| @ -1,751 +0,0 @@ | |||
| /* | |||
| * Copyright 2000-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_ENGINE_H | |||
| # define HEADER_ENGINE_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_ENGINE | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # include <openssl/bn.h> | |||
| # include <openssl/rsa.h> | |||
| # include <openssl/dsa.h> | |||
| # include <openssl/dh.h> | |||
| # include <openssl/ec.h> | |||
| # include <openssl/rand.h> | |||
| # include <openssl/ui.h> | |||
| # include <openssl/err.h> | |||
| # endif | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/symhacks.h> | |||
| # include <openssl/x509.h> | |||
| # include <openssl/engineerr.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| /* | |||
| * These flags are used to control combinations of algorithm (methods) by | |||
| * bitwise "OR"ing. | |||
| */ | |||
| # define ENGINE_METHOD_RSA (unsigned int)0x0001 | |||
| # define ENGINE_METHOD_DSA (unsigned int)0x0002 | |||
| # define ENGINE_METHOD_DH (unsigned int)0x0004 | |||
| # define ENGINE_METHOD_RAND (unsigned int)0x0008 | |||
| # define ENGINE_METHOD_CIPHERS (unsigned int)0x0040 | |||
| # define ENGINE_METHOD_DIGESTS (unsigned int)0x0080 | |||
| # define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200 | |||
| # define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400 | |||
| # define ENGINE_METHOD_EC (unsigned int)0x0800 | |||
| /* Obvious all-or-nothing cases. */ | |||
| # define ENGINE_METHOD_ALL (unsigned int)0xFFFF | |||
| # define ENGINE_METHOD_NONE (unsigned int)0x0000 | |||
| /* | |||
| * This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used | |||
| * internally to control registration of ENGINE implementations, and can be | |||
| * set by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to | |||
| * initialise registered ENGINEs if they are not already initialised. | |||
| */ | |||
| # define ENGINE_TABLE_FLAG_NOINIT (unsigned int)0x0001 | |||
| /* ENGINE flags that can be set by ENGINE_set_flags(). */ | |||
| /* Not used */ | |||
| /* #define ENGINE_FLAGS_MALLOCED 0x0001 */ | |||
| /* | |||
| * This flag is for ENGINEs that wish to handle the various 'CMD'-related | |||
| * control commands on their own. Without this flag, ENGINE_ctrl() handles | |||
| * these control commands on behalf of the ENGINE using their "cmd_defns" | |||
| * data. | |||
| */ | |||
| # define ENGINE_FLAGS_MANUAL_CMD_CTRL (int)0x0002 | |||
| /* | |||
| * This flag is for ENGINEs who return new duplicate structures when found | |||
| * via "ENGINE_by_id()". When an ENGINE must store state (eg. if | |||
| * ENGINE_ctrl() commands are called in sequence as part of some stateful | |||
| * process like key-generation setup and execution), it can set this flag - | |||
| * then each attempt to obtain the ENGINE will result in it being copied into | |||
| * a new structure. Normally, ENGINEs don't declare this flag so | |||
| * ENGINE_by_id() just increments the existing ENGINE's structural reference | |||
| * count. | |||
| */ | |||
| # define ENGINE_FLAGS_BY_ID_COPY (int)0x0004 | |||
| /* | |||
| * This flag if for an ENGINE that does not want its methods registered as | |||
| * part of ENGINE_register_all_complete() for example if the methods are not | |||
| * usable as default methods. | |||
| */ | |||
| # define ENGINE_FLAGS_NO_REGISTER_ALL (int)0x0008 | |||
| /* | |||
| * ENGINEs can support their own command types, and these flags are used in | |||
| * ENGINE_CTRL_GET_CMD_FLAGS to indicate to the caller what kind of input | |||
| * each command expects. Currently only numeric and string input is | |||
| * supported. If a control command supports none of the _NUMERIC, _STRING, or | |||
| * _NO_INPUT options, then it is regarded as an "internal" control command - | |||
| * and not for use in config setting situations. As such, they're not | |||
| * available to the ENGINE_ctrl_cmd_string() function, only raw ENGINE_ctrl() | |||
| * access. Changes to this list of 'command types' should be reflected | |||
| * carefully in ENGINE_cmd_is_executable() and ENGINE_ctrl_cmd_string(). | |||
| */ | |||
| /* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */ | |||
| # define ENGINE_CMD_FLAG_NUMERIC (unsigned int)0x0001 | |||
| /* | |||
| * accepts string input (cast from 'void*' to 'const char *', 4th parameter | |||
| * to ENGINE_ctrl) | |||
| */ | |||
| # define ENGINE_CMD_FLAG_STRING (unsigned int)0x0002 | |||
| /* | |||
| * Indicates that the control command takes *no* input. Ie. the control | |||
| * command is unparameterised. | |||
| */ | |||
| # define ENGINE_CMD_FLAG_NO_INPUT (unsigned int)0x0004 | |||
| /* | |||
| * Indicates that the control command is internal. This control command won't | |||
| * be shown in any output, and is only usable through the ENGINE_ctrl_cmd() | |||
| * function. | |||
| */ | |||
| # define ENGINE_CMD_FLAG_INTERNAL (unsigned int)0x0008 | |||
| /* | |||
| * NB: These 3 control commands are deprecated and should not be used. | |||
| * ENGINEs relying on these commands should compile conditional support for | |||
| * compatibility (eg. if these symbols are defined) but should also migrate | |||
| * the same functionality to their own ENGINE-specific control functions that | |||
| * can be "discovered" by calling applications. The fact these control | |||
| * commands wouldn't be "executable" (ie. usable by text-based config) | |||
| * doesn't change the fact that application code can find and use them | |||
| * without requiring per-ENGINE hacking. | |||
| */ | |||
| /* | |||
| * These flags are used to tell the ctrl function what should be done. All | |||
| * command numbers are shared between all engines, even if some don't make | |||
| * sense to some engines. In such a case, they do nothing but return the | |||
| * error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED. | |||
| */ | |||
| # define ENGINE_CTRL_SET_LOGSTREAM 1 | |||
| # define ENGINE_CTRL_SET_PASSWORD_CALLBACK 2 | |||
| # define ENGINE_CTRL_HUP 3/* Close and reinitialise | |||
| * any handles/connections | |||
| * etc. */ | |||
| # define ENGINE_CTRL_SET_USER_INTERFACE 4/* Alternative to callback */ | |||
| # define ENGINE_CTRL_SET_CALLBACK_DATA 5/* User-specific data, used | |||
| * when calling the password | |||
| * callback and the user | |||
| * interface */ | |||
| # define ENGINE_CTRL_LOAD_CONFIGURATION 6/* Load a configuration, | |||
| * given a string that | |||
| * represents a file name | |||
| * or so */ | |||
| # define ENGINE_CTRL_LOAD_SECTION 7/* Load data from a given | |||
| * section in the already | |||
| * loaded configuration */ | |||
| /* | |||
| * These control commands allow an application to deal with an arbitrary | |||
| * engine in a dynamic way. Warn: Negative return values indicate errors FOR | |||
| * THESE COMMANDS because zero is used to indicate 'end-of-list'. Other | |||
| * commands, including ENGINE-specific command types, return zero for an | |||
| * error. An ENGINE can choose to implement these ctrl functions, and can | |||
| * internally manage things however it chooses - it does so by setting the | |||
| * ENGINE_FLAGS_MANUAL_CMD_CTRL flag (using ENGINE_set_flags()). Otherwise | |||
| * the ENGINE_ctrl() code handles this on the ENGINE's behalf using the | |||
| * cmd_defns data (set using ENGINE_set_cmd_defns()). This means an ENGINE's | |||
| * ctrl() handler need only implement its own commands - the above "meta" | |||
| * commands will be taken care of. | |||
| */ | |||
| /* | |||
| * Returns non-zero if the supplied ENGINE has a ctrl() handler. If "not", | |||
| * then all the remaining control commands will return failure, so it is | |||
| * worth checking this first if the caller is trying to "discover" the | |||
| * engine's capabilities and doesn't want errors generated unnecessarily. | |||
| */ | |||
| # define ENGINE_CTRL_HAS_CTRL_FUNCTION 10 | |||
| /* | |||
| * Returns a positive command number for the first command supported by the | |||
| * engine. Returns zero if no ctrl commands are supported. | |||
| */ | |||
| # define ENGINE_CTRL_GET_FIRST_CMD_TYPE 11 | |||
| /* | |||
| * The 'long' argument specifies a command implemented by the engine, and the | |||
| * return value is the next command supported, or zero if there are no more. | |||
| */ | |||
| # define ENGINE_CTRL_GET_NEXT_CMD_TYPE 12 | |||
| /* | |||
| * The 'void*' argument is a command name (cast from 'const char *'), and the | |||
| * return value is the command that corresponds to it. | |||
| */ | |||
| # define ENGINE_CTRL_GET_CMD_FROM_NAME 13 | |||
| /* | |||
| * The next two allow a command to be converted into its corresponding string | |||
| * form. In each case, the 'long' argument supplies the command. In the | |||
| * NAME_LEN case, the return value is the length of the command name (not | |||
| * counting a trailing EOL). In the NAME case, the 'void*' argument must be a | |||
| * string buffer large enough, and it will be populated with the name of the | |||
| * command (WITH a trailing EOL). | |||
| */ | |||
| # define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD 14 | |||
| # define ENGINE_CTRL_GET_NAME_FROM_CMD 15 | |||
| /* The next two are similar but give a "short description" of a command. */ | |||
| # define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD 16 | |||
| # define ENGINE_CTRL_GET_DESC_FROM_CMD 17 | |||
| /* | |||
| * With this command, the return value is the OR'd combination of | |||
| * ENGINE_CMD_FLAG_*** values that indicate what kind of input a given | |||
| * engine-specific ctrl command expects. | |||
| */ | |||
| # define ENGINE_CTRL_GET_CMD_FLAGS 18 | |||
| /* | |||
| * ENGINE implementations should start the numbering of their own control | |||
| * commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc). | |||
| */ | |||
| # define ENGINE_CMD_BASE 200 | |||
| /* | |||
| * NB: These 2 nCipher "chil" control commands are deprecated, and their | |||
| * functionality is now available through ENGINE-specific control commands | |||
| * (exposed through the above-mentioned 'CMD'-handling). Code using these 2 | |||
| * commands should be migrated to the more general command handling before | |||
| * these are removed. | |||
| */ | |||
| /* Flags specific to the nCipher "chil" engine */ | |||
| # define ENGINE_CTRL_CHIL_SET_FORKCHECK 100 | |||
| /* | |||
| * Depending on the value of the (long)i argument, this sets or | |||
| * unsets the SimpleForkCheck flag in the CHIL API to enable or | |||
| * disable checking and workarounds for applications that fork(). | |||
| */ | |||
| # define ENGINE_CTRL_CHIL_NO_LOCKING 101 | |||
| /* | |||
| * This prevents the initialisation function from providing mutex | |||
| * callbacks to the nCipher library. | |||
| */ | |||
| /* | |||
| * If an ENGINE supports its own specific control commands and wishes the | |||
| * framework to handle the above 'ENGINE_CMD_***'-manipulation commands on | |||
| * its behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN | |||
| * entries to ENGINE_set_cmd_defns(). It should also implement a ctrl() | |||
| * handler that supports the stated commands (ie. the "cmd_num" entries as | |||
| * described by the array). NB: The array must be ordered in increasing order | |||
| * of cmd_num. "null-terminated" means that the last ENGINE_CMD_DEFN element | |||
| * has cmd_num set to zero and/or cmd_name set to NULL. | |||
| */ | |||
| typedef struct ENGINE_CMD_DEFN_st { | |||
| unsigned int cmd_num; /* The command number */ | |||
| const char *cmd_name; /* The command name itself */ | |||
| const char *cmd_desc; /* A short description of the command */ | |||
| unsigned int cmd_flags; /* The input the command expects */ | |||
| } ENGINE_CMD_DEFN; | |||
| /* Generic function pointer */ | |||
| typedef int (*ENGINE_GEN_FUNC_PTR) (void); | |||
| /* Generic function pointer taking no arguments */ | |||
| typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *); | |||
| /* Specific control function pointer */ | |||
| typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *, | |||
| void (*f) (void)); | |||
| /* Generic load_key function pointer */ | |||
| typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *, | |||
| UI_METHOD *ui_method, | |||
| void *callback_data); | |||
| typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl, | |||
| STACK_OF(X509_NAME) *ca_dn, | |||
| X509 **pcert, EVP_PKEY **pkey, | |||
| STACK_OF(X509) **pother, | |||
| UI_METHOD *ui_method, | |||
| void *callback_data); | |||
| /*- | |||
| * These callback types are for an ENGINE's handler for cipher and digest logic. | |||
| * These handlers have these prototypes; | |||
| * int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid); | |||
| * int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid); | |||
| * Looking at how to implement these handlers in the case of cipher support, if | |||
| * the framework wants the EVP_CIPHER for 'nid', it will call; | |||
| * foo(e, &p_evp_cipher, NULL, nid); (return zero for failure) | |||
| * If the framework wants a list of supported 'nid's, it will call; | |||
| * foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error) | |||
| */ | |||
| /* | |||
| * Returns to a pointer to the array of supported cipher 'nid's. If the | |||
| * second parameter is non-NULL it is set to the size of the returned array. | |||
| */ | |||
| typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **, | |||
| const int **, int); | |||
| typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **, | |||
| int); | |||
| typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **, | |||
| const int **, int); | |||
| typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **, | |||
| const int **, int); | |||
| /* | |||
| * STRUCTURE functions ... all of these functions deal with pointers to | |||
| * ENGINE structures where the pointers have a "structural reference". This | |||
| * means that their reference is to allowed access to the structure but it | |||
| * does not imply that the structure is functional. To simply increment or | |||
| * decrement the structural reference count, use ENGINE_by_id and | |||
| * ENGINE_free. NB: This is not required when iterating using ENGINE_get_next | |||
| * as it will automatically decrement the structural reference count of the | |||
| * "current" ENGINE and increment the structural reference count of the | |||
| * ENGINE it returns (unless it is NULL). | |||
| */ | |||
| /* Get the first/last "ENGINE" type available. */ | |||
| ENGINE *ENGINE_get_first(void); | |||
| ENGINE *ENGINE_get_last(void); | |||
| /* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */ | |||
| ENGINE *ENGINE_get_next(ENGINE *e); | |||
| ENGINE *ENGINE_get_prev(ENGINE *e); | |||
| /* Add another "ENGINE" type into the array. */ | |||
| int ENGINE_add(ENGINE *e); | |||
| /* Remove an existing "ENGINE" type from the array. */ | |||
| int ENGINE_remove(ENGINE *e); | |||
| /* Retrieve an engine from the list by its unique "id" value. */ | |||
| ENGINE *ENGINE_by_id(const char *id); | |||
| #if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define ENGINE_load_openssl() \ | |||
| OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_OPENSSL, NULL) | |||
| # define ENGINE_load_dynamic() \ | |||
| OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL) | |||
| # ifndef OPENSSL_NO_STATIC_ENGINE | |||
| # define ENGINE_load_padlock() \ | |||
| OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_PADLOCK, NULL) | |||
| # define ENGINE_load_capi() \ | |||
| OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL) | |||
| # define ENGINE_load_afalg() \ | |||
| OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL) | |||
| # endif | |||
| # define ENGINE_load_cryptodev() \ | |||
| OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL) | |||
| # define ENGINE_load_rdrand() \ | |||
| OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_RDRAND, NULL) | |||
| #endif | |||
| void ENGINE_load_builtin_engines(void); | |||
| /* | |||
| * Get and set global flags (ENGINE_TABLE_FLAG_***) for the implementation | |||
| * "registry" handling. | |||
| */ | |||
| unsigned int ENGINE_get_table_flags(void); | |||
| void ENGINE_set_table_flags(unsigned int flags); | |||
| /*- Manage registration of ENGINEs per "table". For each type, there are 3 | |||
| * functions; | |||
| * ENGINE_register_***(e) - registers the implementation from 'e' (if it has one) | |||
| * ENGINE_unregister_***(e) - unregister the implementation from 'e' | |||
| * ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list | |||
| * Cleanup is automatically registered from each table when required. | |||
| */ | |||
| int ENGINE_register_RSA(ENGINE *e); | |||
| void ENGINE_unregister_RSA(ENGINE *e); | |||
| void ENGINE_register_all_RSA(void); | |||
| int ENGINE_register_DSA(ENGINE *e); | |||
| void ENGINE_unregister_DSA(ENGINE *e); | |||
| void ENGINE_register_all_DSA(void); | |||
| int ENGINE_register_EC(ENGINE *e); | |||
| void ENGINE_unregister_EC(ENGINE *e); | |||
| void ENGINE_register_all_EC(void); | |||
| int ENGINE_register_DH(ENGINE *e); | |||
| void ENGINE_unregister_DH(ENGINE *e); | |||
| void ENGINE_register_all_DH(void); | |||
| int ENGINE_register_RAND(ENGINE *e); | |||
| void ENGINE_unregister_RAND(ENGINE *e); | |||
| void ENGINE_register_all_RAND(void); | |||
| int ENGINE_register_ciphers(ENGINE *e); | |||
| void ENGINE_unregister_ciphers(ENGINE *e); | |||
| void ENGINE_register_all_ciphers(void); | |||
| int ENGINE_register_digests(ENGINE *e); | |||
| void ENGINE_unregister_digests(ENGINE *e); | |||
| void ENGINE_register_all_digests(void); | |||
| int ENGINE_register_pkey_meths(ENGINE *e); | |||
| void ENGINE_unregister_pkey_meths(ENGINE *e); | |||
| void ENGINE_register_all_pkey_meths(void); | |||
| int ENGINE_register_pkey_asn1_meths(ENGINE *e); | |||
| void ENGINE_unregister_pkey_asn1_meths(ENGINE *e); | |||
| void ENGINE_register_all_pkey_asn1_meths(void); | |||
| /* | |||
| * These functions register all support from the above categories. Note, use | |||
| * of these functions can result in static linkage of code your application | |||
| * may not need. If you only need a subset of functionality, consider using | |||
| * more selective initialisation. | |||
| */ | |||
| int ENGINE_register_complete(ENGINE *e); | |||
| int ENGINE_register_all_complete(void); | |||
| /* | |||
| * Send parameterised control commands to the engine. The possibilities to | |||
| * send down an integer, a pointer to data or a function pointer are | |||
| * provided. Any of the parameters may or may not be NULL, depending on the | |||
| * command number. In actuality, this function only requires a structural | |||
| * (rather than functional) reference to an engine, but many control commands | |||
| * may require the engine be functional. The caller should be aware of trying | |||
| * commands that require an operational ENGINE, and only use functional | |||
| * references in such situations. | |||
| */ | |||
| int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void)); | |||
| /* | |||
| * This function tests if an ENGINE-specific command is usable as a | |||
| * "setting". Eg. in an application's config file that gets processed through | |||
| * ENGINE_ctrl_cmd_string(). If this returns zero, it is not available to | |||
| * ENGINE_ctrl_cmd_string(), only ENGINE_ctrl(). | |||
| */ | |||
| int ENGINE_cmd_is_executable(ENGINE *e, int cmd); | |||
| /* | |||
| * This function works like ENGINE_ctrl() with the exception of taking a | |||
| * command name instead of a command number, and can handle optional | |||
| * commands. See the comment on ENGINE_ctrl_cmd_string() for an explanation | |||
| * on how to use the cmd_name and cmd_optional. | |||
| */ | |||
| int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name, | |||
| long i, void *p, void (*f) (void), int cmd_optional); | |||
| /* | |||
| * This function passes a command-name and argument to an ENGINE. The | |||
| * cmd_name is converted to a command number and the control command is | |||
| * called using 'arg' as an argument (unless the ENGINE doesn't support such | |||
| * a command, in which case no control command is called). The command is | |||
| * checked for input flags, and if necessary the argument will be converted | |||
| * to a numeric value. If cmd_optional is non-zero, then if the ENGINE | |||
| * doesn't support the given cmd_name the return value will be success | |||
| * anyway. This function is intended for applications to use so that users | |||
| * (or config files) can supply engine-specific config data to the ENGINE at | |||
| * run-time to control behaviour of specific engines. As such, it shouldn't | |||
| * be used for calling ENGINE_ctrl() functions that return data, deal with | |||
| * binary data, or that are otherwise supposed to be used directly through | |||
| * ENGINE_ctrl() in application code. Any "return" data from an ENGINE_ctrl() | |||
| * operation in this function will be lost - the return value is interpreted | |||
| * as failure if the return value is zero, success otherwise, and this | |||
| * function returns a boolean value as a result. In other words, vendors of | |||
| * 'ENGINE'-enabled devices should write ENGINE implementations with | |||
| * parameterisations that work in this scheme, so that compliant ENGINE-based | |||
| * applications can work consistently with the same configuration for the | |||
| * same ENGINE-enabled devices, across applications. | |||
| */ | |||
| int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg, | |||
| int cmd_optional); | |||
| /* | |||
| * These functions are useful for manufacturing new ENGINE structures. They | |||
| * don't address reference counting at all - one uses them to populate an | |||
| * ENGINE structure with personalised implementations of things prior to | |||
| * using it directly or adding it to the builtin ENGINE list in OpenSSL. | |||
| * These are also here so that the ENGINE structure doesn't have to be | |||
| * exposed and break binary compatibility! | |||
| */ | |||
| ENGINE *ENGINE_new(void); | |||
| int ENGINE_free(ENGINE *e); | |||
| int ENGINE_up_ref(ENGINE *e); | |||
| int ENGINE_set_id(ENGINE *e, const char *id); | |||
| int ENGINE_set_name(ENGINE *e, const char *name); | |||
| int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth); | |||
| int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth); | |||
| int ENGINE_set_EC(ENGINE *e, const EC_KEY_METHOD *ecdsa_meth); | |||
| int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth); | |||
| int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth); | |||
| int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f); | |||
| int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f); | |||
| int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f); | |||
| int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f); | |||
| int ENGINE_set_load_privkey_function(ENGINE *e, | |||
| ENGINE_LOAD_KEY_PTR loadpriv_f); | |||
| int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f); | |||
| int ENGINE_set_load_ssl_client_cert_function(ENGINE *e, | |||
| ENGINE_SSL_CLIENT_CERT_PTR | |||
| loadssl_f); | |||
| int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f); | |||
| int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f); | |||
| int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f); | |||
| int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f); | |||
| int ENGINE_set_flags(ENGINE *e, int flags); | |||
| int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns); | |||
| /* These functions allow control over any per-structure ENGINE data. */ | |||
| #define ENGINE_get_ex_new_index(l, p, newf, dupf, freef) \ | |||
| CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ENGINE, l, p, newf, dupf, freef) | |||
| int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg); | |||
| void *ENGINE_get_ex_data(const ENGINE *e, int idx); | |||
| #if OPENSSL_API_COMPAT < 0x10100000L | |||
| /* | |||
| * This function previously cleaned up anything that needs it. Auto-deinit will | |||
| * now take care of it so it is no longer required to call this function. | |||
| */ | |||
| # define ENGINE_cleanup() while(0) continue | |||
| #endif | |||
| /* | |||
| * These return values from within the ENGINE structure. These can be useful | |||
| * with functional references as well as structural references - it depends | |||
| * which you obtained. Using the result for functional purposes if you only | |||
| * obtained a structural reference may be problematic! | |||
| */ | |||
| const char *ENGINE_get_id(const ENGINE *e); | |||
| const char *ENGINE_get_name(const ENGINE *e); | |||
| const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e); | |||
| const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e); | |||
| const EC_KEY_METHOD *ENGINE_get_EC(const ENGINE *e); | |||
| const DH_METHOD *ENGINE_get_DH(const ENGINE *e); | |||
| const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e); | |||
| ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e); | |||
| ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e); | |||
| ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e); | |||
| ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e); | |||
| ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e); | |||
| ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e); | |||
| ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE | |||
| *e); | |||
| ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e); | |||
| ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e); | |||
| ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e); | |||
| ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e); | |||
| const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid); | |||
| const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid); | |||
| const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid); | |||
| const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid); | |||
| const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e, | |||
| const char *str, | |||
| int len); | |||
| const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe, | |||
| const char *str, | |||
| int len); | |||
| const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e); | |||
| int ENGINE_get_flags(const ENGINE *e); | |||
| /* | |||
| * FUNCTIONAL functions. These functions deal with ENGINE structures that | |||
| * have (or will) be initialised for use. Broadly speaking, the structural | |||
| * functions are useful for iterating the list of available engine types, | |||
| * creating new engine types, and other "list" operations. These functions | |||
| * actually deal with ENGINEs that are to be used. As such these functions | |||
| * can fail (if applicable) when particular engines are unavailable - eg. if | |||
| * a hardware accelerator is not attached or not functioning correctly. Each | |||
| * ENGINE has 2 reference counts; structural and functional. Every time a | |||
| * functional reference is obtained or released, a corresponding structural | |||
| * reference is automatically obtained or released too. | |||
| */ | |||
| /* | |||
| * Initialise a engine type for use (or up its reference count if it's | |||
| * already in use). This will fail if the engine is not currently operational | |||
| * and cannot initialise. | |||
| */ | |||
| int ENGINE_init(ENGINE *e); | |||
| /* | |||
| * Free a functional reference to a engine type. This does not require a | |||
| * corresponding call to ENGINE_free as it also releases a structural | |||
| * reference. | |||
| */ | |||
| int ENGINE_finish(ENGINE *e); | |||
| /* | |||
| * The following functions handle keys that are stored in some secondary | |||
| * location, handled by the engine. The storage may be on a card or | |||
| * whatever. | |||
| */ | |||
| EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id, | |||
| UI_METHOD *ui_method, void *callback_data); | |||
| EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id, | |||
| UI_METHOD *ui_method, void *callback_data); | |||
| int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, | |||
| STACK_OF(X509_NAME) *ca_dn, X509 **pcert, | |||
| EVP_PKEY **ppkey, STACK_OF(X509) **pother, | |||
| UI_METHOD *ui_method, void *callback_data); | |||
| /* | |||
| * This returns a pointer for the current ENGINE structure that is (by | |||
| * default) performing any RSA operations. The value returned is an | |||
| * incremented reference, so it should be free'd (ENGINE_finish) before it is | |||
| * discarded. | |||
| */ | |||
| ENGINE *ENGINE_get_default_RSA(void); | |||
| /* Same for the other "methods" */ | |||
| ENGINE *ENGINE_get_default_DSA(void); | |||
| ENGINE *ENGINE_get_default_EC(void); | |||
| ENGINE *ENGINE_get_default_DH(void); | |||
| ENGINE *ENGINE_get_default_RAND(void); | |||
| /* | |||
| * These functions can be used to get a functional reference to perform | |||
| * ciphering or digesting corresponding to "nid". | |||
| */ | |||
| ENGINE *ENGINE_get_cipher_engine(int nid); | |||
| ENGINE *ENGINE_get_digest_engine(int nid); | |||
| ENGINE *ENGINE_get_pkey_meth_engine(int nid); | |||
| ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid); | |||
| /* | |||
| * This sets a new default ENGINE structure for performing RSA operations. If | |||
| * the result is non-zero (success) then the ENGINE structure will have had | |||
| * its reference count up'd so the caller should still free their own | |||
| * reference 'e'. | |||
| */ | |||
| int ENGINE_set_default_RSA(ENGINE *e); | |||
| int ENGINE_set_default_string(ENGINE *e, const char *def_list); | |||
| /* Same for the other "methods" */ | |||
| int ENGINE_set_default_DSA(ENGINE *e); | |||
| int ENGINE_set_default_EC(ENGINE *e); | |||
| int ENGINE_set_default_DH(ENGINE *e); | |||
| int ENGINE_set_default_RAND(ENGINE *e); | |||
| int ENGINE_set_default_ciphers(ENGINE *e); | |||
| int ENGINE_set_default_digests(ENGINE *e); | |||
| int ENGINE_set_default_pkey_meths(ENGINE *e); | |||
| int ENGINE_set_default_pkey_asn1_meths(ENGINE *e); | |||
| /* | |||
| * The combination "set" - the flags are bitwise "OR"d from the | |||
| * ENGINE_METHOD_*** defines above. As with the "ENGINE_register_complete()" | |||
| * function, this function can result in unnecessary static linkage. If your | |||
| * application requires only specific functionality, consider using more | |||
| * selective functions. | |||
| */ | |||
| int ENGINE_set_default(ENGINE *e, unsigned int flags); | |||
| void ENGINE_add_conf_module(void); | |||
| /* Deprecated functions ... */ | |||
| /* int ENGINE_clear_defaults(void); */ | |||
| /**************************/ | |||
| /* DYNAMIC ENGINE SUPPORT */ | |||
| /**************************/ | |||
| /* Binary/behaviour compatibility levels */ | |||
| # define OSSL_DYNAMIC_VERSION (unsigned long)0x00030000 | |||
| /* | |||
| * Binary versions older than this are too old for us (whether we're a loader | |||
| * or a loadee) | |||
| */ | |||
| # define OSSL_DYNAMIC_OLDEST (unsigned long)0x00030000 | |||
| /* | |||
| * When compiling an ENGINE entirely as an external shared library, loadable | |||
| * by the "dynamic" ENGINE, these types are needed. The 'dynamic_fns' | |||
| * structure type provides the calling application's (or library's) error | |||
| * functionality and memory management function pointers to the loaded | |||
| * library. These should be used/set in the loaded library code so that the | |||
| * loading application's 'state' will be used/changed in all operations. The | |||
| * 'static_state' pointer allows the loaded library to know if it shares the | |||
| * same static data as the calling application (or library), and thus whether | |||
| * these callbacks need to be set or not. | |||
| */ | |||
| typedef void *(*dyn_MEM_malloc_fn) (size_t, const char *, int); | |||
| typedef void *(*dyn_MEM_realloc_fn) (void *, size_t, const char *, int); | |||
| typedef void (*dyn_MEM_free_fn) (void *, const char *, int); | |||
| typedef struct st_dynamic_MEM_fns { | |||
| dyn_MEM_malloc_fn malloc_fn; | |||
| dyn_MEM_realloc_fn realloc_fn; | |||
| dyn_MEM_free_fn free_fn; | |||
| } dynamic_MEM_fns; | |||
| /* | |||
| * FIXME: Perhaps the memory and locking code (crypto.h) should declare and | |||
| * use these types so we (and any other dependent code) can simplify a bit?? | |||
| */ | |||
| /* The top-level structure */ | |||
| typedef struct st_dynamic_fns { | |||
| void *static_state; | |||
| dynamic_MEM_fns mem_fns; | |||
| } dynamic_fns; | |||
| /* | |||
| * The version checking function should be of this prototype. NB: The | |||
| * ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading | |||
| * code. If this function returns zero, it indicates a (potential) version | |||
| * incompatibility and the loaded library doesn't believe it can proceed. | |||
| * Otherwise, the returned value is the (latest) version supported by the | |||
| * loading library. The loader may still decide that the loaded code's | |||
| * version is unsatisfactory and could veto the load. The function is | |||
| * expected to be implemented with the symbol name "v_check", and a default | |||
| * implementation can be fully instantiated with | |||
| * IMPLEMENT_DYNAMIC_CHECK_FN(). | |||
| */ | |||
| typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version); | |||
| # define IMPLEMENT_DYNAMIC_CHECK_FN() \ | |||
| OPENSSL_EXPORT unsigned long v_check(unsigned long v); \ | |||
| OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \ | |||
| if (v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \ | |||
| return 0; } | |||
| /* | |||
| * This function is passed the ENGINE structure to initialise with its own | |||
| * function and command settings. It should not adjust the structural or | |||
| * functional reference counts. If this function returns zero, (a) the load | |||
| * will be aborted, (b) the previous ENGINE state will be memcpy'd back onto | |||
| * the structure, and (c) the shared library will be unloaded. So | |||
| * implementations should do their own internal cleanup in failure | |||
| * circumstances otherwise they could leak. The 'id' parameter, if non-NULL, | |||
| * represents the ENGINE id that the loader is looking for. If this is NULL, | |||
| * the shared library can choose to return failure or to initialise a | |||
| * 'default' ENGINE. If non-NULL, the shared library must initialise only an | |||
| * ENGINE matching the passed 'id'. The function is expected to be | |||
| * implemented with the symbol name "bind_engine". A standard implementation | |||
| * can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where the parameter | |||
| * 'fn' is a callback function that populates the ENGINE structure and | |||
| * returns an int value (zero for failure). 'fn' should have prototype; | |||
| * [static] int fn(ENGINE *e, const char *id); | |||
| */ | |||
| typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id, | |||
| const dynamic_fns *fns); | |||
| # define IMPLEMENT_DYNAMIC_BIND_FN(fn) \ | |||
| OPENSSL_EXPORT \ | |||
| int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); \ | |||
| OPENSSL_EXPORT \ | |||
| int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \ | |||
| if (ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \ | |||
| CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn, \ | |||
| fns->mem_fns.realloc_fn, \ | |||
| fns->mem_fns.free_fn); \ | |||
| skip_cbs: \ | |||
| if (!fn(e, id)) return 0; \ | |||
| return 1; } | |||
| /* | |||
| * If the loading application (or library) and the loaded ENGINE library | |||
| * share the same static data (eg. they're both dynamically linked to the | |||
| * same libcrypto.so) we need a way to avoid trying to set system callbacks - | |||
| * this would fail, and for the same reason that it's unnecessary to try. If | |||
| * the loaded ENGINE has (or gets from through the loader) its own copy of | |||
| * the libcrypto static data, we will need to set the callbacks. The easiest | |||
| * way to detect this is to have a function that returns a pointer to some | |||
| * static data and let the loading application and loaded ENGINE compare | |||
| * their respective values. | |||
| */ | |||
| void *ENGINE_get_static_state(void); | |||
| # if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) | |||
| DEPRECATEDIN_1_1_0(void ENGINE_setup_bsd_cryptodev(void)) | |||
| # endif | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,111 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_ENGINEERR_H | |||
| # define HEADER_ENGINEERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_ENGINE | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_ENGINE_strings(void); | |||
| /* | |||
| * ENGINE function codes. | |||
| */ | |||
| # define ENGINE_F_DIGEST_UPDATE 198 | |||
| # define ENGINE_F_DYNAMIC_CTRL 180 | |||
| # define ENGINE_F_DYNAMIC_GET_DATA_CTX 181 | |||
| # define ENGINE_F_DYNAMIC_LOAD 182 | |||
| # define ENGINE_F_DYNAMIC_SET_DATA_CTX 183 | |||
| # define ENGINE_F_ENGINE_ADD 105 | |||
| # define ENGINE_F_ENGINE_BY_ID 106 | |||
| # define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE 170 | |||
| # define ENGINE_F_ENGINE_CTRL 142 | |||
| # define ENGINE_F_ENGINE_CTRL_CMD 178 | |||
| # define ENGINE_F_ENGINE_CTRL_CMD_STRING 171 | |||
| # define ENGINE_F_ENGINE_FINISH 107 | |||
| # define ENGINE_F_ENGINE_GET_CIPHER 185 | |||
| # define ENGINE_F_ENGINE_GET_DIGEST 186 | |||
| # define ENGINE_F_ENGINE_GET_FIRST 195 | |||
| # define ENGINE_F_ENGINE_GET_LAST 196 | |||
| # define ENGINE_F_ENGINE_GET_NEXT 115 | |||
| # define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH 193 | |||
| # define ENGINE_F_ENGINE_GET_PKEY_METH 192 | |||
| # define ENGINE_F_ENGINE_GET_PREV 116 | |||
| # define ENGINE_F_ENGINE_INIT 119 | |||
| # define ENGINE_F_ENGINE_LIST_ADD 120 | |||
| # define ENGINE_F_ENGINE_LIST_REMOVE 121 | |||
| # define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY 150 | |||
| # define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY 151 | |||
| # define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT 194 | |||
| # define ENGINE_F_ENGINE_NEW 122 | |||
| # define ENGINE_F_ENGINE_PKEY_ASN1_FIND_STR 197 | |||
| # define ENGINE_F_ENGINE_REMOVE 123 | |||
| # define ENGINE_F_ENGINE_SET_DEFAULT_STRING 189 | |||
| # define ENGINE_F_ENGINE_SET_ID 129 | |||
| # define ENGINE_F_ENGINE_SET_NAME 130 | |||
| # define ENGINE_F_ENGINE_TABLE_REGISTER 184 | |||
| # define ENGINE_F_ENGINE_UNLOCKED_FINISH 191 | |||
| # define ENGINE_F_ENGINE_UP_REF 190 | |||
| # define ENGINE_F_INT_CLEANUP_ITEM 199 | |||
| # define ENGINE_F_INT_CTRL_HELPER 172 | |||
| # define ENGINE_F_INT_ENGINE_CONFIGURE 188 | |||
| # define ENGINE_F_INT_ENGINE_MODULE_INIT 187 | |||
| # define ENGINE_F_OSSL_HMAC_INIT 200 | |||
| /* | |||
| * ENGINE reason codes. | |||
| */ | |||
| # define ENGINE_R_ALREADY_LOADED 100 | |||
| # define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER 133 | |||
| # define ENGINE_R_CMD_NOT_EXECUTABLE 134 | |||
| # define ENGINE_R_COMMAND_TAKES_INPUT 135 | |||
| # define ENGINE_R_COMMAND_TAKES_NO_INPUT 136 | |||
| # define ENGINE_R_CONFLICTING_ENGINE_ID 103 | |||
| # define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED 119 | |||
| # define ENGINE_R_DSO_FAILURE 104 | |||
| # define ENGINE_R_DSO_NOT_FOUND 132 | |||
| # define ENGINE_R_ENGINES_SECTION_ERROR 148 | |||
| # define ENGINE_R_ENGINE_CONFIGURATION_ERROR 102 | |||
| # define ENGINE_R_ENGINE_IS_NOT_IN_LIST 105 | |||
| # define ENGINE_R_ENGINE_SECTION_ERROR 149 | |||
| # define ENGINE_R_FAILED_LOADING_PRIVATE_KEY 128 | |||
| # define ENGINE_R_FAILED_LOADING_PUBLIC_KEY 129 | |||
| # define ENGINE_R_FINISH_FAILED 106 | |||
| # define ENGINE_R_ID_OR_NAME_MISSING 108 | |||
| # define ENGINE_R_INIT_FAILED 109 | |||
| # define ENGINE_R_INTERNAL_LIST_ERROR 110 | |||
| # define ENGINE_R_INVALID_ARGUMENT 143 | |||
| # define ENGINE_R_INVALID_CMD_NAME 137 | |||
| # define ENGINE_R_INVALID_CMD_NUMBER 138 | |||
| # define ENGINE_R_INVALID_INIT_VALUE 151 | |||
| # define ENGINE_R_INVALID_STRING 150 | |||
| # define ENGINE_R_NOT_INITIALISED 117 | |||
| # define ENGINE_R_NOT_LOADED 112 | |||
| # define ENGINE_R_NO_CONTROL_FUNCTION 120 | |||
| # define ENGINE_R_NO_INDEX 144 | |||
| # define ENGINE_R_NO_LOAD_FUNCTION 125 | |||
| # define ENGINE_R_NO_REFERENCE 130 | |||
| # define ENGINE_R_NO_SUCH_ENGINE 116 | |||
| # define ENGINE_R_UNIMPLEMENTED_CIPHER 146 | |||
| # define ENGINE_R_UNIMPLEMENTED_DIGEST 147 | |||
| # define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD 101 | |||
| # define ENGINE_R_VERSION_INCOMPATIBILITY 145 | |||
| # endif | |||
| #endif | |||
| @ -1,274 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_ERR_H | |||
| # define HEADER_ERR_H | |||
| # include <openssl/e_os2.h> | |||
| # ifndef OPENSSL_NO_STDIO | |||
| # include <stdio.h> | |||
| # include <stdlib.h> | |||
| # endif | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/bio.h> | |||
| # include <openssl/lhash.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # ifndef OPENSSL_NO_ERR | |||
| # define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,d,e) | |||
| # else | |||
| # define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,NULL,0) | |||
| # endif | |||
| # include <errno.h> | |||
| # define ERR_TXT_MALLOCED 0x01 | |||
| # define ERR_TXT_STRING 0x02 | |||
| # define ERR_FLAG_MARK 0x01 | |||
| # define ERR_FLAG_CLEAR 0x02 | |||
| # define ERR_NUM_ERRORS 16 | |||
| typedef struct err_state_st { | |||
| int err_flags[ERR_NUM_ERRORS]; | |||
| unsigned long err_buffer[ERR_NUM_ERRORS]; | |||
| char *err_data[ERR_NUM_ERRORS]; | |||
| int err_data_flags[ERR_NUM_ERRORS]; | |||
| const char *err_file[ERR_NUM_ERRORS]; | |||
| int err_line[ERR_NUM_ERRORS]; | |||
| int top, bottom; | |||
| } ERR_STATE; | |||
| /* library */ | |||
| # define ERR_LIB_NONE 1 | |||
| # define ERR_LIB_SYS 2 | |||
| # define ERR_LIB_BN 3 | |||
| # define ERR_LIB_RSA 4 | |||
| # define ERR_LIB_DH 5 | |||
| # define ERR_LIB_EVP 6 | |||
| # define ERR_LIB_BUF 7 | |||
| # define ERR_LIB_OBJ 8 | |||
| # define ERR_LIB_PEM 9 | |||
| # define ERR_LIB_DSA 10 | |||
| # define ERR_LIB_X509 11 | |||
| /* #define ERR_LIB_METH 12 */ | |||
| # define ERR_LIB_ASN1 13 | |||
| # define ERR_LIB_CONF 14 | |||
| # define ERR_LIB_CRYPTO 15 | |||
| # define ERR_LIB_EC 16 | |||
| # define ERR_LIB_SSL 20 | |||
| /* #define ERR_LIB_SSL23 21 */ | |||
| /* #define ERR_LIB_SSL2 22 */ | |||
| /* #define ERR_LIB_SSL3 23 */ | |||
| /* #define ERR_LIB_RSAREF 30 */ | |||
| /* #define ERR_LIB_PROXY 31 */ | |||
| # define ERR_LIB_BIO 32 | |||
| # define ERR_LIB_PKCS7 33 | |||
| # define ERR_LIB_X509V3 34 | |||
| # define ERR_LIB_PKCS12 35 | |||
| # define ERR_LIB_RAND 36 | |||
| # define ERR_LIB_DSO 37 | |||
| # define ERR_LIB_ENGINE 38 | |||
| # define ERR_LIB_OCSP 39 | |||
| # define ERR_LIB_UI 40 | |||
| # define ERR_LIB_COMP 41 | |||
| # define ERR_LIB_ECDSA 42 | |||
| # define ERR_LIB_ECDH 43 | |||
| # define ERR_LIB_OSSL_STORE 44 | |||
| # define ERR_LIB_FIPS 45 | |||
| # define ERR_LIB_CMS 46 | |||
| # define ERR_LIB_TS 47 | |||
| # define ERR_LIB_HMAC 48 | |||
| /* # define ERR_LIB_JPAKE 49 */ | |||
| # define ERR_LIB_CT 50 | |||
| # define ERR_LIB_ASYNC 51 | |||
| # define ERR_LIB_KDF 52 | |||
| # define ERR_LIB_SM2 53 | |||
| # define ERR_LIB_USER 128 | |||
| # define SYSerr(f,r) ERR_PUT_error(ERR_LIB_SYS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define BNerr(f,r) ERR_PUT_error(ERR_LIB_BN,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define RSAerr(f,r) ERR_PUT_error(ERR_LIB_RSA,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define DHerr(f,r) ERR_PUT_error(ERR_LIB_DH,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define EVPerr(f,r) ERR_PUT_error(ERR_LIB_EVP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define BUFerr(f,r) ERR_PUT_error(ERR_LIB_BUF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define OBJerr(f,r) ERR_PUT_error(ERR_LIB_OBJ,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define PEMerr(f,r) ERR_PUT_error(ERR_LIB_PEM,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define DSAerr(f,r) ERR_PUT_error(ERR_LIB_DSA,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define X509err(f,r) ERR_PUT_error(ERR_LIB_X509,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define ASN1err(f,r) ERR_PUT_error(ERR_LIB_ASN1,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define CONFerr(f,r) ERR_PUT_error(ERR_LIB_CONF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define CRYPTOerr(f,r) ERR_PUT_error(ERR_LIB_CRYPTO,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define ECerr(f,r) ERR_PUT_error(ERR_LIB_EC,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define SSLerr(f,r) ERR_PUT_error(ERR_LIB_SSL,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define BIOerr(f,r) ERR_PUT_error(ERR_LIB_BIO,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define PKCS7err(f,r) ERR_PUT_error(ERR_LIB_PKCS7,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define X509V3err(f,r) ERR_PUT_error(ERR_LIB_X509V3,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define PKCS12err(f,r) ERR_PUT_error(ERR_LIB_PKCS12,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define RANDerr(f,r) ERR_PUT_error(ERR_LIB_RAND,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define DSOerr(f,r) ERR_PUT_error(ERR_LIB_DSO,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define ENGINEerr(f,r) ERR_PUT_error(ERR_LIB_ENGINE,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define OCSPerr(f,r) ERR_PUT_error(ERR_LIB_OCSP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define UIerr(f,r) ERR_PUT_error(ERR_LIB_UI,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define COMPerr(f,r) ERR_PUT_error(ERR_LIB_COMP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define ECDSAerr(f,r) ERR_PUT_error(ERR_LIB_ECDSA,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define ECDHerr(f,r) ERR_PUT_error(ERR_LIB_ECDH,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define OSSL_STOREerr(f,r) ERR_PUT_error(ERR_LIB_OSSL_STORE,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define FIPSerr(f,r) ERR_PUT_error(ERR_LIB_FIPS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define CMSerr(f,r) ERR_PUT_error(ERR_LIB_CMS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define TSerr(f,r) ERR_PUT_error(ERR_LIB_TS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define HMACerr(f,r) ERR_PUT_error(ERR_LIB_HMAC,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define CTerr(f,r) ERR_PUT_error(ERR_LIB_CT,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define ASYNCerr(f,r) ERR_PUT_error(ERR_LIB_ASYNC,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define KDFerr(f,r) ERR_PUT_error(ERR_LIB_KDF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define SM2err(f,r) ERR_PUT_error(ERR_LIB_SM2,(f),(r),OPENSSL_FILE,OPENSSL_LINE) | |||
| # define ERR_PACK(l,f,r) ( \ | |||
| (((unsigned int)(l) & 0x0FF) << 24L) | \ | |||
| (((unsigned int)(f) & 0xFFF) << 12L) | \ | |||
| (((unsigned int)(r) & 0xFFF) ) ) | |||
| # define ERR_GET_LIB(l) (int)(((l) >> 24L) & 0x0FFL) | |||
| # define ERR_GET_FUNC(l) (int)(((l) >> 12L) & 0xFFFL) | |||
| # define ERR_GET_REASON(l) (int)( (l) & 0xFFFL) | |||
| # define ERR_FATAL_ERROR(l) (int)( (l) & ERR_R_FATAL) | |||
| /* OS functions */ | |||
| # define SYS_F_FOPEN 1 | |||
| # define SYS_F_CONNECT 2 | |||
| # define SYS_F_GETSERVBYNAME 3 | |||
| # define SYS_F_SOCKET 4 | |||
| # define SYS_F_IOCTLSOCKET 5 | |||
| # define SYS_F_BIND 6 | |||
| # define SYS_F_LISTEN 7 | |||
| # define SYS_F_ACCEPT 8 | |||
| # define SYS_F_WSASTARTUP 9/* Winsock stuff */ | |||
| # define SYS_F_OPENDIR 10 | |||
| # define SYS_F_FREAD 11 | |||
| # define SYS_F_GETADDRINFO 12 | |||
| # define SYS_F_GETNAMEINFO 13 | |||
| # define SYS_F_SETSOCKOPT 14 | |||
| # define SYS_F_GETSOCKOPT 15 | |||
| # define SYS_F_GETSOCKNAME 16 | |||
| # define SYS_F_GETHOSTBYNAME 17 | |||
| # define SYS_F_FFLUSH 18 | |||
| # define SYS_F_OPEN 19 | |||
| # define SYS_F_CLOSE 20 | |||
| # define SYS_F_IOCTL 21 | |||
| # define SYS_F_STAT 22 | |||
| # define SYS_F_FCNTL 23 | |||
| # define SYS_F_FSTAT 24 | |||
| /* reasons */ | |||
| # define ERR_R_SYS_LIB ERR_LIB_SYS/* 2 */ | |||
| # define ERR_R_BN_LIB ERR_LIB_BN/* 3 */ | |||
| # define ERR_R_RSA_LIB ERR_LIB_RSA/* 4 */ | |||
| # define ERR_R_DH_LIB ERR_LIB_DH/* 5 */ | |||
| # define ERR_R_EVP_LIB ERR_LIB_EVP/* 6 */ | |||
| # define ERR_R_BUF_LIB ERR_LIB_BUF/* 7 */ | |||
| # define ERR_R_OBJ_LIB ERR_LIB_OBJ/* 8 */ | |||
| # define ERR_R_PEM_LIB ERR_LIB_PEM/* 9 */ | |||
| # define ERR_R_DSA_LIB ERR_LIB_DSA/* 10 */ | |||
| # define ERR_R_X509_LIB ERR_LIB_X509/* 11 */ | |||
| # define ERR_R_ASN1_LIB ERR_LIB_ASN1/* 13 */ | |||
| # define ERR_R_EC_LIB ERR_LIB_EC/* 16 */ | |||
| # define ERR_R_BIO_LIB ERR_LIB_BIO/* 32 */ | |||
| # define ERR_R_PKCS7_LIB ERR_LIB_PKCS7/* 33 */ | |||
| # define ERR_R_X509V3_LIB ERR_LIB_X509V3/* 34 */ | |||
| # define ERR_R_ENGINE_LIB ERR_LIB_ENGINE/* 38 */ | |||
| # define ERR_R_UI_LIB ERR_LIB_UI/* 40 */ | |||
| # define ERR_R_ECDSA_LIB ERR_LIB_ECDSA/* 42 */ | |||
| # define ERR_R_OSSL_STORE_LIB ERR_LIB_OSSL_STORE/* 44 */ | |||
| # define ERR_R_NESTED_ASN1_ERROR 58 | |||
| # define ERR_R_MISSING_ASN1_EOS 63 | |||
| /* fatal error */ | |||
| # define ERR_R_FATAL 64 | |||
| # define ERR_R_MALLOC_FAILURE (1|ERR_R_FATAL) | |||
| # define ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED (2|ERR_R_FATAL) | |||
| # define ERR_R_PASSED_NULL_PARAMETER (3|ERR_R_FATAL) | |||
| # define ERR_R_INTERNAL_ERROR (4|ERR_R_FATAL) | |||
| # define ERR_R_DISABLED (5|ERR_R_FATAL) | |||
| # define ERR_R_INIT_FAIL (6|ERR_R_FATAL) | |||
| # define ERR_R_PASSED_INVALID_ARGUMENT (7) | |||
| # define ERR_R_OPERATION_FAIL (8|ERR_R_FATAL) | |||
| /* | |||
| * 99 is the maximum possible ERR_R_... code, higher values are reserved for | |||
| * the individual libraries | |||
| */ | |||
| typedef struct ERR_string_data_st { | |||
| unsigned long error; | |||
| const char *string; | |||
| } ERR_STRING_DATA; | |||
| DEFINE_LHASH_OF(ERR_STRING_DATA); | |||
| void ERR_put_error(int lib, int func, int reason, const char *file, int line); | |||
| void ERR_set_error_data(char *data, int flags); | |||
| unsigned long ERR_get_error(void); | |||
| unsigned long ERR_get_error_line(const char **file, int *line); | |||
| unsigned long ERR_get_error_line_data(const char **file, int *line, | |||
| const char **data, int *flags); | |||
| unsigned long ERR_peek_error(void); | |||
| unsigned long ERR_peek_error_line(const char **file, int *line); | |||
| unsigned long ERR_peek_error_line_data(const char **file, int *line, | |||
| const char **data, int *flags); | |||
| unsigned long ERR_peek_last_error(void); | |||
| unsigned long ERR_peek_last_error_line(const char **file, int *line); | |||
| unsigned long ERR_peek_last_error_line_data(const char **file, int *line, | |||
| const char **data, int *flags); | |||
| void ERR_clear_error(void); | |||
| char *ERR_error_string(unsigned long e, char *buf); | |||
| void ERR_error_string_n(unsigned long e, char *buf, size_t len); | |||
| const char *ERR_lib_error_string(unsigned long e); | |||
| const char *ERR_func_error_string(unsigned long e); | |||
| const char *ERR_reason_error_string(unsigned long e); | |||
| void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u), | |||
| void *u); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| void ERR_print_errors_fp(FILE *fp); | |||
| # endif | |||
| void ERR_print_errors(BIO *bp); | |||
| void ERR_add_error_data(int num, ...); | |||
| void ERR_add_error_vdata(int num, va_list args); | |||
| int ERR_load_strings(int lib, ERR_STRING_DATA *str); | |||
| int ERR_load_strings_const(const ERR_STRING_DATA *str); | |||
| int ERR_unload_strings(int lib, ERR_STRING_DATA *str); | |||
| int ERR_load_ERR_strings(void); | |||
| #if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define ERR_load_crypto_strings() \ | |||
| OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL) | |||
| # define ERR_free_strings() while(0) continue | |||
| #endif | |||
| DEPRECATEDIN_1_1_0(void ERR_remove_thread_state(void *)) | |||
| DEPRECATEDIN_1_0_0(void ERR_remove_state(unsigned long pid)) | |||
| ERR_STATE *ERR_get_state(void); | |||
| int ERR_get_next_error_library(void); | |||
| int ERR_set_mark(void); | |||
| int ERR_pop_to_mark(void); | |||
| int ERR_clear_last_mark(void); | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,205 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_EVPERR_H | |||
| # define HEADER_EVPERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_EVP_strings(void); | |||
| /* | |||
| * EVP function codes. | |||
| */ | |||
| # define EVP_F_AESNI_INIT_KEY 165 | |||
| # define EVP_F_AESNI_XTS_INIT_KEY 207 | |||
| # define EVP_F_AES_GCM_CTRL 196 | |||
| # define EVP_F_AES_INIT_KEY 133 | |||
| # define EVP_F_AES_OCB_CIPHER 169 | |||
| # define EVP_F_AES_T4_INIT_KEY 178 | |||
| # define EVP_F_AES_T4_XTS_INIT_KEY 208 | |||
| # define EVP_F_AES_WRAP_CIPHER 170 | |||
| # define EVP_F_AES_XTS_INIT_KEY 209 | |||
| # define EVP_F_ALG_MODULE_INIT 177 | |||
| # define EVP_F_ARIA_CCM_INIT_KEY 175 | |||
| # define EVP_F_ARIA_GCM_CTRL 197 | |||
| # define EVP_F_ARIA_GCM_INIT_KEY 176 | |||
| # define EVP_F_ARIA_INIT_KEY 185 | |||
| # define EVP_F_B64_NEW 198 | |||
| # define EVP_F_CAMELLIA_INIT_KEY 159 | |||
| # define EVP_F_CHACHA20_POLY1305_CTRL 182 | |||
| # define EVP_F_CMLL_T4_INIT_KEY 179 | |||
| # define EVP_F_DES_EDE3_WRAP_CIPHER 171 | |||
| # define EVP_F_DO_SIGVER_INIT 161 | |||
| # define EVP_F_ENC_NEW 199 | |||
| # define EVP_F_EVP_CIPHERINIT_EX 123 | |||
| # define EVP_F_EVP_CIPHER_ASN1_TO_PARAM 204 | |||
| # define EVP_F_EVP_CIPHER_CTX_COPY 163 | |||
| # define EVP_F_EVP_CIPHER_CTX_CTRL 124 | |||
| # define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH 122 | |||
| # define EVP_F_EVP_CIPHER_PARAM_TO_ASN1 205 | |||
| # define EVP_F_EVP_DECRYPTFINAL_EX 101 | |||
| # define EVP_F_EVP_DECRYPTUPDATE 166 | |||
| # define EVP_F_EVP_DIGESTFINALXOF 174 | |||
| # define EVP_F_EVP_DIGESTINIT_EX 128 | |||
| # define EVP_F_EVP_ENCRYPTDECRYPTUPDATE 219 | |||
| # define EVP_F_EVP_ENCRYPTFINAL_EX 127 | |||
| # define EVP_F_EVP_ENCRYPTUPDATE 167 | |||
| # define EVP_F_EVP_MD_CTX_COPY_EX 110 | |||
| # define EVP_F_EVP_MD_SIZE 162 | |||
| # define EVP_F_EVP_OPENINIT 102 | |||
| # define EVP_F_EVP_PBE_ALG_ADD 115 | |||
| # define EVP_F_EVP_PBE_ALG_ADD_TYPE 160 | |||
| # define EVP_F_EVP_PBE_CIPHERINIT 116 | |||
| # define EVP_F_EVP_PBE_SCRYPT 181 | |||
| # define EVP_F_EVP_PKCS82PKEY 111 | |||
| # define EVP_F_EVP_PKEY2PKCS8 113 | |||
| # define EVP_F_EVP_PKEY_ASN1_ADD0 188 | |||
| # define EVP_F_EVP_PKEY_CHECK 186 | |||
| # define EVP_F_EVP_PKEY_COPY_PARAMETERS 103 | |||
| # define EVP_F_EVP_PKEY_CTX_CTRL 137 | |||
| # define EVP_F_EVP_PKEY_CTX_CTRL_STR 150 | |||
| # define EVP_F_EVP_PKEY_CTX_DUP 156 | |||
| # define EVP_F_EVP_PKEY_CTX_MD 168 | |||
| # define EVP_F_EVP_PKEY_DECRYPT 104 | |||
| # define EVP_F_EVP_PKEY_DECRYPT_INIT 138 | |||
| # define EVP_F_EVP_PKEY_DECRYPT_OLD 151 | |||
| # define EVP_F_EVP_PKEY_DERIVE 153 | |||
| # define EVP_F_EVP_PKEY_DERIVE_INIT 154 | |||
| # define EVP_F_EVP_PKEY_DERIVE_SET_PEER 155 | |||
| # define EVP_F_EVP_PKEY_ENCRYPT 105 | |||
| # define EVP_F_EVP_PKEY_ENCRYPT_INIT 139 | |||
| # define EVP_F_EVP_PKEY_ENCRYPT_OLD 152 | |||
| # define EVP_F_EVP_PKEY_GET0_DH 119 | |||
| # define EVP_F_EVP_PKEY_GET0_DSA 120 | |||
| # define EVP_F_EVP_PKEY_GET0_EC_KEY 131 | |||
| # define EVP_F_EVP_PKEY_GET0_HMAC 183 | |||
| # define EVP_F_EVP_PKEY_GET0_POLY1305 184 | |||
| # define EVP_F_EVP_PKEY_GET0_RSA 121 | |||
| # define EVP_F_EVP_PKEY_GET0_SIPHASH 172 | |||
| # define EVP_F_EVP_PKEY_GET_RAW_PRIVATE_KEY 202 | |||
| # define EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY 203 | |||
| # define EVP_F_EVP_PKEY_KEYGEN 146 | |||
| # define EVP_F_EVP_PKEY_KEYGEN_INIT 147 | |||
| # define EVP_F_EVP_PKEY_METH_ADD0 194 | |||
| # define EVP_F_EVP_PKEY_METH_NEW 195 | |||
| # define EVP_F_EVP_PKEY_NEW 106 | |||
| # define EVP_F_EVP_PKEY_NEW_CMAC_KEY 193 | |||
| # define EVP_F_EVP_PKEY_NEW_RAW_PRIVATE_KEY 191 | |||
| # define EVP_F_EVP_PKEY_NEW_RAW_PUBLIC_KEY 192 | |||
| # define EVP_F_EVP_PKEY_PARAMGEN 148 | |||
| # define EVP_F_EVP_PKEY_PARAMGEN_INIT 149 | |||
| # define EVP_F_EVP_PKEY_PARAM_CHECK 189 | |||
| # define EVP_F_EVP_PKEY_PUBLIC_CHECK 190 | |||
| # define EVP_F_EVP_PKEY_SET1_ENGINE 187 | |||
| # define EVP_F_EVP_PKEY_SET_ALIAS_TYPE 206 | |||
| # define EVP_F_EVP_PKEY_SIGN 140 | |||
| # define EVP_F_EVP_PKEY_SIGN_INIT 141 | |||
| # define EVP_F_EVP_PKEY_VERIFY 142 | |||
| # define EVP_F_EVP_PKEY_VERIFY_INIT 143 | |||
| # define EVP_F_EVP_PKEY_VERIFY_RECOVER 144 | |||
| # define EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT 145 | |||
| # define EVP_F_EVP_SIGNFINAL 107 | |||
| # define EVP_F_EVP_VERIFYFINAL 108 | |||
| # define EVP_F_INT_CTX_NEW 157 | |||
| # define EVP_F_OK_NEW 200 | |||
| # define EVP_F_PKCS5_PBE_KEYIVGEN 117 | |||
| # define EVP_F_PKCS5_V2_PBE_KEYIVGEN 118 | |||
| # define EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN 164 | |||
| # define EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN 180 | |||
| # define EVP_F_PKEY_SET_TYPE 158 | |||
| # define EVP_F_RC2_MAGIC_TO_METH 109 | |||
| # define EVP_F_RC5_CTRL 125 | |||
| # define EVP_F_R_32_12_16_INIT_KEY 242 | |||
| # define EVP_F_S390X_AES_GCM_CTRL 201 | |||
| # define EVP_F_UPDATE 173 | |||
| /* | |||
| * EVP reason codes. | |||
| */ | |||
| # define EVP_R_AES_KEY_SETUP_FAILED 143 | |||
| # define EVP_R_ARIA_KEY_SETUP_FAILED 176 | |||
| # define EVP_R_BAD_DECRYPT 100 | |||
| # define EVP_R_BAD_KEY_LENGTH 195 | |||
| # define EVP_R_BUFFER_TOO_SMALL 155 | |||
| # define EVP_R_CAMELLIA_KEY_SETUP_FAILED 157 | |||
| # define EVP_R_CIPHER_PARAMETER_ERROR 122 | |||
| # define EVP_R_COMMAND_NOT_SUPPORTED 147 | |||
| # define EVP_R_COPY_ERROR 173 | |||
| # define EVP_R_CTRL_NOT_IMPLEMENTED 132 | |||
| # define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED 133 | |||
| # define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH 138 | |||
| # define EVP_R_DECODE_ERROR 114 | |||
| # define EVP_R_DIFFERENT_KEY_TYPES 101 | |||
| # define EVP_R_DIFFERENT_PARAMETERS 153 | |||
| # define EVP_R_ERROR_LOADING_SECTION 165 | |||
| # define EVP_R_ERROR_SETTING_FIPS_MODE 166 | |||
| # define EVP_R_EXPECTING_AN_HMAC_KEY 174 | |||
| # define EVP_R_EXPECTING_AN_RSA_KEY 127 | |||
| # define EVP_R_EXPECTING_A_DH_KEY 128 | |||
| # define EVP_R_EXPECTING_A_DSA_KEY 129 | |||
| # define EVP_R_EXPECTING_A_EC_KEY 142 | |||
| # define EVP_R_EXPECTING_A_POLY1305_KEY 164 | |||
| # define EVP_R_EXPECTING_A_SIPHASH_KEY 175 | |||
| # define EVP_R_FIPS_MODE_NOT_SUPPORTED 167 | |||
| # define EVP_R_GET_RAW_KEY_FAILED 182 | |||
| # define EVP_R_ILLEGAL_SCRYPT_PARAMETERS 171 | |||
| # define EVP_R_INITIALIZATION_ERROR 134 | |||
| # define EVP_R_INPUT_NOT_INITIALIZED 111 | |||
| # define EVP_R_INVALID_DIGEST 152 | |||
| # define EVP_R_INVALID_FIPS_MODE 168 | |||
| # define EVP_R_INVALID_IV_LENGTH 194 | |||
| # define EVP_R_INVALID_KEY 163 | |||
| # define EVP_R_INVALID_KEY_LENGTH 130 | |||
| # define EVP_R_INVALID_OPERATION 148 | |||
| # define EVP_R_KEYGEN_FAILURE 120 | |||
| # define EVP_R_KEY_SETUP_FAILED 180 | |||
| # define EVP_R_MEMORY_LIMIT_EXCEEDED 172 | |||
| # define EVP_R_MESSAGE_DIGEST_IS_NULL 159 | |||
| # define EVP_R_METHOD_NOT_SUPPORTED 144 | |||
| # define EVP_R_MISSING_PARAMETERS 103 | |||
| # define EVP_R_NOT_XOF_OR_INVALID_LENGTH 178 | |||
| # define EVP_R_NO_CIPHER_SET 131 | |||
| # define EVP_R_NO_DEFAULT_DIGEST 158 | |||
| # define EVP_R_NO_DIGEST_SET 139 | |||
| # define EVP_R_NO_KEY_SET 154 | |||
| # define EVP_R_NO_OPERATION_SET 149 | |||
| # define EVP_R_ONLY_ONESHOT_SUPPORTED 177 | |||
| # define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 150 | |||
| # define EVP_R_OPERATON_NOT_INITIALIZED 151 | |||
| # define EVP_R_PARTIALLY_OVERLAPPING 162 | |||
| # define EVP_R_PBKDF2_ERROR 181 | |||
| # define EVP_R_PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED 179 | |||
| # define EVP_R_PRIVATE_KEY_DECODE_ERROR 145 | |||
| # define EVP_R_PRIVATE_KEY_ENCODE_ERROR 146 | |||
| # define EVP_R_PUBLIC_KEY_NOT_RSA 106 | |||
| # define EVP_R_UNKNOWN_CIPHER 160 | |||
| # define EVP_R_UNKNOWN_DIGEST 161 | |||
| # define EVP_R_UNKNOWN_OPTION 169 | |||
| # define EVP_R_UNKNOWN_PBE_ALGORITHM 121 | |||
| # define EVP_R_UNSUPPORTED_ALGORITHM 156 | |||
| # define EVP_R_UNSUPPORTED_CIPHER 107 | |||
| # define EVP_R_UNSUPPORTED_KEYLENGTH 123 | |||
| # define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION 124 | |||
| # define EVP_R_UNSUPPORTED_KEY_SIZE 108 | |||
| # define EVP_R_UNSUPPORTED_NUMBER_OF_ROUNDS 135 | |||
| # define EVP_R_UNSUPPORTED_PRF 125 | |||
| # define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM 118 | |||
| # define EVP_R_UNSUPPORTED_SALT_TYPE 126 | |||
| # define EVP_R_WRAP_MODE_NOT_ALLOWED 170 | |||
| # define EVP_R_WRONG_FINAL_BLOCK_LENGTH 109 | |||
| # define EVP_R_XTS_DUPLICATED_KEYS 183 | |||
| #endif | |||
| @ -1,51 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_HMAC_H | |||
| # define HEADER_HMAC_H | |||
| # include <openssl/opensslconf.h> | |||
| # include <openssl/evp.h> | |||
| # if OPENSSL_API_COMPAT < 0x10200000L | |||
| # define HMAC_MAX_MD_CBLOCK 128 /* Deprecated */ | |||
| # endif | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| size_t HMAC_size(const HMAC_CTX *e); | |||
| HMAC_CTX *HMAC_CTX_new(void); | |||
| int HMAC_CTX_reset(HMAC_CTX *ctx); | |||
| void HMAC_CTX_free(HMAC_CTX *ctx); | |||
| DEPRECATEDIN_1_1_0(__owur int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, | |||
| const EVP_MD *md)) | |||
| /*__owur*/ int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len, | |||
| const EVP_MD *md, ENGINE *impl); | |||
| /*__owur*/ int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, | |||
| size_t len); | |||
| /*__owur*/ int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, | |||
| unsigned int *len); | |||
| unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len, | |||
| const unsigned char *d, size_t n, unsigned char *md, | |||
| unsigned int *md_len); | |||
| __owur int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx); | |||
| void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags); | |||
| const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx); | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,64 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_IDEA_H | |||
| # define HEADER_IDEA_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_IDEA | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| typedef unsigned int IDEA_INT; | |||
| # define IDEA_ENCRYPT 1 | |||
| # define IDEA_DECRYPT 0 | |||
| # define IDEA_BLOCK 8 | |||
| # define IDEA_KEY_LENGTH 16 | |||
| typedef struct idea_key_st { | |||
| IDEA_INT data[9][6]; | |||
| } IDEA_KEY_SCHEDULE; | |||
| const char *IDEA_options(void); | |||
| void IDEA_ecb_encrypt(const unsigned char *in, unsigned char *out, | |||
| IDEA_KEY_SCHEDULE *ks); | |||
| void IDEA_set_encrypt_key(const unsigned char *key, IDEA_KEY_SCHEDULE *ks); | |||
| void IDEA_set_decrypt_key(IDEA_KEY_SCHEDULE *ek, IDEA_KEY_SCHEDULE *dk); | |||
| void IDEA_cbc_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, | |||
| int enc); | |||
| void IDEA_cfb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, | |||
| int *num, int enc); | |||
| void IDEA_ofb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, | |||
| int *num); | |||
| void IDEA_encrypt(unsigned long *in, IDEA_KEY_SCHEDULE *ks); | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define idea_options IDEA_options | |||
| # define idea_ecb_encrypt IDEA_ecb_encrypt | |||
| # define idea_set_encrypt_key IDEA_set_encrypt_key | |||
| # define idea_set_decrypt_key IDEA_set_decrypt_key | |||
| # define idea_cbc_encrypt IDEA_cbc_encrypt | |||
| # define idea_cfb64_encrypt IDEA_cfb64_encrypt | |||
| # define idea_ofb64_encrypt IDEA_ofb64_encrypt | |||
| # define idea_encrypt IDEA_encrypt | |||
| # endif | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,97 +0,0 @@ | |||
| /* | |||
| * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_KDF_H | |||
| # define HEADER_KDF_H | |||
| # include <openssl/kdferr.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # define EVP_PKEY_CTRL_TLS_MD (EVP_PKEY_ALG_CTRL) | |||
| # define EVP_PKEY_CTRL_TLS_SECRET (EVP_PKEY_ALG_CTRL + 1) | |||
| # define EVP_PKEY_CTRL_TLS_SEED (EVP_PKEY_ALG_CTRL + 2) | |||
| # define EVP_PKEY_CTRL_HKDF_MD (EVP_PKEY_ALG_CTRL + 3) | |||
| # define EVP_PKEY_CTRL_HKDF_SALT (EVP_PKEY_ALG_CTRL + 4) | |||
| # define EVP_PKEY_CTRL_HKDF_KEY (EVP_PKEY_ALG_CTRL + 5) | |||
| # define EVP_PKEY_CTRL_HKDF_INFO (EVP_PKEY_ALG_CTRL + 6) | |||
| # define EVP_PKEY_CTRL_HKDF_MODE (EVP_PKEY_ALG_CTRL + 7) | |||
| # define EVP_PKEY_CTRL_PASS (EVP_PKEY_ALG_CTRL + 8) | |||
| # define EVP_PKEY_CTRL_SCRYPT_SALT (EVP_PKEY_ALG_CTRL + 9) | |||
| # define EVP_PKEY_CTRL_SCRYPT_N (EVP_PKEY_ALG_CTRL + 10) | |||
| # define EVP_PKEY_CTRL_SCRYPT_R (EVP_PKEY_ALG_CTRL + 11) | |||
| # define EVP_PKEY_CTRL_SCRYPT_P (EVP_PKEY_ALG_CTRL + 12) | |||
| # define EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES (EVP_PKEY_ALG_CTRL + 13) | |||
| # define EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND 0 | |||
| # define EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY 1 | |||
| # define EVP_PKEY_HKDEF_MODE_EXPAND_ONLY 2 | |||
| # define EVP_PKEY_CTX_set_tls1_prf_md(pctx, md) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_TLS_MD, 0, (void *)(md)) | |||
| # define EVP_PKEY_CTX_set1_tls1_prf_secret(pctx, sec, seclen) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_TLS_SECRET, seclen, (void *)(sec)) | |||
| # define EVP_PKEY_CTX_add1_tls1_prf_seed(pctx, seed, seedlen) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_TLS_SEED, seedlen, (void *)(seed)) | |||
| # define EVP_PKEY_CTX_set_hkdf_md(pctx, md) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_HKDF_MD, 0, (void *)(md)) | |||
| # define EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt, saltlen) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_HKDF_SALT, saltlen, (void *)(salt)) | |||
| # define EVP_PKEY_CTX_set1_hkdf_key(pctx, key, keylen) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_HKDF_KEY, keylen, (void *)(key)) | |||
| # define EVP_PKEY_CTX_add1_hkdf_info(pctx, info, infolen) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_HKDF_INFO, infolen, (void *)(info)) | |||
| # define EVP_PKEY_CTX_hkdf_mode(pctx, mode) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_HKDF_MODE, mode, NULL) | |||
| # define EVP_PKEY_CTX_set1_pbe_pass(pctx, pass, passlen) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_PASS, passlen, (void *)(pass)) | |||
| # define EVP_PKEY_CTX_set1_scrypt_salt(pctx, salt, saltlen) \ | |||
| EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_SCRYPT_SALT, saltlen, (void *)(salt)) | |||
| # define EVP_PKEY_CTX_set_scrypt_N(pctx, n) \ | |||
| EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_SCRYPT_N, n) | |||
| # define EVP_PKEY_CTX_set_scrypt_r(pctx, r) \ | |||
| EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_SCRYPT_R, r) | |||
| # define EVP_PKEY_CTX_set_scrypt_p(pctx, p) \ | |||
| EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_SCRYPT_P, p) | |||
| # define EVP_PKEY_CTX_set_scrypt_maxmem_bytes(pctx, maxmem_bytes) \ | |||
| EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ | |||
| EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES, maxmem_bytes) | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,55 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_KDFERR_H | |||
| # define HEADER_KDFERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_KDF_strings(void); | |||
| /* | |||
| * KDF function codes. | |||
| */ | |||
| # define KDF_F_PKEY_HKDF_CTRL_STR 103 | |||
| # define KDF_F_PKEY_HKDF_DERIVE 102 | |||
| # define KDF_F_PKEY_HKDF_INIT 108 | |||
| # define KDF_F_PKEY_SCRYPT_CTRL_STR 104 | |||
| # define KDF_F_PKEY_SCRYPT_CTRL_UINT64 105 | |||
| # define KDF_F_PKEY_SCRYPT_DERIVE 109 | |||
| # define KDF_F_PKEY_SCRYPT_INIT 106 | |||
| # define KDF_F_PKEY_SCRYPT_SET_MEMBUF 107 | |||
| # define KDF_F_PKEY_TLS1_PRF_CTRL_STR 100 | |||
| # define KDF_F_PKEY_TLS1_PRF_DERIVE 101 | |||
| # define KDF_F_PKEY_TLS1_PRF_INIT 110 | |||
| # define KDF_F_TLS1_PRF_ALG 111 | |||
| /* | |||
| * KDF reason codes. | |||
| */ | |||
| # define KDF_R_INVALID_DIGEST 100 | |||
| # define KDF_R_MISSING_ITERATION_COUNT 109 | |||
| # define KDF_R_MISSING_KEY 104 | |||
| # define KDF_R_MISSING_MESSAGE_DIGEST 105 | |||
| # define KDF_R_MISSING_PARAMETER 101 | |||
| # define KDF_R_MISSING_PASS 110 | |||
| # define KDF_R_MISSING_SALT 111 | |||
| # define KDF_R_MISSING_SECRET 107 | |||
| # define KDF_R_MISSING_SEED 106 | |||
| # define KDF_R_UNKNOWN_PARAMETER_TYPE 103 | |||
| # define KDF_R_VALUE_ERROR 108 | |||
| # define KDF_R_VALUE_MISSING 102 | |||
| #endif | |||
| @ -1,241 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| /* | |||
| * Header for dynamic hash table routines Author - Eric Young | |||
| */ | |||
| #ifndef HEADER_LHASH_H | |||
| # define HEADER_LHASH_H | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/bio.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| typedef struct lhash_node_st OPENSSL_LH_NODE; | |||
| typedef int (*OPENSSL_LH_COMPFUNC) (const void *, const void *); | |||
| typedef unsigned long (*OPENSSL_LH_HASHFUNC) (const void *); | |||
| typedef void (*OPENSSL_LH_DOALL_FUNC) (void *); | |||
| typedef void (*OPENSSL_LH_DOALL_FUNCARG) (void *, void *); | |||
| typedef struct lhash_st OPENSSL_LHASH; | |||
| /* | |||
| * Macros for declaring and implementing type-safe wrappers for LHASH | |||
| * callbacks. This way, callbacks can be provided to LHASH structures without | |||
| * function pointer casting and the macro-defined callbacks provide | |||
| * per-variable casting before deferring to the underlying type-specific | |||
| * callbacks. NB: It is possible to place a "static" in front of both the | |||
| * DECLARE and IMPLEMENT macros if the functions are strictly internal. | |||
| */ | |||
| /* First: "hash" functions */ | |||
| # define DECLARE_LHASH_HASH_FN(name, o_type) \ | |||
| unsigned long name##_LHASH_HASH(const void *); | |||
| # define IMPLEMENT_LHASH_HASH_FN(name, o_type) \ | |||
| unsigned long name##_LHASH_HASH(const void *arg) { \ | |||
| const o_type *a = arg; \ | |||
| return name##_hash(a); } | |||
| # define LHASH_HASH_FN(name) name##_LHASH_HASH | |||
| /* Second: "compare" functions */ | |||
| # define DECLARE_LHASH_COMP_FN(name, o_type) \ | |||
| int name##_LHASH_COMP(const void *, const void *); | |||
| # define IMPLEMENT_LHASH_COMP_FN(name, o_type) \ | |||
| int name##_LHASH_COMP(const void *arg1, const void *arg2) { \ | |||
| const o_type *a = arg1; \ | |||
| const o_type *b = arg2; \ | |||
| return name##_cmp(a,b); } | |||
| # define LHASH_COMP_FN(name) name##_LHASH_COMP | |||
| /* Fourth: "doall_arg" functions */ | |||
| # define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ | |||
| void name##_LHASH_DOALL_ARG(void *, void *); | |||
| # define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ | |||
| void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \ | |||
| o_type *a = arg1; \ | |||
| a_type *b = arg2; \ | |||
| name##_doall_arg(a, b); } | |||
| # define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG | |||
| # define LH_LOAD_MULT 256 | |||
| int OPENSSL_LH_error(OPENSSL_LHASH *lh); | |||
| OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c); | |||
| void OPENSSL_LH_free(OPENSSL_LHASH *lh); | |||
| void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data); | |||
| void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data); | |||
| void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data); | |||
| void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func); | |||
| void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNCARG func, void *arg); | |||
| unsigned long OPENSSL_LH_strhash(const char *c); | |||
| unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh); | |||
| unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh); | |||
| void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp); | |||
| void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp); | |||
| void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp); | |||
| # endif | |||
| void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out); | |||
| void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out); | |||
| void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out); | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define _LHASH OPENSSL_LHASH | |||
| # define LHASH_NODE OPENSSL_LH_NODE | |||
| # define lh_error OPENSSL_LH_error | |||
| # define lh_new OPENSSL_LH_new | |||
| # define lh_free OPENSSL_LH_free | |||
| # define lh_insert OPENSSL_LH_insert | |||
| # define lh_delete OPENSSL_LH_delete | |||
| # define lh_retrieve OPENSSL_LH_retrieve | |||
| # define lh_doall OPENSSL_LH_doall | |||
| # define lh_doall_arg OPENSSL_LH_doall_arg | |||
| # define lh_strhash OPENSSL_LH_strhash | |||
| # define lh_num_items OPENSSL_LH_num_items | |||
| # ifndef OPENSSL_NO_STDIO | |||
| # define lh_stats OPENSSL_LH_stats | |||
| # define lh_node_stats OPENSSL_LH_node_stats | |||
| # define lh_node_usage_stats OPENSSL_LH_node_usage_stats | |||
| # endif | |||
| # define lh_stats_bio OPENSSL_LH_stats_bio | |||
| # define lh_node_stats_bio OPENSSL_LH_node_stats_bio | |||
| # define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio | |||
| # endif | |||
| /* Type checking... */ | |||
| # define LHASH_OF(type) struct lhash_st_##type | |||
| # define DEFINE_LHASH_OF(type) \ | |||
| LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \ | |||
| static ossl_unused ossl_inline LHASH_OF(type) *lh_##type##_new(unsigned long (*hfn)(const type *), \ | |||
| int (*cfn)(const type *, const type *)) \ | |||
| { \ | |||
| return (LHASH_OF(type) *) \ | |||
| OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void lh_##type##_free(LHASH_OF(type) *lh) \ | |||
| { \ | |||
| OPENSSL_LH_free((OPENSSL_LHASH *)lh); \ | |||
| } \ | |||
| static ossl_unused ossl_inline type *lh_##type##_insert(LHASH_OF(type) *lh, type *d) \ | |||
| { \ | |||
| return (type *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); \ | |||
| } \ | |||
| static ossl_unused ossl_inline type *lh_##type##_delete(LHASH_OF(type) *lh, const type *d) \ | |||
| { \ | |||
| return (type *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); \ | |||
| } \ | |||
| static ossl_unused ossl_inline type *lh_##type##_retrieve(LHASH_OF(type) *lh, const type *d) \ | |||
| { \ | |||
| return (type *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); \ | |||
| } \ | |||
| static ossl_unused ossl_inline int lh_##type##_error(LHASH_OF(type) *lh) \ | |||
| { \ | |||
| return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \ | |||
| } \ | |||
| static ossl_unused ossl_inline unsigned long lh_##type##_num_items(LHASH_OF(type) *lh) \ | |||
| { \ | |||
| return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void lh_##type##_node_stats_bio(const LHASH_OF(type) *lh, BIO *out) \ | |||
| { \ | |||
| OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void lh_##type##_node_usage_stats_bio(const LHASH_OF(type) *lh, BIO *out) \ | |||
| { \ | |||
| OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void lh_##type##_stats_bio(const LHASH_OF(type) *lh, BIO *out) \ | |||
| { \ | |||
| OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); \ | |||
| } \ | |||
| static ossl_unused ossl_inline unsigned long lh_##type##_get_down_load(LHASH_OF(type) *lh) \ | |||
| { \ | |||
| return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \ | |||
| { \ | |||
| OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void lh_##type##_doall(LHASH_OF(type) *lh, \ | |||
| void (*doall)(type *)) \ | |||
| { \ | |||
| OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \ | |||
| } \ | |||
| LHASH_OF(type) | |||
| #define IMPLEMENT_LHASH_DOALL_ARG_CONST(type, argtype) \ | |||
| int_implement_lhash_doall(type, argtype, const type) | |||
| #define IMPLEMENT_LHASH_DOALL_ARG(type, argtype) \ | |||
| int_implement_lhash_doall(type, argtype, type) | |||
| #define int_implement_lhash_doall(type, argtype, cbargtype) \ | |||
| static ossl_unused ossl_inline void \ | |||
| lh_##type##_doall_##argtype(LHASH_OF(type) *lh, \ | |||
| void (*fn)(cbargtype *, argtype *), \ | |||
| argtype *arg) \ | |||
| { \ | |||
| OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNCARG)fn, (void *)arg); \ | |||
| } \ | |||
| LHASH_OF(type) | |||
| DEFINE_LHASH_OF(OPENSSL_STRING); | |||
| # ifdef _MSC_VER | |||
| /* | |||
| * push and pop this warning: | |||
| * warning C4090: 'function': different 'const' qualifiers | |||
| */ | |||
| # pragma warning (push) | |||
| # pragma warning (disable: 4090) | |||
| # endif | |||
| DEFINE_LHASH_OF(OPENSSL_CSTRING); | |||
| # ifdef _MSC_VER | |||
| # pragma warning (pop) | |||
| # endif | |||
| /* | |||
| * If called without higher optimization (min. -xO3) the Oracle Developer | |||
| * Studio compiler generates code for the defined (static inline) functions | |||
| * above. | |||
| * This would later lead to the linker complaining about missing symbols when | |||
| * this header file is included but the resulting object is not linked against | |||
| * the Crypto library (openssl#6912). | |||
| */ | |||
| # ifdef __SUNPRO_C | |||
| # pragma weak OPENSSL_LH_new | |||
| # pragma weak OPENSSL_LH_free | |||
| # pragma weak OPENSSL_LH_insert | |||
| # pragma weak OPENSSL_LH_delete | |||
| # pragma weak OPENSSL_LH_retrieve | |||
| # pragma weak OPENSSL_LH_error | |||
| # pragma weak OPENSSL_LH_num_items | |||
| # pragma weak OPENSSL_LH_node_stats_bio | |||
| # pragma weak OPENSSL_LH_node_usage_stats_bio | |||
| # pragma weak OPENSSL_LH_stats_bio | |||
| # pragma weak OPENSSL_LH_get_down_load | |||
| # pragma weak OPENSSL_LH_set_down_load | |||
| # pragma weak OPENSSL_LH_doall | |||
| # pragma weak OPENSSL_LH_doall_arg | |||
| # endif /* __SUNPRO_C */ | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,44 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_MD2_H | |||
| # define HEADER_MD2_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_MD2 | |||
| # include <stddef.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| typedef unsigned char MD2_INT; | |||
| # define MD2_DIGEST_LENGTH 16 | |||
| # define MD2_BLOCK 16 | |||
| typedef struct MD2state_st { | |||
| unsigned int num; | |||
| unsigned char data[MD2_BLOCK]; | |||
| MD2_INT cksm[MD2_BLOCK]; | |||
| MD2_INT state[MD2_BLOCK]; | |||
| } MD2_CTX; | |||
| const char *MD2_options(void); | |||
| int MD2_Init(MD2_CTX *c); | |||
| int MD2_Update(MD2_CTX *c, const unsigned char *data, size_t len); | |||
| int MD2_Final(unsigned char *md, MD2_CTX *c); | |||
| unsigned char *MD2(const unsigned char *d, size_t n, unsigned char *md); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,51 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_MD4_H | |||
| # define HEADER_MD4_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_MD4 | |||
| # include <openssl/e_os2.h> | |||
| # include <stddef.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| /*- | |||
| * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |||
| * ! MD4_LONG has to be at least 32 bits wide. ! | |||
| * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |||
| */ | |||
| # define MD4_LONG unsigned int | |||
| # define MD4_CBLOCK 64 | |||
| # define MD4_LBLOCK (MD4_CBLOCK/4) | |||
| # define MD4_DIGEST_LENGTH 16 | |||
| typedef struct MD4state_st { | |||
| MD4_LONG A, B, C, D; | |||
| MD4_LONG Nl, Nh; | |||
| MD4_LONG data[MD4_LBLOCK]; | |||
| unsigned int num; | |||
| } MD4_CTX; | |||
| int MD4_Init(MD4_CTX *c); | |||
| int MD4_Update(MD4_CTX *c, const void *data, size_t len); | |||
| int MD4_Final(unsigned char *md, MD4_CTX *c); | |||
| unsigned char *MD4(const unsigned char *d, size_t n, unsigned char *md); | |||
| void MD4_Transform(MD4_CTX *c, const unsigned char *b); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,50 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_MD5_H | |||
| # define HEADER_MD5_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_MD5 | |||
| # include <openssl/e_os2.h> | |||
| # include <stddef.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| /* | |||
| * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |||
| * ! MD5_LONG has to be at least 32 bits wide. ! | |||
| * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |||
| */ | |||
| # define MD5_LONG unsigned int | |||
| # define MD5_CBLOCK 64 | |||
| # define MD5_LBLOCK (MD5_CBLOCK/4) | |||
| # define MD5_DIGEST_LENGTH 16 | |||
| typedef struct MD5state_st { | |||
| MD5_LONG A, B, C, D; | |||
| MD5_LONG Nl, Nh; | |||
| MD5_LONG data[MD5_LBLOCK]; | |||
| unsigned int num; | |||
| } MD5_CTX; | |||
| int MD5_Init(MD5_CTX *c); | |||
| int MD5_Update(MD5_CTX *c, const void *data, size_t len); | |||
| int MD5_Final(unsigned char *md, MD5_CTX *c); | |||
| unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md); | |||
| void MD5_Transform(MD5_CTX *c, const unsigned char *b); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,42 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_MDC2_H | |||
| # define HEADER_MDC2_H | |||
| # include <openssl/opensslconf.h> | |||
| #ifndef OPENSSL_NO_MDC2 | |||
| # include <stdlib.h> | |||
| # include <openssl/des.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| # define MDC2_BLOCK 8 | |||
| # define MDC2_DIGEST_LENGTH 16 | |||
| typedef struct mdc2_ctx_st { | |||
| unsigned int num; | |||
| unsigned char data[MDC2_BLOCK]; | |||
| DES_cblock h, hh; | |||
| int pad_type; /* either 1 or 2, default 1 */ | |||
| } MDC2_CTX; | |||
| int MDC2_Init(MDC2_CTX *c); | |||
| int MDC2_Update(MDC2_CTX *c, const unsigned char *data, size_t len); | |||
| int MDC2_Final(unsigned char *md, MDC2_CTX *c); | |||
| unsigned char *MDC2(const unsigned char *d, size_t n, unsigned char *md); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,208 +0,0 @@ | |||
| /* | |||
| * Copyright 2008-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_MODES_H | |||
| # define HEADER_MODES_H | |||
| # include <stddef.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| typedef void (*block128_f) (const unsigned char in[16], | |||
| unsigned char out[16], const void *key); | |||
| typedef void (*cbc128_f) (const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], int enc); | |||
| typedef void (*ctr128_f) (const unsigned char *in, unsigned char *out, | |||
| size_t blocks, const void *key, | |||
| const unsigned char ivec[16]); | |||
| typedef void (*ccm128_f) (const unsigned char *in, unsigned char *out, | |||
| size_t blocks, const void *key, | |||
| const unsigned char ivec[16], | |||
| unsigned char cmac[16]); | |||
| void CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], block128_f block); | |||
| void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], block128_f block); | |||
| void CRYPTO_ctr128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], | |||
| unsigned char ecount_buf[16], unsigned int *num, | |||
| block128_f block); | |||
| void CRYPTO_ctr128_encrypt_ctr32(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], | |||
| unsigned char ecount_buf[16], | |||
| unsigned int *num, ctr128_f ctr); | |||
| void CRYPTO_ofb128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], int *num, | |||
| block128_f block); | |||
| void CRYPTO_cfb128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], int *num, | |||
| int enc, block128_f block); | |||
| void CRYPTO_cfb128_8_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t length, const void *key, | |||
| unsigned char ivec[16], int *num, | |||
| int enc, block128_f block); | |||
| void CRYPTO_cfb128_1_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t bits, const void *key, | |||
| unsigned char ivec[16], int *num, | |||
| int enc, block128_f block); | |||
| size_t CRYPTO_cts128_encrypt_block(const unsigned char *in, | |||
| unsigned char *out, size_t len, | |||
| const void *key, unsigned char ivec[16], | |||
| block128_f block); | |||
| size_t CRYPTO_cts128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], cbc128_f cbc); | |||
| size_t CRYPTO_cts128_decrypt_block(const unsigned char *in, | |||
| unsigned char *out, size_t len, | |||
| const void *key, unsigned char ivec[16], | |||
| block128_f block); | |||
| size_t CRYPTO_cts128_decrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], cbc128_f cbc); | |||
| size_t CRYPTO_nistcts128_encrypt_block(const unsigned char *in, | |||
| unsigned char *out, size_t len, | |||
| const void *key, | |||
| unsigned char ivec[16], | |||
| block128_f block); | |||
| size_t CRYPTO_nistcts128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], cbc128_f cbc); | |||
| size_t CRYPTO_nistcts128_decrypt_block(const unsigned char *in, | |||
| unsigned char *out, size_t len, | |||
| const void *key, | |||
| unsigned char ivec[16], | |||
| block128_f block); | |||
| size_t CRYPTO_nistcts128_decrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const void *key, | |||
| unsigned char ivec[16], cbc128_f cbc); | |||
| typedef struct gcm128_context GCM128_CONTEXT; | |||
| GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block); | |||
| void CRYPTO_gcm128_init(GCM128_CONTEXT *ctx, void *key, block128_f block); | |||
| void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const unsigned char *iv, | |||
| size_t len); | |||
| int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const unsigned char *aad, | |||
| size_t len); | |||
| int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, | |||
| const unsigned char *in, unsigned char *out, | |||
| size_t len); | |||
| int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, | |||
| const unsigned char *in, unsigned char *out, | |||
| size_t len); | |||
| int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx, | |||
| const unsigned char *in, unsigned char *out, | |||
| size_t len, ctr128_f stream); | |||
| int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx, | |||
| const unsigned char *in, unsigned char *out, | |||
| size_t len, ctr128_f stream); | |||
| int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const unsigned char *tag, | |||
| size_t len); | |||
| void CRYPTO_gcm128_tag(GCM128_CONTEXT *ctx, unsigned char *tag, size_t len); | |||
| void CRYPTO_gcm128_release(GCM128_CONTEXT *ctx); | |||
| typedef struct ccm128_context CCM128_CONTEXT; | |||
| void CRYPTO_ccm128_init(CCM128_CONTEXT *ctx, | |||
| unsigned int M, unsigned int L, void *key, | |||
| block128_f block); | |||
| int CRYPTO_ccm128_setiv(CCM128_CONTEXT *ctx, const unsigned char *nonce, | |||
| size_t nlen, size_t mlen); | |||
| void CRYPTO_ccm128_aad(CCM128_CONTEXT *ctx, const unsigned char *aad, | |||
| size_t alen); | |||
| int CRYPTO_ccm128_encrypt(CCM128_CONTEXT *ctx, const unsigned char *inp, | |||
| unsigned char *out, size_t len); | |||
| int CRYPTO_ccm128_decrypt(CCM128_CONTEXT *ctx, const unsigned char *inp, | |||
| unsigned char *out, size_t len); | |||
| int CRYPTO_ccm128_encrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp, | |||
| unsigned char *out, size_t len, | |||
| ccm128_f stream); | |||
| int CRYPTO_ccm128_decrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp, | |||
| unsigned char *out, size_t len, | |||
| ccm128_f stream); | |||
| size_t CRYPTO_ccm128_tag(CCM128_CONTEXT *ctx, unsigned char *tag, size_t len); | |||
| typedef struct xts128_context XTS128_CONTEXT; | |||
| int CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, | |||
| const unsigned char iv[16], | |||
| const unsigned char *inp, unsigned char *out, | |||
| size_t len, int enc); | |||
| size_t CRYPTO_128_wrap(void *key, const unsigned char *iv, | |||
| unsigned char *out, | |||
| const unsigned char *in, size_t inlen, | |||
| block128_f block); | |||
| size_t CRYPTO_128_unwrap(void *key, const unsigned char *iv, | |||
| unsigned char *out, | |||
| const unsigned char *in, size_t inlen, | |||
| block128_f block); | |||
| size_t CRYPTO_128_wrap_pad(void *key, const unsigned char *icv, | |||
| unsigned char *out, const unsigned char *in, | |||
| size_t inlen, block128_f block); | |||
| size_t CRYPTO_128_unwrap_pad(void *key, const unsigned char *icv, | |||
| unsigned char *out, const unsigned char *in, | |||
| size_t inlen, block128_f block); | |||
| # ifndef OPENSSL_NO_OCB | |||
| typedef struct ocb128_context OCB128_CONTEXT; | |||
| typedef void (*ocb128_f) (const unsigned char *in, unsigned char *out, | |||
| size_t blocks, const void *key, | |||
| size_t start_block_num, | |||
| unsigned char offset_i[16], | |||
| const unsigned char L_[][16], | |||
| unsigned char checksum[16]); | |||
| OCB128_CONTEXT *CRYPTO_ocb128_new(void *keyenc, void *keydec, | |||
| block128_f encrypt, block128_f decrypt, | |||
| ocb128_f stream); | |||
| int CRYPTO_ocb128_init(OCB128_CONTEXT *ctx, void *keyenc, void *keydec, | |||
| block128_f encrypt, block128_f decrypt, | |||
| ocb128_f stream); | |||
| int CRYPTO_ocb128_copy_ctx(OCB128_CONTEXT *dest, OCB128_CONTEXT *src, | |||
| void *keyenc, void *keydec); | |||
| int CRYPTO_ocb128_setiv(OCB128_CONTEXT *ctx, const unsigned char *iv, | |||
| size_t len, size_t taglen); | |||
| int CRYPTO_ocb128_aad(OCB128_CONTEXT *ctx, const unsigned char *aad, | |||
| size_t len); | |||
| int CRYPTO_ocb128_encrypt(OCB128_CONTEXT *ctx, const unsigned char *in, | |||
| unsigned char *out, size_t len); | |||
| int CRYPTO_ocb128_decrypt(OCB128_CONTEXT *ctx, const unsigned char *in, | |||
| unsigned char *out, size_t len); | |||
| int CRYPTO_ocb128_finish(OCB128_CONTEXT *ctx, const unsigned char *tag, | |||
| size_t len); | |||
| int CRYPTO_ocb128_tag(OCB128_CONTEXT *ctx, unsigned char *tag, size_t len); | |||
| void CRYPTO_ocb128_cleanup(OCB128_CONTEXT *ctx); | |||
| # endif /* OPENSSL_NO_OCB */ | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,175 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_OBJECTS_H | |||
| # define HEADER_OBJECTS_H | |||
| # include <openssl/obj_mac.h> | |||
| # include <openssl/bio.h> | |||
| # include <openssl/asn1.h> | |||
| # include <openssl/objectserr.h> | |||
| # define OBJ_NAME_TYPE_UNDEF 0x00 | |||
| # define OBJ_NAME_TYPE_MD_METH 0x01 | |||
| # define OBJ_NAME_TYPE_CIPHER_METH 0x02 | |||
| # define OBJ_NAME_TYPE_PKEY_METH 0x03 | |||
| # define OBJ_NAME_TYPE_COMP_METH 0x04 | |||
| # define OBJ_NAME_TYPE_NUM 0x05 | |||
| # define OBJ_NAME_ALIAS 0x8000 | |||
| # define OBJ_BSEARCH_VALUE_ON_NOMATCH 0x01 | |||
| # define OBJ_BSEARCH_FIRST_VALUE_ON_MATCH 0x02 | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| typedef struct obj_name_st { | |||
| int type; | |||
| int alias; | |||
| const char *name; | |||
| const char *data; | |||
| } OBJ_NAME; | |||
| # define OBJ_create_and_add_object(a,b,c) OBJ_create(a,b,c) | |||
| int OBJ_NAME_init(void); | |||
| int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *), | |||
| int (*cmp_func) (const char *, const char *), | |||
| void (*free_func) (const char *, int, const char *)); | |||
| const char *OBJ_NAME_get(const char *name, int type); | |||
| int OBJ_NAME_add(const char *name, int type, const char *data); | |||
| int OBJ_NAME_remove(const char *name, int type); | |||
| void OBJ_NAME_cleanup(int type); /* -1 for everything */ | |||
| void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg), | |||
| void *arg); | |||
| void OBJ_NAME_do_all_sorted(int type, | |||
| void (*fn) (const OBJ_NAME *, void *arg), | |||
| void *arg); | |||
| ASN1_OBJECT *OBJ_dup(const ASN1_OBJECT *o); | |||
| ASN1_OBJECT *OBJ_nid2obj(int n); | |||
| const char *OBJ_nid2ln(int n); | |||
| const char *OBJ_nid2sn(int n); | |||
| int OBJ_obj2nid(const ASN1_OBJECT *o); | |||
| ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name); | |||
| int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name); | |||
| int OBJ_txt2nid(const char *s); | |||
| int OBJ_ln2nid(const char *s); | |||
| int OBJ_sn2nid(const char *s); | |||
| int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b); | |||
| const void *OBJ_bsearch_(const void *key, const void *base, int num, int size, | |||
| int (*cmp) (const void *, const void *)); | |||
| const void *OBJ_bsearch_ex_(const void *key, const void *base, int num, | |||
| int size, | |||
| int (*cmp) (const void *, const void *), | |||
| int flags); | |||
| # define _DECLARE_OBJ_BSEARCH_CMP_FN(scope, type1, type2, nm) \ | |||
| static int nm##_cmp_BSEARCH_CMP_FN(const void *, const void *); \ | |||
| static int nm##_cmp(type1 const *, type2 const *); \ | |||
| scope type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) | |||
| # define DECLARE_OBJ_BSEARCH_CMP_FN(type1, type2, cmp) \ | |||
| _DECLARE_OBJ_BSEARCH_CMP_FN(static, type1, type2, cmp) | |||
| # define DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm) \ | |||
| type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) | |||
| /*- | |||
| * Unsolved problem: if a type is actually a pointer type, like | |||
| * nid_triple is, then its impossible to get a const where you need | |||
| * it. Consider: | |||
| * | |||
| * typedef int nid_triple[3]; | |||
| * const void *a_; | |||
| * const nid_triple const *a = a_; | |||
| * | |||
| * The assignment discards a const because what you really want is: | |||
| * | |||
| * const int const * const *a = a_; | |||
| * | |||
| * But if you do that, you lose the fact that a is an array of 3 ints, | |||
| * which breaks comparison functions. | |||
| * | |||
| * Thus we end up having to cast, sadly, or unpack the | |||
| * declarations. Or, as I finally did in this case, declare nid_triple | |||
| * to be a struct, which it should have been in the first place. | |||
| * | |||
| * Ben, August 2008. | |||
| * | |||
| * Also, strictly speaking not all types need be const, but handling | |||
| * the non-constness means a lot of complication, and in practice | |||
| * comparison routines do always not touch their arguments. | |||
| */ | |||
| # define IMPLEMENT_OBJ_BSEARCH_CMP_FN(type1, type2, nm) \ | |||
| static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) \ | |||
| { \ | |||
| type1 const *a = a_; \ | |||
| type2 const *b = b_; \ | |||
| return nm##_cmp(a,b); \ | |||
| } \ | |||
| static type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \ | |||
| { \ | |||
| return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \ | |||
| nm##_cmp_BSEARCH_CMP_FN); \ | |||
| } \ | |||
| extern void dummy_prototype(void) | |||
| # define IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm) \ | |||
| static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) \ | |||
| { \ | |||
| type1 const *a = a_; \ | |||
| type2 const *b = b_; \ | |||
| return nm##_cmp(a,b); \ | |||
| } \ | |||
| type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \ | |||
| { \ | |||
| return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \ | |||
| nm##_cmp_BSEARCH_CMP_FN); \ | |||
| } \ | |||
| extern void dummy_prototype(void) | |||
| # define OBJ_bsearch(type1,key,type2,base,num,cmp) \ | |||
| ((type2 *)OBJ_bsearch_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \ | |||
| num,sizeof(type2), \ | |||
| ((void)CHECKED_PTR_OF(type1,cmp##_type_1), \ | |||
| (void)CHECKED_PTR_OF(type2,cmp##_type_2), \ | |||
| cmp##_BSEARCH_CMP_FN))) | |||
| # define OBJ_bsearch_ex(type1,key,type2,base,num,cmp,flags) \ | |||
| ((type2 *)OBJ_bsearch_ex_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \ | |||
| num,sizeof(type2), \ | |||
| ((void)CHECKED_PTR_OF(type1,cmp##_type_1), \ | |||
| (void)type_2=CHECKED_PTR_OF(type2,cmp##_type_2), \ | |||
| cmp##_BSEARCH_CMP_FN)),flags) | |||
| int OBJ_new_nid(int num); | |||
| int OBJ_add_object(const ASN1_OBJECT *obj); | |||
| int OBJ_create(const char *oid, const char *sn, const char *ln); | |||
| #if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define OBJ_cleanup() while(0) continue | |||
| #endif | |||
| int OBJ_create_objects(BIO *in); | |||
| size_t OBJ_length(const ASN1_OBJECT *obj); | |||
| const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj); | |||
| int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid); | |||
| int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid); | |||
| int OBJ_add_sigid(int signid, int dig_id, int pkey_id); | |||
| void OBJ_sigid_free(void); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,42 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_OBJERR_H | |||
| # define HEADER_OBJERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_OBJ_strings(void); | |||
| /* | |||
| * OBJ function codes. | |||
| */ | |||
| # define OBJ_F_OBJ_ADD_OBJECT 105 | |||
| # define OBJ_F_OBJ_ADD_SIGID 107 | |||
| # define OBJ_F_OBJ_CREATE 100 | |||
| # define OBJ_F_OBJ_DUP 101 | |||
| # define OBJ_F_OBJ_NAME_NEW_INDEX 106 | |||
| # define OBJ_F_OBJ_NID2LN 102 | |||
| # define OBJ_F_OBJ_NID2OBJ 103 | |||
| # define OBJ_F_OBJ_NID2SN 104 | |||
| # define OBJ_F_OBJ_TXT2OBJ 108 | |||
| /* | |||
| * OBJ reason codes. | |||
| */ | |||
| # define OBJ_R_OID_EXISTS 102 | |||
| # define OBJ_R_UNKNOWN_NID 101 | |||
| #endif | |||
| @ -1,352 +0,0 @@ | |||
| /* | |||
| * Copyright 2000-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_OCSP_H | |||
| # define HEADER_OCSP_H | |||
| #include <openssl/opensslconf.h> | |||
| /* | |||
| * These definitions are outside the OPENSSL_NO_OCSP guard because although for | |||
| * historical reasons they have OCSP_* names, they can actually be used | |||
| * independently of OCSP. E.g. see RFC5280 | |||
| */ | |||
| /*- | |||
| * CRLReason ::= ENUMERATED { | |||
| * unspecified (0), | |||
| * keyCompromise (1), | |||
| * cACompromise (2), | |||
| * affiliationChanged (3), | |||
| * superseded (4), | |||
| * cessationOfOperation (5), | |||
| * certificateHold (6), | |||
| * removeFromCRL (8) } | |||
| */ | |||
| # define OCSP_REVOKED_STATUS_NOSTATUS -1 | |||
| # define OCSP_REVOKED_STATUS_UNSPECIFIED 0 | |||
| # define OCSP_REVOKED_STATUS_KEYCOMPROMISE 1 | |||
| # define OCSP_REVOKED_STATUS_CACOMPROMISE 2 | |||
| # define OCSP_REVOKED_STATUS_AFFILIATIONCHANGED 3 | |||
| # define OCSP_REVOKED_STATUS_SUPERSEDED 4 | |||
| # define OCSP_REVOKED_STATUS_CESSATIONOFOPERATION 5 | |||
| # define OCSP_REVOKED_STATUS_CERTIFICATEHOLD 6 | |||
| # define OCSP_REVOKED_STATUS_REMOVEFROMCRL 8 | |||
| # ifndef OPENSSL_NO_OCSP | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/x509.h> | |||
| # include <openssl/x509v3.h> | |||
| # include <openssl/safestack.h> | |||
| # include <openssl/ocsperr.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /* Various flags and values */ | |||
| # define OCSP_DEFAULT_NONCE_LENGTH 16 | |||
| # define OCSP_NOCERTS 0x1 | |||
| # define OCSP_NOINTERN 0x2 | |||
| # define OCSP_NOSIGS 0x4 | |||
| # define OCSP_NOCHAIN 0x8 | |||
| # define OCSP_NOVERIFY 0x10 | |||
| # define OCSP_NOEXPLICIT 0x20 | |||
| # define OCSP_NOCASIGN 0x40 | |||
| # define OCSP_NODELEGATED 0x80 | |||
| # define OCSP_NOCHECKS 0x100 | |||
| # define OCSP_TRUSTOTHER 0x200 | |||
| # define OCSP_RESPID_KEY 0x400 | |||
| # define OCSP_NOTIME 0x800 | |||
| typedef struct ocsp_cert_id_st OCSP_CERTID; | |||
| DEFINE_STACK_OF(OCSP_CERTID) | |||
| typedef struct ocsp_one_request_st OCSP_ONEREQ; | |||
| DEFINE_STACK_OF(OCSP_ONEREQ) | |||
| typedef struct ocsp_req_info_st OCSP_REQINFO; | |||
| typedef struct ocsp_signature_st OCSP_SIGNATURE; | |||
| typedef struct ocsp_request_st OCSP_REQUEST; | |||
| # define OCSP_RESPONSE_STATUS_SUCCESSFUL 0 | |||
| # define OCSP_RESPONSE_STATUS_MALFORMEDREQUEST 1 | |||
| # define OCSP_RESPONSE_STATUS_INTERNALERROR 2 | |||
| # define OCSP_RESPONSE_STATUS_TRYLATER 3 | |||
| # define OCSP_RESPONSE_STATUS_SIGREQUIRED 5 | |||
| # define OCSP_RESPONSE_STATUS_UNAUTHORIZED 6 | |||
| typedef struct ocsp_resp_bytes_st OCSP_RESPBYTES; | |||
| # define V_OCSP_RESPID_NAME 0 | |||
| # define V_OCSP_RESPID_KEY 1 | |||
| DEFINE_STACK_OF(OCSP_RESPID) | |||
| typedef struct ocsp_revoked_info_st OCSP_REVOKEDINFO; | |||
| # define V_OCSP_CERTSTATUS_GOOD 0 | |||
| # define V_OCSP_CERTSTATUS_REVOKED 1 | |||
| # define V_OCSP_CERTSTATUS_UNKNOWN 2 | |||
| typedef struct ocsp_cert_status_st OCSP_CERTSTATUS; | |||
| typedef struct ocsp_single_response_st OCSP_SINGLERESP; | |||
| DEFINE_STACK_OF(OCSP_SINGLERESP) | |||
| typedef struct ocsp_response_data_st OCSP_RESPDATA; | |||
| typedef struct ocsp_basic_response_st OCSP_BASICRESP; | |||
| typedef struct ocsp_crl_id_st OCSP_CRLID; | |||
| typedef struct ocsp_service_locator_st OCSP_SERVICELOC; | |||
| # define PEM_STRING_OCSP_REQUEST "OCSP REQUEST" | |||
| # define PEM_STRING_OCSP_RESPONSE "OCSP RESPONSE" | |||
| # define d2i_OCSP_REQUEST_bio(bp,p) ASN1_d2i_bio_of(OCSP_REQUEST,OCSP_REQUEST_new,d2i_OCSP_REQUEST,bp,p) | |||
| # define d2i_OCSP_RESPONSE_bio(bp,p) ASN1_d2i_bio_of(OCSP_RESPONSE,OCSP_RESPONSE_new,d2i_OCSP_RESPONSE,bp,p) | |||
| # define PEM_read_bio_OCSP_REQUEST(bp,x,cb) (OCSP_REQUEST *)PEM_ASN1_read_bio( \ | |||
| (char *(*)())d2i_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST, \ | |||
| bp,(char **)(x),cb,NULL) | |||
| # define PEM_read_bio_OCSP_RESPONSE(bp,x,cb) (OCSP_RESPONSE *)PEM_ASN1_read_bio(\ | |||
| (char *(*)())d2i_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE, \ | |||
| bp,(char **)(x),cb,NULL) | |||
| # define PEM_write_bio_OCSP_REQUEST(bp,o) \ | |||
| PEM_ASN1_write_bio((int (*)())i2d_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST,\ | |||
| bp,(char *)(o), NULL,NULL,0,NULL,NULL) | |||
| # define PEM_write_bio_OCSP_RESPONSE(bp,o) \ | |||
| PEM_ASN1_write_bio((int (*)())i2d_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE,\ | |||
| bp,(char *)(o), NULL,NULL,0,NULL,NULL) | |||
| # define i2d_OCSP_RESPONSE_bio(bp,o) ASN1_i2d_bio_of(OCSP_RESPONSE,i2d_OCSP_RESPONSE,bp,o) | |||
| # define i2d_OCSP_REQUEST_bio(bp,o) ASN1_i2d_bio_of(OCSP_REQUEST,i2d_OCSP_REQUEST,bp,o) | |||
| # define ASN1_BIT_STRING_digest(data,type,md,len) \ | |||
| ASN1_item_digest(ASN1_ITEM_rptr(ASN1_BIT_STRING),type,data,md,len) | |||
| # define OCSP_CERTSTATUS_dup(cs)\ | |||
| (OCSP_CERTSTATUS*)ASN1_dup((int(*)())i2d_OCSP_CERTSTATUS,\ | |||
| (char *(*)())d2i_OCSP_CERTSTATUS,(char *)(cs)) | |||
| OCSP_CERTID *OCSP_CERTID_dup(OCSP_CERTID *id); | |||
| OCSP_RESPONSE *OCSP_sendreq_bio(BIO *b, const char *path, OCSP_REQUEST *req); | |||
| OCSP_REQ_CTX *OCSP_sendreq_new(BIO *io, const char *path, OCSP_REQUEST *req, | |||
| int maxline); | |||
| int OCSP_REQ_CTX_nbio(OCSP_REQ_CTX *rctx); | |||
| int OCSP_sendreq_nbio(OCSP_RESPONSE **presp, OCSP_REQ_CTX *rctx); | |||
| OCSP_REQ_CTX *OCSP_REQ_CTX_new(BIO *io, int maxline); | |||
| void OCSP_REQ_CTX_free(OCSP_REQ_CTX *rctx); | |||
| void OCSP_set_max_response_length(OCSP_REQ_CTX *rctx, unsigned long len); | |||
| int OCSP_REQ_CTX_i2d(OCSP_REQ_CTX *rctx, const ASN1_ITEM *it, | |||
| ASN1_VALUE *val); | |||
| int OCSP_REQ_CTX_nbio_d2i(OCSP_REQ_CTX *rctx, ASN1_VALUE **pval, | |||
| const ASN1_ITEM *it); | |||
| BIO *OCSP_REQ_CTX_get0_mem_bio(OCSP_REQ_CTX *rctx); | |||
| int OCSP_REQ_CTX_http(OCSP_REQ_CTX *rctx, const char *op, const char *path); | |||
| int OCSP_REQ_CTX_set1_req(OCSP_REQ_CTX *rctx, OCSP_REQUEST *req); | |||
| int OCSP_REQ_CTX_add1_header(OCSP_REQ_CTX *rctx, | |||
| const char *name, const char *value); | |||
| OCSP_CERTID *OCSP_cert_to_id(const EVP_MD *dgst, const X509 *subject, | |||
| const X509 *issuer); | |||
| OCSP_CERTID *OCSP_cert_id_new(const EVP_MD *dgst, | |||
| const X509_NAME *issuerName, | |||
| const ASN1_BIT_STRING *issuerKey, | |||
| const ASN1_INTEGER *serialNumber); | |||
| OCSP_ONEREQ *OCSP_request_add0_id(OCSP_REQUEST *req, OCSP_CERTID *cid); | |||
| int OCSP_request_add1_nonce(OCSP_REQUEST *req, unsigned char *val, int len); | |||
| int OCSP_basic_add1_nonce(OCSP_BASICRESP *resp, unsigned char *val, int len); | |||
| int OCSP_check_nonce(OCSP_REQUEST *req, OCSP_BASICRESP *bs); | |||
| int OCSP_copy_nonce(OCSP_BASICRESP *resp, OCSP_REQUEST *req); | |||
| int OCSP_request_set1_name(OCSP_REQUEST *req, X509_NAME *nm); | |||
| int OCSP_request_add1_cert(OCSP_REQUEST *req, X509 *cert); | |||
| int OCSP_request_sign(OCSP_REQUEST *req, | |||
| X509 *signer, | |||
| EVP_PKEY *key, | |||
| const EVP_MD *dgst, | |||
| STACK_OF(X509) *certs, unsigned long flags); | |||
| int OCSP_response_status(OCSP_RESPONSE *resp); | |||
| OCSP_BASICRESP *OCSP_response_get1_basic(OCSP_RESPONSE *resp); | |||
| const ASN1_OCTET_STRING *OCSP_resp_get0_signature(const OCSP_BASICRESP *bs); | |||
| const X509_ALGOR *OCSP_resp_get0_tbs_sigalg(const OCSP_BASICRESP *bs); | |||
| const OCSP_RESPDATA *OCSP_resp_get0_respdata(const OCSP_BASICRESP *bs); | |||
| int OCSP_resp_get0_signer(OCSP_BASICRESP *bs, X509 **signer, | |||
| STACK_OF(X509) *extra_certs); | |||
| int OCSP_resp_count(OCSP_BASICRESP *bs); | |||
| OCSP_SINGLERESP *OCSP_resp_get0(OCSP_BASICRESP *bs, int idx); | |||
| const ASN1_GENERALIZEDTIME *OCSP_resp_get0_produced_at(const OCSP_BASICRESP* bs); | |||
| const STACK_OF(X509) *OCSP_resp_get0_certs(const OCSP_BASICRESP *bs); | |||
| int OCSP_resp_get0_id(const OCSP_BASICRESP *bs, | |||
| const ASN1_OCTET_STRING **pid, | |||
| const X509_NAME **pname); | |||
| int OCSP_resp_get1_id(const OCSP_BASICRESP *bs, | |||
| ASN1_OCTET_STRING **pid, | |||
| X509_NAME **pname); | |||
| int OCSP_resp_find(OCSP_BASICRESP *bs, OCSP_CERTID *id, int last); | |||
| int OCSP_single_get0_status(OCSP_SINGLERESP *single, int *reason, | |||
| ASN1_GENERALIZEDTIME **revtime, | |||
| ASN1_GENERALIZEDTIME **thisupd, | |||
| ASN1_GENERALIZEDTIME **nextupd); | |||
| int OCSP_resp_find_status(OCSP_BASICRESP *bs, OCSP_CERTID *id, int *status, | |||
| int *reason, | |||
| ASN1_GENERALIZEDTIME **revtime, | |||
| ASN1_GENERALIZEDTIME **thisupd, | |||
| ASN1_GENERALIZEDTIME **nextupd); | |||
| int OCSP_check_validity(ASN1_GENERALIZEDTIME *thisupd, | |||
| ASN1_GENERALIZEDTIME *nextupd, long sec, long maxsec); | |||
| int OCSP_request_verify(OCSP_REQUEST *req, STACK_OF(X509) *certs, | |||
| X509_STORE *store, unsigned long flags); | |||
| int OCSP_parse_url(const char *url, char **phost, char **pport, char **ppath, | |||
| int *pssl); | |||
| int OCSP_id_issuer_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b); | |||
| int OCSP_id_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b); | |||
| int OCSP_request_onereq_count(OCSP_REQUEST *req); | |||
| OCSP_ONEREQ *OCSP_request_onereq_get0(OCSP_REQUEST *req, int i); | |||
| OCSP_CERTID *OCSP_onereq_get0_id(OCSP_ONEREQ *one); | |||
| int OCSP_id_get0_info(ASN1_OCTET_STRING **piNameHash, ASN1_OBJECT **pmd, | |||
| ASN1_OCTET_STRING **pikeyHash, | |||
| ASN1_INTEGER **pserial, OCSP_CERTID *cid); | |||
| int OCSP_request_is_signed(OCSP_REQUEST *req); | |||
| OCSP_RESPONSE *OCSP_response_create(int status, OCSP_BASICRESP *bs); | |||
| OCSP_SINGLERESP *OCSP_basic_add1_status(OCSP_BASICRESP *rsp, | |||
| OCSP_CERTID *cid, | |||
| int status, int reason, | |||
| ASN1_TIME *revtime, | |||
| ASN1_TIME *thisupd, | |||
| ASN1_TIME *nextupd); | |||
| int OCSP_basic_add1_cert(OCSP_BASICRESP *resp, X509 *cert); | |||
| int OCSP_basic_sign(OCSP_BASICRESP *brsp, | |||
| X509 *signer, EVP_PKEY *key, const EVP_MD *dgst, | |||
| STACK_OF(X509) *certs, unsigned long flags); | |||
| int OCSP_basic_sign_ctx(OCSP_BASICRESP *brsp, | |||
| X509 *signer, EVP_MD_CTX *ctx, | |||
| STACK_OF(X509) *certs, unsigned long flags); | |||
| int OCSP_RESPID_set_by_name(OCSP_RESPID *respid, X509 *cert); | |||
| int OCSP_RESPID_set_by_key(OCSP_RESPID *respid, X509 *cert); | |||
| int OCSP_RESPID_match(OCSP_RESPID *respid, X509 *cert); | |||
| X509_EXTENSION *OCSP_crlID_new(const char *url, long *n, char *tim); | |||
| X509_EXTENSION *OCSP_accept_responses_new(char **oids); | |||
| X509_EXTENSION *OCSP_archive_cutoff_new(char *tim); | |||
| X509_EXTENSION *OCSP_url_svcloc_new(X509_NAME *issuer, const char **urls); | |||
| int OCSP_REQUEST_get_ext_count(OCSP_REQUEST *x); | |||
| int OCSP_REQUEST_get_ext_by_NID(OCSP_REQUEST *x, int nid, int lastpos); | |||
| int OCSP_REQUEST_get_ext_by_OBJ(OCSP_REQUEST *x, const ASN1_OBJECT *obj, | |||
| int lastpos); | |||
| int OCSP_REQUEST_get_ext_by_critical(OCSP_REQUEST *x, int crit, int lastpos); | |||
| X509_EXTENSION *OCSP_REQUEST_get_ext(OCSP_REQUEST *x, int loc); | |||
| X509_EXTENSION *OCSP_REQUEST_delete_ext(OCSP_REQUEST *x, int loc); | |||
| void *OCSP_REQUEST_get1_ext_d2i(OCSP_REQUEST *x, int nid, int *crit, | |||
| int *idx); | |||
| int OCSP_REQUEST_add1_ext_i2d(OCSP_REQUEST *x, int nid, void *value, int crit, | |||
| unsigned long flags); | |||
| int OCSP_REQUEST_add_ext(OCSP_REQUEST *x, X509_EXTENSION *ex, int loc); | |||
| int OCSP_ONEREQ_get_ext_count(OCSP_ONEREQ *x); | |||
| int OCSP_ONEREQ_get_ext_by_NID(OCSP_ONEREQ *x, int nid, int lastpos); | |||
| int OCSP_ONEREQ_get_ext_by_OBJ(OCSP_ONEREQ *x, const ASN1_OBJECT *obj, int lastpos); | |||
| int OCSP_ONEREQ_get_ext_by_critical(OCSP_ONEREQ *x, int crit, int lastpos); | |||
| X509_EXTENSION *OCSP_ONEREQ_get_ext(OCSP_ONEREQ *x, int loc); | |||
| X509_EXTENSION *OCSP_ONEREQ_delete_ext(OCSP_ONEREQ *x, int loc); | |||
| void *OCSP_ONEREQ_get1_ext_d2i(OCSP_ONEREQ *x, int nid, int *crit, int *idx); | |||
| int OCSP_ONEREQ_add1_ext_i2d(OCSP_ONEREQ *x, int nid, void *value, int crit, | |||
| unsigned long flags); | |||
| int OCSP_ONEREQ_add_ext(OCSP_ONEREQ *x, X509_EXTENSION *ex, int loc); | |||
| int OCSP_BASICRESP_get_ext_count(OCSP_BASICRESP *x); | |||
| int OCSP_BASICRESP_get_ext_by_NID(OCSP_BASICRESP *x, int nid, int lastpos); | |||
| int OCSP_BASICRESP_get_ext_by_OBJ(OCSP_BASICRESP *x, const ASN1_OBJECT *obj, | |||
| int lastpos); | |||
| int OCSP_BASICRESP_get_ext_by_critical(OCSP_BASICRESP *x, int crit, | |||
| int lastpos); | |||
| X509_EXTENSION *OCSP_BASICRESP_get_ext(OCSP_BASICRESP *x, int loc); | |||
| X509_EXTENSION *OCSP_BASICRESP_delete_ext(OCSP_BASICRESP *x, int loc); | |||
| void *OCSP_BASICRESP_get1_ext_d2i(OCSP_BASICRESP *x, int nid, int *crit, | |||
| int *idx); | |||
| int OCSP_BASICRESP_add1_ext_i2d(OCSP_BASICRESP *x, int nid, void *value, | |||
| int crit, unsigned long flags); | |||
| int OCSP_BASICRESP_add_ext(OCSP_BASICRESP *x, X509_EXTENSION *ex, int loc); | |||
| int OCSP_SINGLERESP_get_ext_count(OCSP_SINGLERESP *x); | |||
| int OCSP_SINGLERESP_get_ext_by_NID(OCSP_SINGLERESP *x, int nid, int lastpos); | |||
| int OCSP_SINGLERESP_get_ext_by_OBJ(OCSP_SINGLERESP *x, const ASN1_OBJECT *obj, | |||
| int lastpos); | |||
| int OCSP_SINGLERESP_get_ext_by_critical(OCSP_SINGLERESP *x, int crit, | |||
| int lastpos); | |||
| X509_EXTENSION *OCSP_SINGLERESP_get_ext(OCSP_SINGLERESP *x, int loc); | |||
| X509_EXTENSION *OCSP_SINGLERESP_delete_ext(OCSP_SINGLERESP *x, int loc); | |||
| void *OCSP_SINGLERESP_get1_ext_d2i(OCSP_SINGLERESP *x, int nid, int *crit, | |||
| int *idx); | |||
| int OCSP_SINGLERESP_add1_ext_i2d(OCSP_SINGLERESP *x, int nid, void *value, | |||
| int crit, unsigned long flags); | |||
| int OCSP_SINGLERESP_add_ext(OCSP_SINGLERESP *x, X509_EXTENSION *ex, int loc); | |||
| const OCSP_CERTID *OCSP_SINGLERESP_get0_id(const OCSP_SINGLERESP *x); | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_SINGLERESP) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_CERTSTATUS) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_REVOKEDINFO) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_BASICRESP) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_RESPDATA) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_RESPID) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_RESPONSE) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_RESPBYTES) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_ONEREQ) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_CERTID) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_REQUEST) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_SIGNATURE) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_REQINFO) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_CRLID) | |||
| DECLARE_ASN1_FUNCTIONS(OCSP_SERVICELOC) | |||
| const char *OCSP_response_status_str(long s); | |||
| const char *OCSP_cert_status_str(long s); | |||
| const char *OCSP_crl_reason_str(long s); | |||
| int OCSP_REQUEST_print(BIO *bp, OCSP_REQUEST *a, unsigned long flags); | |||
| int OCSP_RESPONSE_print(BIO *bp, OCSP_RESPONSE *o, unsigned long flags); | |||
| int OCSP_basic_verify(OCSP_BASICRESP *bs, STACK_OF(X509) *certs, | |||
| X509_STORE *st, unsigned long flags); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,78 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_OCSPERR_H | |||
| # define HEADER_OCSPERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_OCSP | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_OCSP_strings(void); | |||
| /* | |||
| * OCSP function codes. | |||
| */ | |||
| # define OCSP_F_D2I_OCSP_NONCE 102 | |||
| # define OCSP_F_OCSP_BASIC_ADD1_STATUS 103 | |||
| # define OCSP_F_OCSP_BASIC_SIGN 104 | |||
| # define OCSP_F_OCSP_BASIC_SIGN_CTX 119 | |||
| # define OCSP_F_OCSP_BASIC_VERIFY 105 | |||
| # define OCSP_F_OCSP_CERT_ID_NEW 101 | |||
| # define OCSP_F_OCSP_CHECK_DELEGATED 106 | |||
| # define OCSP_F_OCSP_CHECK_IDS 107 | |||
| # define OCSP_F_OCSP_CHECK_ISSUER 108 | |||
| # define OCSP_F_OCSP_CHECK_VALIDITY 115 | |||
| # define OCSP_F_OCSP_MATCH_ISSUERID 109 | |||
| # define OCSP_F_OCSP_PARSE_URL 114 | |||
| # define OCSP_F_OCSP_REQUEST_SIGN 110 | |||
| # define OCSP_F_OCSP_REQUEST_VERIFY 116 | |||
| # define OCSP_F_OCSP_RESPONSE_GET1_BASIC 111 | |||
| # define OCSP_F_PARSE_HTTP_LINE1 118 | |||
| /* | |||
| * OCSP reason codes. | |||
| */ | |||
| # define OCSP_R_CERTIFICATE_VERIFY_ERROR 101 | |||
| # define OCSP_R_DIGEST_ERR 102 | |||
| # define OCSP_R_ERROR_IN_NEXTUPDATE_FIELD 122 | |||
| # define OCSP_R_ERROR_IN_THISUPDATE_FIELD 123 | |||
| # define OCSP_R_ERROR_PARSING_URL 121 | |||
| # define OCSP_R_MISSING_OCSPSIGNING_USAGE 103 | |||
| # define OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE 124 | |||
| # define OCSP_R_NOT_BASIC_RESPONSE 104 | |||
| # define OCSP_R_NO_CERTIFICATES_IN_CHAIN 105 | |||
| # define OCSP_R_NO_RESPONSE_DATA 108 | |||
| # define OCSP_R_NO_REVOKED_TIME 109 | |||
| # define OCSP_R_NO_SIGNER_KEY 130 | |||
| # define OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 110 | |||
| # define OCSP_R_REQUEST_NOT_SIGNED 128 | |||
| # define OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA 111 | |||
| # define OCSP_R_ROOT_CA_NOT_TRUSTED 112 | |||
| # define OCSP_R_SERVER_RESPONSE_ERROR 114 | |||
| # define OCSP_R_SERVER_RESPONSE_PARSE_ERROR 115 | |||
| # define OCSP_R_SIGNATURE_FAILURE 117 | |||
| # define OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND 118 | |||
| # define OCSP_R_STATUS_EXPIRED 125 | |||
| # define OCSP_R_STATUS_NOT_YET_VALID 126 | |||
| # define OCSP_R_STATUS_TOO_OLD 127 | |||
| # define OCSP_R_UNKNOWN_MESSAGE_DIGEST 119 | |||
| # define OCSP_R_UNKNOWN_NID 120 | |||
| # define OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE 129 | |||
| # endif | |||
| #endif | |||
| @ -1,213 +0,0 @@ | |||
| /* | |||
| * WARNING: do not edit! | |||
| * Generated by makefile from ..\include\openssl\opensslconf.h.in | |||
| * | |||
| * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #include <openssl/opensslv.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| #ifdef OPENSSL_ALGORITHM_DEFINES | |||
| # error OPENSSL_ALGORITHM_DEFINES no longer supported | |||
| #endif | |||
| /* | |||
| * OpenSSL was configured with the following options: | |||
| */ | |||
| #ifndef OPENSSL_SYS_WIN64A | |||
| # define OPENSSL_SYS_WIN64A 1 | |||
| #endif | |||
| #define OPENSSL_MIN_API 0x10100000L | |||
| #ifndef OPENSSL_NO_COMP | |||
| # define OPENSSL_NO_COMP | |||
| #endif | |||
| #ifndef OPENSSL_NO_MD2 | |||
| # define OPENSSL_NO_MD2 | |||
| #endif | |||
| #ifndef OPENSSL_NO_RC5 | |||
| # define OPENSSL_NO_RC5 | |||
| #endif | |||
| #ifndef OPENSSL_THREADS | |||
| # define OPENSSL_THREADS | |||
| #endif | |||
| #ifndef OPENSSL_RAND_SEED_OS | |||
| # define OPENSSL_RAND_SEED_OS | |||
| #endif | |||
| #ifndef OPENSSL_NO_AFALGENG | |||
| # define OPENSSL_NO_AFALGENG | |||
| #endif | |||
| #ifndef OPENSSL_NO_ASAN | |||
| # define OPENSSL_NO_ASAN | |||
| #endif | |||
| #ifndef OPENSSL_NO_ASM | |||
| # define OPENSSL_NO_ASM | |||
| #endif | |||
| #ifndef OPENSSL_NO_CRYPTO_MDEBUG | |||
| # define OPENSSL_NO_CRYPTO_MDEBUG | |||
| #endif | |||
| #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE | |||
| # define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE | |||
| #endif | |||
| #ifndef OPENSSL_NO_DEVCRYPTOENG | |||
| # define OPENSSL_NO_DEVCRYPTOENG | |||
| #endif | |||
| #ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 | |||
| # define OPENSSL_NO_EC_NISTP_64_GCC_128 | |||
| #endif | |||
| #ifndef OPENSSL_NO_EGD | |||
| # define OPENSSL_NO_EGD | |||
| #endif | |||
| #ifndef OPENSSL_NO_EXTERNAL_TESTS | |||
| # define OPENSSL_NO_EXTERNAL_TESTS | |||
| #endif | |||
| #ifndef OPENSSL_NO_FUZZ_AFL | |||
| # define OPENSSL_NO_FUZZ_AFL | |||
| #endif | |||
| #ifndef OPENSSL_NO_FUZZ_LIBFUZZER | |||
| # define OPENSSL_NO_FUZZ_LIBFUZZER | |||
| #endif | |||
| #ifndef OPENSSL_NO_HEARTBEATS | |||
| # define OPENSSL_NO_HEARTBEATS | |||
| #endif | |||
| #ifndef OPENSSL_NO_MSAN | |||
| # define OPENSSL_NO_MSAN | |||
| #endif | |||
| #ifndef OPENSSL_NO_SCTP | |||
| # define OPENSSL_NO_SCTP | |||
| #endif | |||
| #ifndef OPENSSL_NO_SSL_TRACE | |||
| # define OPENSSL_NO_SSL_TRACE | |||
| #endif | |||
| #ifndef OPENSSL_NO_SSL3 | |||
| # define OPENSSL_NO_SSL3 | |||
| #endif | |||
| #ifndef OPENSSL_NO_SSL3_METHOD | |||
| # define OPENSSL_NO_SSL3_METHOD | |||
| #endif | |||
| #ifndef OPENSSL_NO_UBSAN | |||
| # define OPENSSL_NO_UBSAN | |||
| #endif | |||
| #ifndef OPENSSL_NO_UI_CONSOLE | |||
| # define OPENSSL_NO_UI_CONSOLE | |||
| #endif | |||
| #ifndef OPENSSL_NO_UNIT_TEST | |||
| # define OPENSSL_NO_UNIT_TEST | |||
| #endif | |||
| #ifndef OPENSSL_NO_WEAK_SSL_CIPHERS | |||
| # define OPENSSL_NO_WEAK_SSL_CIPHERS | |||
| #endif | |||
| #ifndef OPENSSL_NO_STATIC_ENGINE | |||
| # define OPENSSL_NO_STATIC_ENGINE | |||
| #endif | |||
| /* | |||
| * Sometimes OPENSSSL_NO_xxx ends up with an empty file and some compilers | |||
| * don't like that. This will hopefully silence them. | |||
| */ | |||
| #define NON_EMPTY_TRANSLATION_UNIT static void *dummy = &dummy; | |||
| /* | |||
| * Applications should use -DOPENSSL_API_COMPAT=<version> to suppress the | |||
| * declarations of functions deprecated in or before <version>. Otherwise, they | |||
| * still won't see them if the library has been built to disable deprecated | |||
| * functions. | |||
| */ | |||
| #ifndef DECLARE_DEPRECATED | |||
| # define DECLARE_DEPRECATED(f) f; | |||
| # ifdef __GNUC__ | |||
| # if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0) | |||
| # undef DECLARE_DEPRECATED | |||
| # define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); | |||
| # endif | |||
| # elif defined(__SUNPRO_C) | |||
| # if (__SUNPRO_C >= 0x5130) | |||
| # undef DECLARE_DEPRECATED | |||
| # define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); | |||
| # endif | |||
| # endif | |||
| #endif | |||
| #ifndef OPENSSL_FILE | |||
| # ifdef OPENSSL_NO_FILENAMES | |||
| # define OPENSSL_FILE "" | |||
| # define OPENSSL_LINE 0 | |||
| # else | |||
| # define OPENSSL_FILE __FILE__ | |||
| # define OPENSSL_LINE __LINE__ | |||
| # endif | |||
| #endif | |||
| #ifndef OPENSSL_MIN_API | |||
| # define OPENSSL_MIN_API 0 | |||
| #endif | |||
| #if !defined(OPENSSL_API_COMPAT) || OPENSSL_API_COMPAT < OPENSSL_MIN_API | |||
| # undef OPENSSL_API_COMPAT | |||
| # define OPENSSL_API_COMPAT OPENSSL_MIN_API | |||
| #endif | |||
| /* | |||
| * Do not deprecate things to be deprecated in version 1.2.0 before the | |||
| * OpenSSL version number matches. | |||
| */ | |||
| #if OPENSSL_VERSION_NUMBER < 0x10200000L | |||
| # define DEPRECATEDIN_1_2_0(f) f; | |||
| #elif OPENSSL_API_COMPAT < 0x10200000L | |||
| # define DEPRECATEDIN_1_2_0(f) DECLARE_DEPRECATED(f) | |||
| #else | |||
| # define DEPRECATEDIN_1_2_0(f) | |||
| #endif | |||
| #if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define DEPRECATEDIN_1_1_0(f) DECLARE_DEPRECATED(f) | |||
| #else | |||
| # define DEPRECATEDIN_1_1_0(f) | |||
| #endif | |||
| #if OPENSSL_API_COMPAT < 0x10000000L | |||
| # define DEPRECATEDIN_1_0_0(f) DECLARE_DEPRECATED(f) | |||
| #else | |||
| # define DEPRECATEDIN_1_0_0(f) | |||
| #endif | |||
| #if OPENSSL_API_COMPAT < 0x00908000L | |||
| # define DEPRECATEDIN_0_9_8(f) DECLARE_DEPRECATED(f) | |||
| #else | |||
| # define DEPRECATEDIN_0_9_8(f) | |||
| #endif | |||
| /* Generate 80386 code? */ | |||
| #undef I386_ONLY | |||
| #undef OPENSSL_UNISTD | |||
| #define OPENSSL_UNISTD <unistd.h> | |||
| #define OPENSSL_EXPORT_VAR_AS_FUNCTION | |||
| /* | |||
| * The following are cipher-specific, but are part of the public API. | |||
| */ | |||
| #if !defined(OPENSSL_SYS_UEFI) | |||
| # undef BN_LLONG | |||
| /* Only one for the following should be defined */ | |||
| # undef SIXTY_FOUR_BIT_LONG | |||
| # define SIXTY_FOUR_BIT | |||
| # undef THIRTY_TWO_BIT | |||
| #endif | |||
| #define RC4_INT unsigned int | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| @ -1,101 +0,0 @@ | |||
| /* | |||
| * Copyright 1999-2020 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_OPENSSLV_H | |||
| # define HEADER_OPENSSLV_H | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /*- | |||
| * Numeric release version identifier: | |||
| * MNNFFPPS: major minor fix patch status | |||
| * The status nibble has one of the values 0 for development, 1 to e for betas | |||
| * 1 to 14, and f for release. The patch level is exactly that. | |||
| * For example: | |||
| * 0.9.3-dev 0x00903000 | |||
| * 0.9.3-beta1 0x00903001 | |||
| * 0.9.3-beta2-dev 0x00903002 | |||
| * 0.9.3-beta2 0x00903002 (same as ...beta2-dev) | |||
| * 0.9.3 0x0090300f | |||
| * 0.9.3a 0x0090301f | |||
| * 0.9.4 0x0090400f | |||
| * 1.2.3z 0x102031af | |||
| * | |||
| * For continuity reasons (because 0.9.5 is already out, and is coded | |||
| * 0x00905100), between 0.9.5 and 0.9.6 the coding of the patch level | |||
| * part is slightly different, by setting the highest bit. This means | |||
| * that 0.9.5a looks like this: 0x0090581f. At 0.9.6, we can start | |||
| * with 0x0090600S... | |||
| * | |||
| * (Prior to 0.9.3-dev a different scheme was used: 0.9.2b is 0x0922.) | |||
| * (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for | |||
| * major minor fix final patch/beta) | |||
| */ | |||
| # define OPENSSL_VERSION_NUMBER 0x10101080L | |||
| # define OPENSSL_VERSION_TEXT "OpenSSL 1.1.1h-dev xx XXX xxxx" | |||
| /*- | |||
| * The macros below are to be used for shared library (.so, .dll, ...) | |||
| * versioning. That kind of versioning works a bit differently between | |||
| * operating systems. The most usual scheme is to set a major and a minor | |||
| * number, and have the runtime loader check that the major number is equal | |||
| * to what it was at application link time, while the minor number has to | |||
| * be greater or equal to what it was at application link time. With this | |||
| * scheme, the version number is usually part of the file name, like this: | |||
| * | |||
| * libcrypto.so.0.9 | |||
| * | |||
| * Some unixen also make a softlink with the major version number only: | |||
| * | |||
| * libcrypto.so.0 | |||
| * | |||
| * On Tru64 and IRIX 6.x it works a little bit differently. There, the | |||
| * shared library version is stored in the file, and is actually a series | |||
| * of versions, separated by colons. The rightmost version present in the | |||
| * library when linking an application is stored in the application to be | |||
| * matched at run time. When the application is run, a check is done to | |||
| * see if the library version stored in the application matches any of the | |||
| * versions in the version string of the library itself. | |||
| * This version string can be constructed in any way, depending on what | |||
| * kind of matching is desired. However, to implement the same scheme as | |||
| * the one used in the other unixen, all compatible versions, from lowest | |||
| * to highest, should be part of the string. Consecutive builds would | |||
| * give the following versions strings: | |||
| * | |||
| * 3.0 | |||
| * 3.0:3.1 | |||
| * 3.0:3.1:3.2 | |||
| * 4.0 | |||
| * 4.0:4.1 | |||
| * | |||
| * Notice how version 4 is completely incompatible with version, and | |||
| * therefore give the breach you can see. | |||
| * | |||
| * There may be other schemes as well that I haven't yet discovered. | |||
| * | |||
| * So, here's the way it works here: first of all, the library version | |||
| * number doesn't need at all to match the overall OpenSSL version. | |||
| * However, it's nice and more understandable if it actually does. | |||
| * The current library version is stored in the macro SHLIB_VERSION_NUMBER, | |||
| * which is just a piece of text in the format "M.m.e" (Major, minor, edit). | |||
| * For the sake of Tru64, IRIX, and any other OS that behaves in similar ways, | |||
| * we need to keep a history of version numbers, which is done in the | |||
| * macro SHLIB_VERSION_HISTORY. The numbers are separated by colons and | |||
| * should only keep the versions that are binary compatible with the current. | |||
| */ | |||
| # define SHLIB_VERSION_HISTORY "" | |||
| # define SHLIB_VERSION_NUMBER "1.1" | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif /* HEADER_OPENSSLV_H */ | |||
| @ -1,197 +0,0 @@ | |||
| /* | |||
| * Copyright 2001-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_OPENSSL_TYPES_H | |||
| # define HEADER_OPENSSL_TYPES_H | |||
| #include <limits.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # include <openssl/e_os2.h> | |||
| # ifdef NO_ASN1_TYPEDEFS | |||
| # define ASN1_INTEGER ASN1_STRING | |||
| # define ASN1_ENUMERATED ASN1_STRING | |||
| # define ASN1_BIT_STRING ASN1_STRING | |||
| # define ASN1_OCTET_STRING ASN1_STRING | |||
| # define ASN1_PRINTABLESTRING ASN1_STRING | |||
| # define ASN1_T61STRING ASN1_STRING | |||
| # define ASN1_IA5STRING ASN1_STRING | |||
| # define ASN1_UTCTIME ASN1_STRING | |||
| # define ASN1_GENERALIZEDTIME ASN1_STRING | |||
| # define ASN1_TIME ASN1_STRING | |||
| # define ASN1_GENERALSTRING ASN1_STRING | |||
| # define ASN1_UNIVERSALSTRING ASN1_STRING | |||
| # define ASN1_BMPSTRING ASN1_STRING | |||
| # define ASN1_VISIBLESTRING ASN1_STRING | |||
| # define ASN1_UTF8STRING ASN1_STRING | |||
| # define ASN1_BOOLEAN int | |||
| # define ASN1_NULL int | |||
| # else | |||
| typedef struct asn1_string_st ASN1_INTEGER; | |||
| typedef struct asn1_string_st ASN1_ENUMERATED; | |||
| typedef struct asn1_string_st ASN1_BIT_STRING; | |||
| typedef struct asn1_string_st ASN1_OCTET_STRING; | |||
| typedef struct asn1_string_st ASN1_PRINTABLESTRING; | |||
| typedef struct asn1_string_st ASN1_T61STRING; | |||
| typedef struct asn1_string_st ASN1_IA5STRING; | |||
| typedef struct asn1_string_st ASN1_GENERALSTRING; | |||
| typedef struct asn1_string_st ASN1_UNIVERSALSTRING; | |||
| typedef struct asn1_string_st ASN1_BMPSTRING; | |||
| typedef struct asn1_string_st ASN1_UTCTIME; | |||
| typedef struct asn1_string_st ASN1_TIME; | |||
| typedef struct asn1_string_st ASN1_GENERALIZEDTIME; | |||
| typedef struct asn1_string_st ASN1_VISIBLESTRING; | |||
| typedef struct asn1_string_st ASN1_UTF8STRING; | |||
| typedef struct asn1_string_st ASN1_STRING; | |||
| typedef int ASN1_BOOLEAN; | |||
| typedef int ASN1_NULL; | |||
| # endif | |||
| typedef struct asn1_object_st ASN1_OBJECT; | |||
| typedef struct ASN1_ITEM_st ASN1_ITEM; | |||
| typedef struct asn1_pctx_st ASN1_PCTX; | |||
| typedef struct asn1_sctx_st ASN1_SCTX; | |||
| # ifdef _WIN32 | |||
| # undef X509_NAME | |||
| # undef X509_EXTENSIONS | |||
| # undef PKCS7_ISSUER_AND_SERIAL | |||
| # undef PKCS7_SIGNER_INFO | |||
| # undef OCSP_REQUEST | |||
| # undef OCSP_RESPONSE | |||
| # endif | |||
| # ifdef BIGNUM | |||
| # undef BIGNUM | |||
| # endif | |||
| struct dane_st; | |||
| typedef struct bio_st BIO; | |||
| typedef struct bignum_st BIGNUM; | |||
| typedef struct bignum_ctx BN_CTX; | |||
| typedef struct bn_blinding_st BN_BLINDING; | |||
| typedef struct bn_mont_ctx_st BN_MONT_CTX; | |||
| typedef struct bn_recp_ctx_st BN_RECP_CTX; | |||
| typedef struct bn_gencb_st BN_GENCB; | |||
| typedef struct buf_mem_st BUF_MEM; | |||
| typedef struct evp_cipher_st EVP_CIPHER; | |||
| typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX; | |||
| typedef struct evp_md_st EVP_MD; | |||
| typedef struct evp_md_ctx_st EVP_MD_CTX; | |||
| typedef struct evp_pkey_st EVP_PKEY; | |||
| typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD; | |||
| typedef struct evp_pkey_method_st EVP_PKEY_METHOD; | |||
| typedef struct evp_pkey_ctx_st EVP_PKEY_CTX; | |||
| typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX; | |||
| typedef struct hmac_ctx_st HMAC_CTX; | |||
| typedef struct dh_st DH; | |||
| typedef struct dh_method DH_METHOD; | |||
| typedef struct dsa_st DSA; | |||
| typedef struct dsa_method DSA_METHOD; | |||
| typedef struct rsa_st RSA; | |||
| typedef struct rsa_meth_st RSA_METHOD; | |||
| typedef struct rsa_pss_params_st RSA_PSS_PARAMS; | |||
| typedef struct ec_key_st EC_KEY; | |||
| typedef struct ec_key_method_st EC_KEY_METHOD; | |||
| typedef struct rand_meth_st RAND_METHOD; | |||
| typedef struct rand_drbg_st RAND_DRBG; | |||
| typedef struct ssl_dane_st SSL_DANE; | |||
| typedef struct x509_st X509; | |||
| typedef struct X509_algor_st X509_ALGOR; | |||
| typedef struct X509_crl_st X509_CRL; | |||
| typedef struct x509_crl_method_st X509_CRL_METHOD; | |||
| typedef struct x509_revoked_st X509_REVOKED; | |||
| typedef struct X509_name_st X509_NAME; | |||
| typedef struct X509_pubkey_st X509_PUBKEY; | |||
| typedef struct x509_store_st X509_STORE; | |||
| typedef struct x509_store_ctx_st X509_STORE_CTX; | |||
| typedef struct x509_object_st X509_OBJECT; | |||
| typedef struct x509_lookup_st X509_LOOKUP; | |||
| typedef struct x509_lookup_method_st X509_LOOKUP_METHOD; | |||
| typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM; | |||
| typedef struct x509_sig_info_st X509_SIG_INFO; | |||
| typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO; | |||
| typedef struct v3_ext_ctx X509V3_CTX; | |||
| typedef struct conf_st CONF; | |||
| typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS; | |||
| typedef struct ui_st UI; | |||
| typedef struct ui_method_st UI_METHOD; | |||
| typedef struct engine_st ENGINE; | |||
| typedef struct ssl_st SSL; | |||
| typedef struct ssl_ctx_st SSL_CTX; | |||
| typedef struct comp_ctx_st COMP_CTX; | |||
| typedef struct comp_method_st COMP_METHOD; | |||
| typedef struct X509_POLICY_NODE_st X509_POLICY_NODE; | |||
| typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL; | |||
| typedef struct X509_POLICY_TREE_st X509_POLICY_TREE; | |||
| typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE; | |||
| typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID; | |||
| typedef struct DIST_POINT_st DIST_POINT; | |||
| typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT; | |||
| typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS; | |||
| typedef struct crypto_ex_data_st CRYPTO_EX_DATA; | |||
| typedef struct ocsp_req_ctx_st OCSP_REQ_CTX; | |||
| typedef struct ocsp_response_st OCSP_RESPONSE; | |||
| typedef struct ocsp_responder_id_st OCSP_RESPID; | |||
| typedef struct sct_st SCT; | |||
| typedef struct sct_ctx_st SCT_CTX; | |||
| typedef struct ctlog_st CTLOG; | |||
| typedef struct ctlog_store_st CTLOG_STORE; | |||
| typedef struct ct_policy_eval_ctx_st CT_POLICY_EVAL_CTX; | |||
| typedef struct ossl_store_info_st OSSL_STORE_INFO; | |||
| typedef struct ossl_store_search_st OSSL_STORE_SEARCH; | |||
| #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \ | |||
| defined(INTMAX_MAX) && defined(UINTMAX_MAX) | |||
| typedef intmax_t ossl_intmax_t; | |||
| typedef uintmax_t ossl_uintmax_t; | |||
| #else | |||
| /* | |||
| * Not long long, because the C-library can only be expected to provide | |||
| * strtoll(), strtoull() at the same time as intmax_t and strtoimax(), | |||
| * strtoumax(). Since we use these for parsing arguments, we need the | |||
| * conversion functions, not just the sizes. | |||
| */ | |||
| typedef long ossl_intmax_t; | |||
| typedef unsigned long ossl_uintmax_t; | |||
| #endif | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif /* def HEADER_OPENSSL_TYPES_H */ | |||
| @ -1,378 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_PEM_H | |||
| # define HEADER_PEM_H | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/bio.h> | |||
| # include <openssl/safestack.h> | |||
| # include <openssl/evp.h> | |||
| # include <openssl/x509.h> | |||
| # include <openssl/pemerr.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # define PEM_BUFSIZE 1024 | |||
| # define PEM_STRING_X509_OLD "X509 CERTIFICATE" | |||
| # define PEM_STRING_X509 "CERTIFICATE" | |||
| # define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE" | |||
| # define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST" | |||
| # define PEM_STRING_X509_REQ "CERTIFICATE REQUEST" | |||
| # define PEM_STRING_X509_CRL "X509 CRL" | |||
| # define PEM_STRING_EVP_PKEY "ANY PRIVATE KEY" | |||
| # define PEM_STRING_PUBLIC "PUBLIC KEY" | |||
| # define PEM_STRING_RSA "RSA PRIVATE KEY" | |||
| # define PEM_STRING_RSA_PUBLIC "RSA PUBLIC KEY" | |||
| # define PEM_STRING_DSA "DSA PRIVATE KEY" | |||
| # define PEM_STRING_DSA_PUBLIC "DSA PUBLIC KEY" | |||
| # define PEM_STRING_PKCS7 "PKCS7" | |||
| # define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA" | |||
| # define PEM_STRING_PKCS8 "ENCRYPTED PRIVATE KEY" | |||
| # define PEM_STRING_PKCS8INF "PRIVATE KEY" | |||
| # define PEM_STRING_DHPARAMS "DH PARAMETERS" | |||
| # define PEM_STRING_DHXPARAMS "X9.42 DH PARAMETERS" | |||
| # define PEM_STRING_SSL_SESSION "SSL SESSION PARAMETERS" | |||
| # define PEM_STRING_DSAPARAMS "DSA PARAMETERS" | |||
| # define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY" | |||
| # define PEM_STRING_ECPARAMETERS "EC PARAMETERS" | |||
| # define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY" | |||
| # define PEM_STRING_PARAMETERS "PARAMETERS" | |||
| # define PEM_STRING_CMS "CMS" | |||
| # define PEM_TYPE_ENCRYPTED 10 | |||
| # define PEM_TYPE_MIC_ONLY 20 | |||
| # define PEM_TYPE_MIC_CLEAR 30 | |||
| # define PEM_TYPE_CLEAR 40 | |||
| /* | |||
| * These macros make the PEM_read/PEM_write functions easier to maintain and | |||
| * write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or | |||
| * IMPLEMENT_PEM_rw_cb(...) | |||
| */ | |||
| # ifdef OPENSSL_NO_STDIO | |||
| # define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/ | |||
| # define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/ | |||
| # define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/ | |||
| # define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/ | |||
| # define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/ | |||
| # else | |||
| # define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \ | |||
| type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\ | |||
| { \ | |||
| return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str,fp,(void **)x,cb,u); \ | |||
| } | |||
| # define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \ | |||
| int PEM_write_##name(FILE *fp, type *x) \ | |||
| { \ | |||
| return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL); \ | |||
| } | |||
| # define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \ | |||
| int PEM_write_##name(FILE *fp, const type *x) \ | |||
| { \ | |||
| return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,(void *)x,NULL,NULL,0,NULL,NULL); \ | |||
| } | |||
| # define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \ | |||
| int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ | |||
| unsigned char *kstr, int klen, pem_password_cb *cb, \ | |||
| void *u) \ | |||
| { \ | |||
| return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ | |||
| } | |||
| # define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \ | |||
| int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ | |||
| unsigned char *kstr, int klen, pem_password_cb *cb, \ | |||
| void *u) \ | |||
| { \ | |||
| return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ | |||
| } | |||
| # endif | |||
| # define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ | |||
| type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\ | |||
| { \ | |||
| return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str,bp,(void **)x,cb,u); \ | |||
| } | |||
| # define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ | |||
| int PEM_write_bio_##name(BIO *bp, type *x) \ | |||
| { \ | |||
| return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL); \ | |||
| } | |||
| # define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ | |||
| int PEM_write_bio_##name(BIO *bp, const type *x) \ | |||
| { \ | |||
| return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,NULL,NULL,0,NULL,NULL); \ | |||
| } | |||
| # define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ | |||
| int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ | |||
| unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ | |||
| { \ | |||
| return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u); \ | |||
| } | |||
| # define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ | |||
| int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ | |||
| unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ | |||
| { \ | |||
| return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,enc,kstr,klen,cb,u); \ | |||
| } | |||
| # define IMPLEMENT_PEM_write(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_fp(name, type, str, asn1) | |||
| # define IMPLEMENT_PEM_write_const(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) | |||
| # define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) | |||
| # define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) | |||
| # define IMPLEMENT_PEM_read(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_read_fp(name, type, str, asn1) | |||
| # define IMPLEMENT_PEM_rw(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_read(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write(name, type, str, asn1) | |||
| # define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_read(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_const(name, type, str, asn1) | |||
| # define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_read(name, type, str, asn1) \ | |||
| IMPLEMENT_PEM_write_cb(name, type, str, asn1) | |||
| /* These are the same except they are for the declarations */ | |||
| # if defined(OPENSSL_NO_STDIO) | |||
| # define DECLARE_PEM_read_fp(name, type) /**/ | |||
| # define DECLARE_PEM_write_fp(name, type) /**/ | |||
| # define DECLARE_PEM_write_fp_const(name, type) /**/ | |||
| # define DECLARE_PEM_write_cb_fp(name, type) /**/ | |||
| # else | |||
| # define DECLARE_PEM_read_fp(name, type) \ | |||
| type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u); | |||
| # define DECLARE_PEM_write_fp(name, type) \ | |||
| int PEM_write_##name(FILE *fp, type *x); | |||
| # define DECLARE_PEM_write_fp_const(name, type) \ | |||
| int PEM_write_##name(FILE *fp, const type *x); | |||
| # define DECLARE_PEM_write_cb_fp(name, type) \ | |||
| int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ | |||
| unsigned char *kstr, int klen, pem_password_cb *cb, void *u); | |||
| # endif | |||
| # define DECLARE_PEM_read_bio(name, type) \ | |||
| type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u); | |||
| # define DECLARE_PEM_write_bio(name, type) \ | |||
| int PEM_write_bio_##name(BIO *bp, type *x); | |||
| # define DECLARE_PEM_write_bio_const(name, type) \ | |||
| int PEM_write_bio_##name(BIO *bp, const type *x); | |||
| # define DECLARE_PEM_write_cb_bio(name, type) \ | |||
| int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ | |||
| unsigned char *kstr, int klen, pem_password_cb *cb, void *u); | |||
| # define DECLARE_PEM_write(name, type) \ | |||
| DECLARE_PEM_write_bio(name, type) \ | |||
| DECLARE_PEM_write_fp(name, type) | |||
| # define DECLARE_PEM_write_const(name, type) \ | |||
| DECLARE_PEM_write_bio_const(name, type) \ | |||
| DECLARE_PEM_write_fp_const(name, type) | |||
| # define DECLARE_PEM_write_cb(name, type) \ | |||
| DECLARE_PEM_write_cb_bio(name, type) \ | |||
| DECLARE_PEM_write_cb_fp(name, type) | |||
| # define DECLARE_PEM_read(name, type) \ | |||
| DECLARE_PEM_read_bio(name, type) \ | |||
| DECLARE_PEM_read_fp(name, type) | |||
| # define DECLARE_PEM_rw(name, type) \ | |||
| DECLARE_PEM_read(name, type) \ | |||
| DECLARE_PEM_write(name, type) | |||
| # define DECLARE_PEM_rw_const(name, type) \ | |||
| DECLARE_PEM_read(name, type) \ | |||
| DECLARE_PEM_write_const(name, type) | |||
| # define DECLARE_PEM_rw_cb(name, type) \ | |||
| DECLARE_PEM_read(name, type) \ | |||
| DECLARE_PEM_write_cb(name, type) | |||
| typedef int pem_password_cb (char *buf, int size, int rwflag, void *userdata); | |||
| int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher); | |||
| int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len, | |||
| pem_password_cb *callback, void *u); | |||
| int PEM_read_bio(BIO *bp, char **name, char **header, | |||
| unsigned char **data, long *len); | |||
| # define PEM_FLAG_SECURE 0x1 | |||
| # define PEM_FLAG_EAY_COMPATIBLE 0x2 | |||
| # define PEM_FLAG_ONLY_B64 0x4 | |||
| int PEM_read_bio_ex(BIO *bp, char **name, char **header, | |||
| unsigned char **data, long *len, unsigned int flags); | |||
| int PEM_bytes_read_bio_secmem(unsigned char **pdata, long *plen, char **pnm, | |||
| const char *name, BIO *bp, pem_password_cb *cb, | |||
| void *u); | |||
| int PEM_write_bio(BIO *bp, const char *name, const char *hdr, | |||
| const unsigned char *data, long len); | |||
| int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, | |||
| const char *name, BIO *bp, pem_password_cb *cb, | |||
| void *u); | |||
| void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x, | |||
| pem_password_cb *cb, void *u); | |||
| int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp, void *x, | |||
| const EVP_CIPHER *enc, unsigned char *kstr, int klen, | |||
| pem_password_cb *cb, void *u); | |||
| STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, | |||
| pem_password_cb *cb, void *u); | |||
| int PEM_X509_INFO_write_bio(BIO *bp, X509_INFO *xi, EVP_CIPHER *enc, | |||
| unsigned char *kstr, int klen, | |||
| pem_password_cb *cd, void *u); | |||
| #ifndef OPENSSL_NO_STDIO | |||
| int PEM_read(FILE *fp, char **name, char **header, | |||
| unsigned char **data, long *len); | |||
| int PEM_write(FILE *fp, const char *name, const char *hdr, | |||
| const unsigned char *data, long len); | |||
| void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x, | |||
| pem_password_cb *cb, void *u); | |||
| int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp, | |||
| void *x, const EVP_CIPHER *enc, unsigned char *kstr, | |||
| int klen, pem_password_cb *callback, void *u); | |||
| STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk, | |||
| pem_password_cb *cb, void *u); | |||
| #endif | |||
| int PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type); | |||
| int PEM_SignUpdate(EVP_MD_CTX *ctx, unsigned char *d, unsigned int cnt); | |||
| int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, | |||
| unsigned int *siglen, EVP_PKEY *pkey); | |||
| /* The default pem_password_cb that's used internally */ | |||
| int PEM_def_callback(char *buf, int num, int rwflag, void *userdata); | |||
| void PEM_proc_type(char *buf, int type); | |||
| void PEM_dek_info(char *buf, const char *type, int len, char *str); | |||
| # include <openssl/symhacks.h> | |||
| DECLARE_PEM_rw(X509, X509) | |||
| DECLARE_PEM_rw(X509_AUX, X509) | |||
| DECLARE_PEM_rw(X509_REQ, X509_REQ) | |||
| DECLARE_PEM_write(X509_REQ_NEW, X509_REQ) | |||
| DECLARE_PEM_rw(X509_CRL, X509_CRL) | |||
| DECLARE_PEM_rw(PKCS7, PKCS7) | |||
| DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE) | |||
| DECLARE_PEM_rw(PKCS8, X509_SIG) | |||
| DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO) | |||
| # ifndef OPENSSL_NO_RSA | |||
| DECLARE_PEM_rw_cb(RSAPrivateKey, RSA) | |||
| DECLARE_PEM_rw_const(RSAPublicKey, RSA) | |||
| DECLARE_PEM_rw(RSA_PUBKEY, RSA) | |||
| # endif | |||
| # ifndef OPENSSL_NO_DSA | |||
| DECLARE_PEM_rw_cb(DSAPrivateKey, DSA) | |||
| DECLARE_PEM_rw(DSA_PUBKEY, DSA) | |||
| DECLARE_PEM_rw_const(DSAparams, DSA) | |||
| # endif | |||
| # ifndef OPENSSL_NO_EC | |||
| DECLARE_PEM_rw_const(ECPKParameters, EC_GROUP) | |||
| DECLARE_PEM_rw_cb(ECPrivateKey, EC_KEY) | |||
| DECLARE_PEM_rw(EC_PUBKEY, EC_KEY) | |||
| # endif | |||
| # ifndef OPENSSL_NO_DH | |||
| DECLARE_PEM_rw_const(DHparams, DH) | |||
| DECLARE_PEM_write_const(DHxparams, DH) | |||
| # endif | |||
| DECLARE_PEM_rw_cb(PrivateKey, EVP_PKEY) | |||
| DECLARE_PEM_rw(PUBKEY, EVP_PKEY) | |||
| int PEM_write_bio_PrivateKey_traditional(BIO *bp, EVP_PKEY *x, | |||
| const EVP_CIPHER *enc, | |||
| unsigned char *kstr, int klen, | |||
| pem_password_cb *cb, void *u); | |||
| int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid, | |||
| char *kstr, int klen, | |||
| pem_password_cb *cb, void *u); | |||
| int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *, | |||
| char *, int, pem_password_cb *, void *); | |||
| int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc, | |||
| char *kstr, int klen, | |||
| pem_password_cb *cb, void *u); | |||
| int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid, | |||
| char *kstr, int klen, | |||
| pem_password_cb *cb, void *u); | |||
| EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, | |||
| void *u); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, | |||
| char *kstr, int klen, | |||
| pem_password_cb *cb, void *u); | |||
| int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid, | |||
| char *kstr, int klen, | |||
| pem_password_cb *cb, void *u); | |||
| int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid, | |||
| char *kstr, int klen, | |||
| pem_password_cb *cb, void *u); | |||
| EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, | |||
| void *u); | |||
| int PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, | |||
| char *kstr, int klen, pem_password_cb *cd, | |||
| void *u); | |||
| # endif | |||
| EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x); | |||
| int PEM_write_bio_Parameters(BIO *bp, EVP_PKEY *x); | |||
| # ifndef OPENSSL_NO_DSA | |||
| EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length); | |||
| EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length); | |||
| EVP_PKEY *b2i_PrivateKey_bio(BIO *in); | |||
| EVP_PKEY *b2i_PublicKey_bio(BIO *in); | |||
| int i2b_PrivateKey_bio(BIO *out, EVP_PKEY *pk); | |||
| int i2b_PublicKey_bio(BIO *out, EVP_PKEY *pk); | |||
| # ifndef OPENSSL_NO_RC4 | |||
| EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u); | |||
| int i2b_PVK_bio(BIO *out, EVP_PKEY *pk, int enclevel, | |||
| pem_password_cb *cb, void *u); | |||
| # endif | |||
| # endif | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,13 +0,0 @@ | |||
| /* | |||
| * Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_PEM2_H | |||
| # define HEADER_PEM2_H | |||
| # include <openssl/pemerr.h> | |||
| #endif | |||
| @ -1,103 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_PEMERR_H | |||
| # define HEADER_PEMERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_PEM_strings(void); | |||
| /* | |||
| * PEM function codes. | |||
| */ | |||
| # define PEM_F_B2I_DSS 127 | |||
| # define PEM_F_B2I_PVK_BIO 128 | |||
| # define PEM_F_B2I_RSA 129 | |||
| # define PEM_F_CHECK_BITLEN_DSA 130 | |||
| # define PEM_F_CHECK_BITLEN_RSA 131 | |||
| # define PEM_F_D2I_PKCS8PRIVATEKEY_BIO 120 | |||
| # define PEM_F_D2I_PKCS8PRIVATEKEY_FP 121 | |||
| # define PEM_F_DO_B2I 132 | |||
| # define PEM_F_DO_B2I_BIO 133 | |||
| # define PEM_F_DO_BLOB_HEADER 134 | |||
| # define PEM_F_DO_I2B 146 | |||
| # define PEM_F_DO_PK8PKEY 126 | |||
| # define PEM_F_DO_PK8PKEY_FP 125 | |||
| # define PEM_F_DO_PVK_BODY 135 | |||
| # define PEM_F_DO_PVK_HEADER 136 | |||
| # define PEM_F_GET_HEADER_AND_DATA 143 | |||
| # define PEM_F_GET_NAME 144 | |||
| # define PEM_F_I2B_PVK 137 | |||
| # define PEM_F_I2B_PVK_BIO 138 | |||
| # define PEM_F_LOAD_IV 101 | |||
| # define PEM_F_PEM_ASN1_READ 102 | |||
| # define PEM_F_PEM_ASN1_READ_BIO 103 | |||
| # define PEM_F_PEM_ASN1_WRITE 104 | |||
| # define PEM_F_PEM_ASN1_WRITE_BIO 105 | |||
| # define PEM_F_PEM_DEF_CALLBACK 100 | |||
| # define PEM_F_PEM_DO_HEADER 106 | |||
| # define PEM_F_PEM_GET_EVP_CIPHER_INFO 107 | |||
| # define PEM_F_PEM_READ 108 | |||
| # define PEM_F_PEM_READ_BIO 109 | |||
| # define PEM_F_PEM_READ_BIO_DHPARAMS 141 | |||
| # define PEM_F_PEM_READ_BIO_EX 145 | |||
| # define PEM_F_PEM_READ_BIO_PARAMETERS 140 | |||
| # define PEM_F_PEM_READ_BIO_PRIVATEKEY 123 | |||
| # define PEM_F_PEM_READ_DHPARAMS 142 | |||
| # define PEM_F_PEM_READ_PRIVATEKEY 124 | |||
| # define PEM_F_PEM_SIGNFINAL 112 | |||
| # define PEM_F_PEM_WRITE 113 | |||
| # define PEM_F_PEM_WRITE_BIO 114 | |||
| # define PEM_F_PEM_WRITE_PRIVATEKEY 139 | |||
| # define PEM_F_PEM_X509_INFO_READ 115 | |||
| # define PEM_F_PEM_X509_INFO_READ_BIO 116 | |||
| # define PEM_F_PEM_X509_INFO_WRITE_BIO 117 | |||
| /* | |||
| * PEM reason codes. | |||
| */ | |||
| # define PEM_R_BAD_BASE64_DECODE 100 | |||
| # define PEM_R_BAD_DECRYPT 101 | |||
| # define PEM_R_BAD_END_LINE 102 | |||
| # define PEM_R_BAD_IV_CHARS 103 | |||
| # define PEM_R_BAD_MAGIC_NUMBER 116 | |||
| # define PEM_R_BAD_PASSWORD_READ 104 | |||
| # define PEM_R_BAD_VERSION_NUMBER 117 | |||
| # define PEM_R_BIO_WRITE_FAILURE 118 | |||
| # define PEM_R_CIPHER_IS_NULL 127 | |||
| # define PEM_R_ERROR_CONVERTING_PRIVATE_KEY 115 | |||
| # define PEM_R_EXPECTING_PRIVATE_KEY_BLOB 119 | |||
| # define PEM_R_EXPECTING_PUBLIC_KEY_BLOB 120 | |||
| # define PEM_R_HEADER_TOO_LONG 128 | |||
| # define PEM_R_INCONSISTENT_HEADER 121 | |||
| # define PEM_R_KEYBLOB_HEADER_PARSE_ERROR 122 | |||
| # define PEM_R_KEYBLOB_TOO_SHORT 123 | |||
| # define PEM_R_MISSING_DEK_IV 129 | |||
| # define PEM_R_NOT_DEK_INFO 105 | |||
| # define PEM_R_NOT_ENCRYPTED 106 | |||
| # define PEM_R_NOT_PROC_TYPE 107 | |||
| # define PEM_R_NO_START_LINE 108 | |||
| # define PEM_R_PROBLEMS_GETTING_PASSWORD 109 | |||
| # define PEM_R_PVK_DATA_TOO_SHORT 124 | |||
| # define PEM_R_PVK_TOO_SHORT 125 | |||
| # define PEM_R_READ_KEY 111 | |||
| # define PEM_R_SHORT_HEADER 112 | |||
| # define PEM_R_UNEXPECTED_DEK_IV 130 | |||
| # define PEM_R_UNSUPPORTED_CIPHER 113 | |||
| # define PEM_R_UNSUPPORTED_ENCRYPTION 114 | |||
| # define PEM_R_UNSUPPORTED_KEY_COMPONENTS 126 | |||
| #endif | |||
| @ -1,223 +0,0 @@ | |||
| /* | |||
| * Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_PKCS12_H | |||
| # define HEADER_PKCS12_H | |||
| # include <openssl/bio.h> | |||
| # include <openssl/x509.h> | |||
| # include <openssl/pkcs12err.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # define PKCS12_KEY_ID 1 | |||
| # define PKCS12_IV_ID 2 | |||
| # define PKCS12_MAC_ID 3 | |||
| /* Default iteration count */ | |||
| # ifndef PKCS12_DEFAULT_ITER | |||
| # define PKCS12_DEFAULT_ITER PKCS5_DEFAULT_ITER | |||
| # endif | |||
| # define PKCS12_MAC_KEY_LENGTH 20 | |||
| # define PKCS12_SALT_LEN 8 | |||
| /* It's not clear if these are actually needed... */ | |||
| # define PKCS12_key_gen PKCS12_key_gen_utf8 | |||
| # define PKCS12_add_friendlyname PKCS12_add_friendlyname_utf8 | |||
| /* MS key usage constants */ | |||
| # define KEY_EX 0x10 | |||
| # define KEY_SIG 0x80 | |||
| typedef struct PKCS12_MAC_DATA_st PKCS12_MAC_DATA; | |||
| typedef struct PKCS12_st PKCS12; | |||
| typedef struct PKCS12_SAFEBAG_st PKCS12_SAFEBAG; | |||
| DEFINE_STACK_OF(PKCS12_SAFEBAG) | |||
| typedef struct pkcs12_bag_st PKCS12_BAGS; | |||
| # define PKCS12_ERROR 0 | |||
| # define PKCS12_OK 1 | |||
| /* Compatibility macros */ | |||
| #if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define M_PKCS12_bag_type PKCS12_bag_type | |||
| # define M_PKCS12_cert_bag_type PKCS12_cert_bag_type | |||
| # define M_PKCS12_crl_bag_type PKCS12_cert_bag_type | |||
| # define PKCS12_certbag2x509 PKCS12_SAFEBAG_get1_cert | |||
| # define PKCS12_certbag2scrl PKCS12_SAFEBAG_get1_crl | |||
| # define PKCS12_bag_type PKCS12_SAFEBAG_get_nid | |||
| # define PKCS12_cert_bag_type PKCS12_SAFEBAG_get_bag_nid | |||
| # define PKCS12_x5092certbag PKCS12_SAFEBAG_create_cert | |||
| # define PKCS12_x509crl2certbag PKCS12_SAFEBAG_create_crl | |||
| # define PKCS12_MAKE_KEYBAG PKCS12_SAFEBAG_create0_p8inf | |||
| # define PKCS12_MAKE_SHKEYBAG PKCS12_SAFEBAG_create_pkcs8_encrypt | |||
| #endif | |||
| DEPRECATEDIN_1_1_0(ASN1_TYPE *PKCS12_get_attr(const PKCS12_SAFEBAG *bag, int attr_nid)) | |||
| ASN1_TYPE *PKCS8_get_attr(PKCS8_PRIV_KEY_INFO *p8, int attr_nid); | |||
| int PKCS12_mac_present(const PKCS12 *p12); | |||
| void PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac, | |||
| const X509_ALGOR **pmacalg, | |||
| const ASN1_OCTET_STRING **psalt, | |||
| const ASN1_INTEGER **piter, | |||
| const PKCS12 *p12); | |||
| const ASN1_TYPE *PKCS12_SAFEBAG_get0_attr(const PKCS12_SAFEBAG *bag, | |||
| int attr_nid); | |||
| const ASN1_OBJECT *PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG *bag); | |||
| int PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG *bag); | |||
| int PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag); | |||
| X509 *PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag); | |||
| X509_CRL *PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag); | |||
| const STACK_OF(PKCS12_SAFEBAG) * | |||
| PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag); | |||
| const PKCS8_PRIV_KEY_INFO *PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag); | |||
| const X509_SIG *PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag); | |||
| PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_cert(X509 *x509); | |||
| PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_crl(X509_CRL *crl); | |||
| PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_p8inf(PKCS8_PRIV_KEY_INFO *p8); | |||
| PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_pkcs8(X509_SIG *p8); | |||
| PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid, | |||
| const char *pass, | |||
| int passlen, | |||
| unsigned char *salt, | |||
| int saltlen, int iter, | |||
| PKCS8_PRIV_KEY_INFO *p8inf); | |||
| PKCS12_SAFEBAG *PKCS12_item_pack_safebag(void *obj, const ASN1_ITEM *it, | |||
| int nid1, int nid2); | |||
| PKCS8_PRIV_KEY_INFO *PKCS8_decrypt(const X509_SIG *p8, const char *pass, | |||
| int passlen); | |||
| PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey(const PKCS12_SAFEBAG *bag, | |||
| const char *pass, int passlen); | |||
| X509_SIG *PKCS8_encrypt(int pbe_nid, const EVP_CIPHER *cipher, | |||
| const char *pass, int passlen, unsigned char *salt, | |||
| int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8); | |||
| X509_SIG *PKCS8_set0_pbe(const char *pass, int passlen, | |||
| PKCS8_PRIV_KEY_INFO *p8inf, X509_ALGOR *pbe); | |||
| PKCS7 *PKCS12_pack_p7data(STACK_OF(PKCS12_SAFEBAG) *sk); | |||
| STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7data(PKCS7 *p7); | |||
| PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, const char *pass, int passlen, | |||
| unsigned char *salt, int saltlen, int iter, | |||
| STACK_OF(PKCS12_SAFEBAG) *bags); | |||
| STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass, | |||
| int passlen); | |||
| int PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes); | |||
| STACK_OF(PKCS7) *PKCS12_unpack_authsafes(const PKCS12 *p12); | |||
| int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name, | |||
| int namelen); | |||
| int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name, | |||
| int namelen); | |||
| int PKCS12_add_friendlyname_utf8(PKCS12_SAFEBAG *bag, const char *name, | |||
| int namelen); | |||
| int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name, | |||
| int namelen); | |||
| int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag, | |||
| const unsigned char *name, int namelen); | |||
| int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage); | |||
| ASN1_TYPE *PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs, | |||
| int attr_nid); | |||
| char *PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag); | |||
| const STACK_OF(X509_ATTRIBUTE) * | |||
| PKCS12_SAFEBAG_get0_attrs(const PKCS12_SAFEBAG *bag); | |||
| unsigned char *PKCS12_pbe_crypt(const X509_ALGOR *algor, | |||
| const char *pass, int passlen, | |||
| const unsigned char *in, int inlen, | |||
| unsigned char **data, int *datalen, | |||
| int en_de); | |||
| void *PKCS12_item_decrypt_d2i(const X509_ALGOR *algor, const ASN1_ITEM *it, | |||
| const char *pass, int passlen, | |||
| const ASN1_OCTET_STRING *oct, int zbuf); | |||
| ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor, | |||
| const ASN1_ITEM *it, | |||
| const char *pass, int passlen, | |||
| void *obj, int zbuf); | |||
| PKCS12 *PKCS12_init(int mode); | |||
| int PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt, | |||
| int saltlen, int id, int iter, int n, | |||
| unsigned char *out, const EVP_MD *md_type); | |||
| int PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt, | |||
| int saltlen, int id, int iter, int n, | |||
| unsigned char *out, const EVP_MD *md_type); | |||
| int PKCS12_key_gen_utf8(const char *pass, int passlen, unsigned char *salt, | |||
| int saltlen, int id, int iter, int n, | |||
| unsigned char *out, const EVP_MD *md_type); | |||
| int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, | |||
| ASN1_TYPE *param, const EVP_CIPHER *cipher, | |||
| const EVP_MD *md_type, int en_de); | |||
| int PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen, | |||
| unsigned char *mac, unsigned int *maclen); | |||
| int PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen); | |||
| int PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen, | |||
| unsigned char *salt, int saltlen, int iter, | |||
| const EVP_MD *md_type); | |||
| int PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt, | |||
| int saltlen, const EVP_MD *md_type); | |||
| unsigned char *OPENSSL_asc2uni(const char *asc, int asclen, | |||
| unsigned char **uni, int *unilen); | |||
| char *OPENSSL_uni2asc(const unsigned char *uni, int unilen); | |||
| unsigned char *OPENSSL_utf82uni(const char *asc, int asclen, | |||
| unsigned char **uni, int *unilen); | |||
| char *OPENSSL_uni2utf8(const unsigned char *uni, int unilen); | |||
| DECLARE_ASN1_FUNCTIONS(PKCS12) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS12_MAC_DATA) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS12_SAFEBAG) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS12_BAGS) | |||
| DECLARE_ASN1_ITEM(PKCS12_SAFEBAGS) | |||
| DECLARE_ASN1_ITEM(PKCS12_AUTHSAFES) | |||
| void PKCS12_PBE_add(void); | |||
| int PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, X509 **cert, | |||
| STACK_OF(X509) **ca); | |||
| PKCS12 *PKCS12_create(const char *pass, const char *name, EVP_PKEY *pkey, | |||
| X509 *cert, STACK_OF(X509) *ca, int nid_key, int nid_cert, | |||
| int iter, int mac_iter, int keytype); | |||
| PKCS12_SAFEBAG *PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert); | |||
| PKCS12_SAFEBAG *PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags, | |||
| EVP_PKEY *key, int key_usage, int iter, | |||
| int key_nid, const char *pass); | |||
| int PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags, | |||
| int safe_nid, int iter, const char *pass); | |||
| PKCS12 *PKCS12_add_safes(STACK_OF(PKCS7) *safes, int p7_nid); | |||
| int i2d_PKCS12_bio(BIO *bp, PKCS12 *p12); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int i2d_PKCS12_fp(FILE *fp, PKCS12 *p12); | |||
| # endif | |||
| PKCS12 *d2i_PKCS12_bio(BIO *bp, PKCS12 **p12); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12); | |||
| # endif | |||
| int PKCS12_newpass(PKCS12 *p12, const char *oldpass, const char *newpass); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,81 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_PKCS12ERR_H | |||
| # define HEADER_PKCS12ERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_PKCS12_strings(void); | |||
| /* | |||
| * PKCS12 function codes. | |||
| */ | |||
| # define PKCS12_F_OPENSSL_ASC2UNI 121 | |||
| # define PKCS12_F_OPENSSL_UNI2ASC 124 | |||
| # define PKCS12_F_OPENSSL_UNI2UTF8 127 | |||
| # define PKCS12_F_OPENSSL_UTF82UNI 129 | |||
| # define PKCS12_F_PKCS12_CREATE 105 | |||
| # define PKCS12_F_PKCS12_GEN_MAC 107 | |||
| # define PKCS12_F_PKCS12_INIT 109 | |||
| # define PKCS12_F_PKCS12_ITEM_DECRYPT_D2I 106 | |||
| # define PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT 108 | |||
| # define PKCS12_F_PKCS12_ITEM_PACK_SAFEBAG 117 | |||
| # define PKCS12_F_PKCS12_KEY_GEN_ASC 110 | |||
| # define PKCS12_F_PKCS12_KEY_GEN_UNI 111 | |||
| # define PKCS12_F_PKCS12_KEY_GEN_UTF8 116 | |||
| # define PKCS12_F_PKCS12_NEWPASS 128 | |||
| # define PKCS12_F_PKCS12_PACK_P7DATA 114 | |||
| # define PKCS12_F_PKCS12_PACK_P7ENCDATA 115 | |||
| # define PKCS12_F_PKCS12_PARSE 118 | |||
| # define PKCS12_F_PKCS12_PBE_CRYPT 119 | |||
| # define PKCS12_F_PKCS12_PBE_KEYIVGEN 120 | |||
| # define PKCS12_F_PKCS12_SAFEBAG_CREATE0_P8INF 112 | |||
| # define PKCS12_F_PKCS12_SAFEBAG_CREATE0_PKCS8 113 | |||
| # define PKCS12_F_PKCS12_SAFEBAG_CREATE_PKCS8_ENCRYPT 133 | |||
| # define PKCS12_F_PKCS12_SETUP_MAC 122 | |||
| # define PKCS12_F_PKCS12_SET_MAC 123 | |||
| # define PKCS12_F_PKCS12_UNPACK_AUTHSAFES 130 | |||
| # define PKCS12_F_PKCS12_UNPACK_P7DATA 131 | |||
| # define PKCS12_F_PKCS12_VERIFY_MAC 126 | |||
| # define PKCS12_F_PKCS8_ENCRYPT 125 | |||
| # define PKCS12_F_PKCS8_SET0_PBE 132 | |||
| /* | |||
| * PKCS12 reason codes. | |||
| */ | |||
| # define PKCS12_R_CANT_PACK_STRUCTURE 100 | |||
| # define PKCS12_R_CONTENT_TYPE_NOT_DATA 121 | |||
| # define PKCS12_R_DECODE_ERROR 101 | |||
| # define PKCS12_R_ENCODE_ERROR 102 | |||
| # define PKCS12_R_ENCRYPT_ERROR 103 | |||
| # define PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE 120 | |||
| # define PKCS12_R_INVALID_NULL_ARGUMENT 104 | |||
| # define PKCS12_R_INVALID_NULL_PKCS12_POINTER 105 | |||
| # define PKCS12_R_IV_GEN_ERROR 106 | |||
| # define PKCS12_R_KEY_GEN_ERROR 107 | |||
| # define PKCS12_R_MAC_ABSENT 108 | |||
| # define PKCS12_R_MAC_GENERATION_ERROR 109 | |||
| # define PKCS12_R_MAC_SETUP_ERROR 110 | |||
| # define PKCS12_R_MAC_STRING_SET_ERROR 111 | |||
| # define PKCS12_R_MAC_VERIFY_FAILURE 113 | |||
| # define PKCS12_R_PARSE_ERROR 114 | |||
| # define PKCS12_R_PKCS12_ALGOR_CIPHERINIT_ERROR 115 | |||
| # define PKCS12_R_PKCS12_CIPHERFINAL_ERROR 116 | |||
| # define PKCS12_R_PKCS12_PBE_CRYPT_ERROR 117 | |||
| # define PKCS12_R_UNKNOWN_DIGEST_ALGORITHM 118 | |||
| # define PKCS12_R_UNSUPPORTED_PKCS12_MODE 119 | |||
| #endif | |||
| @ -1,319 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_PKCS7_H | |||
| # define HEADER_PKCS7_H | |||
| # include <openssl/asn1.h> | |||
| # include <openssl/bio.h> | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/symhacks.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/pkcs7err.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /*- | |||
| Encryption_ID DES-CBC | |||
| Digest_ID MD5 | |||
| Digest_Encryption_ID rsaEncryption | |||
| Key_Encryption_ID rsaEncryption | |||
| */ | |||
| typedef struct pkcs7_issuer_and_serial_st { | |||
| X509_NAME *issuer; | |||
| ASN1_INTEGER *serial; | |||
| } PKCS7_ISSUER_AND_SERIAL; | |||
| typedef struct pkcs7_signer_info_st { | |||
| ASN1_INTEGER *version; /* version 1 */ | |||
| PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; | |||
| X509_ALGOR *digest_alg; | |||
| STACK_OF(X509_ATTRIBUTE) *auth_attr; /* [ 0 ] */ | |||
| X509_ALGOR *digest_enc_alg; | |||
| ASN1_OCTET_STRING *enc_digest; | |||
| STACK_OF(X509_ATTRIBUTE) *unauth_attr; /* [ 1 ] */ | |||
| /* The private key to sign with */ | |||
| EVP_PKEY *pkey; | |||
| } PKCS7_SIGNER_INFO; | |||
| DEFINE_STACK_OF(PKCS7_SIGNER_INFO) | |||
| typedef struct pkcs7_recip_info_st { | |||
| ASN1_INTEGER *version; /* version 0 */ | |||
| PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; | |||
| X509_ALGOR *key_enc_algor; | |||
| ASN1_OCTET_STRING *enc_key; | |||
| X509 *cert; /* get the pub-key from this */ | |||
| } PKCS7_RECIP_INFO; | |||
| DEFINE_STACK_OF(PKCS7_RECIP_INFO) | |||
| typedef struct pkcs7_signed_st { | |||
| ASN1_INTEGER *version; /* version 1 */ | |||
| STACK_OF(X509_ALGOR) *md_algs; /* md used */ | |||
| STACK_OF(X509) *cert; /* [ 0 ] */ | |||
| STACK_OF(X509_CRL) *crl; /* [ 1 ] */ | |||
| STACK_OF(PKCS7_SIGNER_INFO) *signer_info; | |||
| struct pkcs7_st *contents; | |||
| } PKCS7_SIGNED; | |||
| /* | |||
| * The above structure is very very similar to PKCS7_SIGN_ENVELOPE. How about | |||
| * merging the two | |||
| */ | |||
| typedef struct pkcs7_enc_content_st { | |||
| ASN1_OBJECT *content_type; | |||
| X509_ALGOR *algorithm; | |||
| ASN1_OCTET_STRING *enc_data; /* [ 0 ] */ | |||
| const EVP_CIPHER *cipher; | |||
| } PKCS7_ENC_CONTENT; | |||
| typedef struct pkcs7_enveloped_st { | |||
| ASN1_INTEGER *version; /* version 0 */ | |||
| STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; | |||
| PKCS7_ENC_CONTENT *enc_data; | |||
| } PKCS7_ENVELOPE; | |||
| typedef struct pkcs7_signedandenveloped_st { | |||
| ASN1_INTEGER *version; /* version 1 */ | |||
| STACK_OF(X509_ALGOR) *md_algs; /* md used */ | |||
| STACK_OF(X509) *cert; /* [ 0 ] */ | |||
| STACK_OF(X509_CRL) *crl; /* [ 1 ] */ | |||
| STACK_OF(PKCS7_SIGNER_INFO) *signer_info; | |||
| PKCS7_ENC_CONTENT *enc_data; | |||
| STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; | |||
| } PKCS7_SIGN_ENVELOPE; | |||
| typedef struct pkcs7_digest_st { | |||
| ASN1_INTEGER *version; /* version 0 */ | |||
| X509_ALGOR *md; /* md used */ | |||
| struct pkcs7_st *contents; | |||
| ASN1_OCTET_STRING *digest; | |||
| } PKCS7_DIGEST; | |||
| typedef struct pkcs7_encrypted_st { | |||
| ASN1_INTEGER *version; /* version 0 */ | |||
| PKCS7_ENC_CONTENT *enc_data; | |||
| } PKCS7_ENCRYPT; | |||
| typedef struct pkcs7_st { | |||
| /* | |||
| * The following is non NULL if it contains ASN1 encoding of this | |||
| * structure | |||
| */ | |||
| unsigned char *asn1; | |||
| long length; | |||
| # define PKCS7_S_HEADER 0 | |||
| # define PKCS7_S_BODY 1 | |||
| # define PKCS7_S_TAIL 2 | |||
| int state; /* used during processing */ | |||
| int detached; | |||
| ASN1_OBJECT *type; | |||
| /* content as defined by the type */ | |||
| /* | |||
| * all encryption/message digests are applied to the 'contents', leaving | |||
| * out the 'type' field. | |||
| */ | |||
| union { | |||
| char *ptr; | |||
| /* NID_pkcs7_data */ | |||
| ASN1_OCTET_STRING *data; | |||
| /* NID_pkcs7_signed */ | |||
| PKCS7_SIGNED *sign; | |||
| /* NID_pkcs7_enveloped */ | |||
| PKCS7_ENVELOPE *enveloped; | |||
| /* NID_pkcs7_signedAndEnveloped */ | |||
| PKCS7_SIGN_ENVELOPE *signed_and_enveloped; | |||
| /* NID_pkcs7_digest */ | |||
| PKCS7_DIGEST *digest; | |||
| /* NID_pkcs7_encrypted */ | |||
| PKCS7_ENCRYPT *encrypted; | |||
| /* Anything else */ | |||
| ASN1_TYPE *other; | |||
| } d; | |||
| } PKCS7; | |||
| DEFINE_STACK_OF(PKCS7) | |||
| # define PKCS7_OP_SET_DETACHED_SIGNATURE 1 | |||
| # define PKCS7_OP_GET_DETACHED_SIGNATURE 2 | |||
| # define PKCS7_get_signed_attributes(si) ((si)->auth_attr) | |||
| # define PKCS7_get_attributes(si) ((si)->unauth_attr) | |||
| # define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed) | |||
| # define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted) | |||
| # define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped) | |||
| # define PKCS7_type_is_signedAndEnveloped(a) \ | |||
| (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped) | |||
| # define PKCS7_type_is_data(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_data) | |||
| # define PKCS7_type_is_digest(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_digest) | |||
| # define PKCS7_set_detached(p,v) \ | |||
| PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL) | |||
| # define PKCS7_get_detached(p) \ | |||
| PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL) | |||
| # define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7)) | |||
| /* S/MIME related flags */ | |||
| # define PKCS7_TEXT 0x1 | |||
| # define PKCS7_NOCERTS 0x2 | |||
| # define PKCS7_NOSIGS 0x4 | |||
| # define PKCS7_NOCHAIN 0x8 | |||
| # define PKCS7_NOINTERN 0x10 | |||
| # define PKCS7_NOVERIFY 0x20 | |||
| # define PKCS7_DETACHED 0x40 | |||
| # define PKCS7_BINARY 0x80 | |||
| # define PKCS7_NOATTR 0x100 | |||
| # define PKCS7_NOSMIMECAP 0x200 | |||
| # define PKCS7_NOOLDMIMETYPE 0x400 | |||
| # define PKCS7_CRLFEOL 0x800 | |||
| # define PKCS7_STREAM 0x1000 | |||
| # define PKCS7_NOCRL 0x2000 | |||
| # define PKCS7_PARTIAL 0x4000 | |||
| # define PKCS7_REUSE_DIGEST 0x8000 | |||
| # define PKCS7_NO_DUAL_CONTENT 0x10000 | |||
| /* Flags: for compatibility with older code */ | |||
| # define SMIME_TEXT PKCS7_TEXT | |||
| # define SMIME_NOCERTS PKCS7_NOCERTS | |||
| # define SMIME_NOSIGS PKCS7_NOSIGS | |||
| # define SMIME_NOCHAIN PKCS7_NOCHAIN | |||
| # define SMIME_NOINTERN PKCS7_NOINTERN | |||
| # define SMIME_NOVERIFY PKCS7_NOVERIFY | |||
| # define SMIME_DETACHED PKCS7_DETACHED | |||
| # define SMIME_BINARY PKCS7_BINARY | |||
| # define SMIME_NOATTR PKCS7_NOATTR | |||
| /* CRLF ASCII canonicalisation */ | |||
| # define SMIME_ASCIICRLF 0x80000 | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL) | |||
| int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data, | |||
| const EVP_MD *type, unsigned char *md, | |||
| unsigned int *len); | |||
| # ifndef OPENSSL_NO_STDIO | |||
| PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7); | |||
| int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7); | |||
| # endif | |||
| PKCS7 *PKCS7_dup(PKCS7 *p7); | |||
| PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7); | |||
| int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7); | |||
| int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags); | |||
| int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags); | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT) | |||
| DECLARE_ASN1_FUNCTIONS(PKCS7) | |||
| DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN) | |||
| DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY) | |||
| DECLARE_ASN1_NDEF_FUNCTION(PKCS7) | |||
| DECLARE_ASN1_PRINT_FUNCTION(PKCS7) | |||
| long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg); | |||
| int PKCS7_set_type(PKCS7 *p7, int type); | |||
| int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other); | |||
| int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data); | |||
| int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey, | |||
| const EVP_MD *dgst); | |||
| int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si); | |||
| int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i); | |||
| int PKCS7_add_certificate(PKCS7 *p7, X509 *x509); | |||
| int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509); | |||
| int PKCS7_content_new(PKCS7 *p7, int nid); | |||
| int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, | |||
| BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si); | |||
| int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si, | |||
| X509 *x509); | |||
| BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio); | |||
| int PKCS7_dataFinal(PKCS7 *p7, BIO *bio); | |||
| BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert); | |||
| PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509, | |||
| EVP_PKEY *pkey, const EVP_MD *dgst); | |||
| X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si); | |||
| int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md); | |||
| STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7); | |||
| PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509); | |||
| void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk, | |||
| X509_ALGOR **pdig, X509_ALGOR **psig); | |||
| void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc); | |||
| int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri); | |||
| int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509); | |||
| int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher); | |||
| int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7); | |||
| PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx); | |||
| ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk); | |||
| int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int type, | |||
| void *data); | |||
| int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, | |||
| void *value); | |||
| ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid); | |||
| ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid); | |||
| int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si, | |||
| STACK_OF(X509_ATTRIBUTE) *sk); | |||
| int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, | |||
| STACK_OF(X509_ATTRIBUTE) *sk); | |||
| PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs, | |||
| BIO *data, int flags); | |||
| PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7, | |||
| X509 *signcert, EVP_PKEY *pkey, | |||
| const EVP_MD *md, int flags); | |||
| int PKCS7_final(PKCS7 *p7, BIO *data, int flags); | |||
| int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store, | |||
| BIO *indata, BIO *out, int flags); | |||
| STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, | |||
| int flags); | |||
| PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher, | |||
| int flags); | |||
| int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, | |||
| int flags); | |||
| int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, | |||
| STACK_OF(X509_ALGOR) *cap); | |||
| STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si); | |||
| int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg); | |||
| int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid); | |||
| int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t); | |||
| int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si, | |||
| const unsigned char *md, int mdlen); | |||
| int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags); | |||
| PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont); | |||
| BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,103 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_PKCS7ERR_H | |||
| # define HEADER_PKCS7ERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_PKCS7_strings(void); | |||
| /* | |||
| * PKCS7 function codes. | |||
| */ | |||
| # define PKCS7_F_DO_PKCS7_SIGNED_ATTRIB 136 | |||
| # define PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME 135 | |||
| # define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP 118 | |||
| # define PKCS7_F_PKCS7_ADD_CERTIFICATE 100 | |||
| # define PKCS7_F_PKCS7_ADD_CRL 101 | |||
| # define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO 102 | |||
| # define PKCS7_F_PKCS7_ADD_SIGNATURE 131 | |||
| # define PKCS7_F_PKCS7_ADD_SIGNER 103 | |||
| # define PKCS7_F_PKCS7_BIO_ADD_DIGEST 125 | |||
| # define PKCS7_F_PKCS7_COPY_EXISTING_DIGEST 138 | |||
| # define PKCS7_F_PKCS7_CTRL 104 | |||
| # define PKCS7_F_PKCS7_DATADECODE 112 | |||
| # define PKCS7_F_PKCS7_DATAFINAL 128 | |||
| # define PKCS7_F_PKCS7_DATAINIT 105 | |||
| # define PKCS7_F_PKCS7_DATAVERIFY 107 | |||
| # define PKCS7_F_PKCS7_DECRYPT 114 | |||
| # define PKCS7_F_PKCS7_DECRYPT_RINFO 133 | |||
| # define PKCS7_F_PKCS7_ENCODE_RINFO 132 | |||
| # define PKCS7_F_PKCS7_ENCRYPT 115 | |||
| # define PKCS7_F_PKCS7_FINAL 134 | |||
| # define PKCS7_F_PKCS7_FIND_DIGEST 127 | |||
| # define PKCS7_F_PKCS7_GET0_SIGNERS 124 | |||
| # define PKCS7_F_PKCS7_RECIP_INFO_SET 130 | |||
| # define PKCS7_F_PKCS7_SET_CIPHER 108 | |||
| # define PKCS7_F_PKCS7_SET_CONTENT 109 | |||
| # define PKCS7_F_PKCS7_SET_DIGEST 126 | |||
| # define PKCS7_F_PKCS7_SET_TYPE 110 | |||
| # define PKCS7_F_PKCS7_SIGN 116 | |||
| # define PKCS7_F_PKCS7_SIGNATUREVERIFY 113 | |||
| # define PKCS7_F_PKCS7_SIGNER_INFO_SET 129 | |||
| # define PKCS7_F_PKCS7_SIGNER_INFO_SIGN 139 | |||
| # define PKCS7_F_PKCS7_SIGN_ADD_SIGNER 137 | |||
| # define PKCS7_F_PKCS7_SIMPLE_SMIMECAP 119 | |||
| # define PKCS7_F_PKCS7_VERIFY 117 | |||
| /* | |||
| * PKCS7 reason codes. | |||
| */ | |||
| # define PKCS7_R_CERTIFICATE_VERIFY_ERROR 117 | |||
| # define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 144 | |||
| # define PKCS7_R_CIPHER_NOT_INITIALIZED 116 | |||
| # define PKCS7_R_CONTENT_AND_DATA_PRESENT 118 | |||
| # define PKCS7_R_CTRL_ERROR 152 | |||
| # define PKCS7_R_DECRYPT_ERROR 119 | |||
| # define PKCS7_R_DIGEST_FAILURE 101 | |||
| # define PKCS7_R_ENCRYPTION_CTRL_FAILURE 149 | |||
| # define PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 150 | |||
| # define PKCS7_R_ERROR_ADDING_RECIPIENT 120 | |||
| # define PKCS7_R_ERROR_SETTING_CIPHER 121 | |||
| # define PKCS7_R_INVALID_NULL_POINTER 143 | |||
| # define PKCS7_R_INVALID_SIGNED_DATA_TYPE 155 | |||
| # define PKCS7_R_NO_CONTENT 122 | |||
| # define PKCS7_R_NO_DEFAULT_DIGEST 151 | |||
| # define PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND 154 | |||
| # define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE 115 | |||
| # define PKCS7_R_NO_SIGNATURES_ON_DATA 123 | |||
| # define PKCS7_R_NO_SIGNERS 142 | |||
| # define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE 104 | |||
| # define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR 124 | |||
| # define PKCS7_R_PKCS7_ADD_SIGNER_ERROR 153 | |||
| # define PKCS7_R_PKCS7_DATASIGN 145 | |||
| # define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 127 | |||
| # define PKCS7_R_SIGNATURE_FAILURE 105 | |||
| # define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND 128 | |||
| # define PKCS7_R_SIGNING_CTRL_FAILURE 147 | |||
| # define PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 148 | |||
| # define PKCS7_R_SMIME_TEXT_ERROR 129 | |||
| # define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE 106 | |||
| # define PKCS7_R_UNABLE_TO_FIND_MEM_BIO 107 | |||
| # define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST 108 | |||
| # define PKCS7_R_UNKNOWN_DIGEST_TYPE 109 | |||
| # define PKCS7_R_UNKNOWN_OPERATION 110 | |||
| # define PKCS7_R_UNSUPPORTED_CIPHER_TYPE 111 | |||
| # define PKCS7_R_UNSUPPORTED_CONTENT_TYPE 112 | |||
| # define PKCS7_R_WRONG_CONTENT_TYPE 113 | |||
| # define PKCS7_R_WRONG_PKCS7_TYPE 114 | |||
| #endif | |||
| @ -1,77 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_RAND_H | |||
| # define HEADER_RAND_H | |||
| # include <stdlib.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/randerr.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| struct rand_meth_st { | |||
| int (*seed) (const void *buf, int num); | |||
| int (*bytes) (unsigned char *buf, int num); | |||
| void (*cleanup) (void); | |||
| int (*add) (const void *buf, int num, double randomness); | |||
| int (*pseudorand) (unsigned char *buf, int num); | |||
| int (*status) (void); | |||
| }; | |||
| int RAND_set_rand_method(const RAND_METHOD *meth); | |||
| const RAND_METHOD *RAND_get_rand_method(void); | |||
| # ifndef OPENSSL_NO_ENGINE | |||
| int RAND_set_rand_engine(ENGINE *engine); | |||
| # endif | |||
| RAND_METHOD *RAND_OpenSSL(void); | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define RAND_cleanup() while(0) continue | |||
| # endif | |||
| int RAND_bytes(unsigned char *buf, int num); | |||
| int RAND_priv_bytes(unsigned char *buf, int num); | |||
| DEPRECATEDIN_1_1_0(int RAND_pseudo_bytes(unsigned char *buf, int num)) | |||
| void RAND_seed(const void *buf, int num); | |||
| void RAND_keep_random_devices_open(int keep); | |||
| # if defined(__ANDROID__) && defined(__NDK_FPABI__) | |||
| __NDK_FPABI__ /* __attribute__((pcs("aapcs"))) on ARM */ | |||
| # endif | |||
| void RAND_add(const void *buf, int num, double randomness); | |||
| int RAND_load_file(const char *file, long max_bytes); | |||
| int RAND_write_file(const char *file); | |||
| const char *RAND_file_name(char *file, size_t num); | |||
| int RAND_status(void); | |||
| # ifndef OPENSSL_NO_EGD | |||
| int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes); | |||
| int RAND_egd(const char *path); | |||
| int RAND_egd_bytes(const char *path, int bytes); | |||
| # endif | |||
| int RAND_poll(void); | |||
| # if defined(_WIN32) && (defined(BASETYPES) || defined(_WINDEF_H)) | |||
| /* application has to include <windows.h> in order to use these */ | |||
| DEPRECATEDIN_1_1_0(void RAND_screen(void)) | |||
| DEPRECATEDIN_1_1_0(int RAND_event(UINT, WPARAM, LPARAM)) | |||
| # endif | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,130 +0,0 @@ | |||
| /* | |||
| * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_DRBG_RAND_H | |||
| # define HEADER_DRBG_RAND_H | |||
| # include <time.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/obj_mac.h> | |||
| /* | |||
| * RAND_DRBG flags | |||
| * | |||
| * Note: if new flags are added, the constant `rand_drbg_used_flags` | |||
| * in drbg_lib.c needs to be updated accordingly. | |||
| */ | |||
| /* In CTR mode, disable derivation function ctr_df */ | |||
| # define RAND_DRBG_FLAG_CTR_NO_DF 0x1 | |||
| # if OPENSSL_API_COMPAT < 0x10200000L | |||
| /* This #define was replaced by an internal constant and should not be used. */ | |||
| # define RAND_DRBG_USED_FLAGS (RAND_DRBG_FLAG_CTR_NO_DF) | |||
| # endif | |||
| /* | |||
| * Default security strength (in the sense of [NIST SP 800-90Ar1]) | |||
| * | |||
| * NIST SP 800-90Ar1 supports the strength of the DRBG being smaller than that | |||
| * of the cipher by collecting less entropy. The current DRBG implementation | |||
| * does not take RAND_DRBG_STRENGTH into account and sets the strength of the | |||
| * DRBG to that of the cipher. | |||
| * | |||
| * RAND_DRBG_STRENGTH is currently only used for the legacy RAND | |||
| * implementation. | |||
| * | |||
| * Currently supported ciphers are: NID_aes_128_ctr, NID_aes_192_ctr and | |||
| * NID_aes_256_ctr | |||
| */ | |||
| # define RAND_DRBG_STRENGTH 256 | |||
| /* Default drbg type */ | |||
| # define RAND_DRBG_TYPE NID_aes_256_ctr | |||
| /* Default drbg flags */ | |||
| # define RAND_DRBG_FLAGS 0 | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| /* | |||
| * Object lifetime functions. | |||
| */ | |||
| RAND_DRBG *RAND_DRBG_new(int type, unsigned int flags, RAND_DRBG *parent); | |||
| RAND_DRBG *RAND_DRBG_secure_new(int type, unsigned int flags, RAND_DRBG *parent); | |||
| int RAND_DRBG_set(RAND_DRBG *drbg, int type, unsigned int flags); | |||
| int RAND_DRBG_set_defaults(int type, unsigned int flags); | |||
| int RAND_DRBG_instantiate(RAND_DRBG *drbg, | |||
| const unsigned char *pers, size_t perslen); | |||
| int RAND_DRBG_uninstantiate(RAND_DRBG *drbg); | |||
| void RAND_DRBG_free(RAND_DRBG *drbg); | |||
| /* | |||
| * Object "use" functions. | |||
| */ | |||
| int RAND_DRBG_reseed(RAND_DRBG *drbg, | |||
| const unsigned char *adin, size_t adinlen, | |||
| int prediction_resistance); | |||
| int RAND_DRBG_generate(RAND_DRBG *drbg, unsigned char *out, size_t outlen, | |||
| int prediction_resistance, | |||
| const unsigned char *adin, size_t adinlen); | |||
| int RAND_DRBG_bytes(RAND_DRBG *drbg, unsigned char *out, size_t outlen); | |||
| int RAND_DRBG_set_reseed_interval(RAND_DRBG *drbg, unsigned int interval); | |||
| int RAND_DRBG_set_reseed_time_interval(RAND_DRBG *drbg, time_t interval); | |||
| int RAND_DRBG_set_reseed_defaults( | |||
| unsigned int master_reseed_interval, | |||
| unsigned int slave_reseed_interval, | |||
| time_t master_reseed_time_interval, | |||
| time_t slave_reseed_time_interval | |||
| ); | |||
| RAND_DRBG *RAND_DRBG_get0_master(void); | |||
| RAND_DRBG *RAND_DRBG_get0_public(void); | |||
| RAND_DRBG *RAND_DRBG_get0_private(void); | |||
| /* | |||
| * EXDATA | |||
| */ | |||
| # define RAND_DRBG_get_ex_new_index(l, p, newf, dupf, freef) \ | |||
| CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DRBG, l, p, newf, dupf, freef) | |||
| int RAND_DRBG_set_ex_data(RAND_DRBG *drbg, int idx, void *arg); | |||
| void *RAND_DRBG_get_ex_data(const RAND_DRBG *drbg, int idx); | |||
| /* | |||
| * Callback function typedefs | |||
| */ | |||
| typedef size_t (*RAND_DRBG_get_entropy_fn)(RAND_DRBG *drbg, | |||
| unsigned char **pout, | |||
| int entropy, size_t min_len, | |||
| size_t max_len, | |||
| int prediction_resistance); | |||
| typedef void (*RAND_DRBG_cleanup_entropy_fn)(RAND_DRBG *ctx, | |||
| unsigned char *out, size_t outlen); | |||
| typedef size_t (*RAND_DRBG_get_nonce_fn)(RAND_DRBG *drbg, unsigned char **pout, | |||
| int entropy, size_t min_len, | |||
| size_t max_len); | |||
| typedef void (*RAND_DRBG_cleanup_nonce_fn)(RAND_DRBG *drbg, | |||
| unsigned char *out, size_t outlen); | |||
| int RAND_DRBG_set_callbacks(RAND_DRBG *drbg, | |||
| RAND_DRBG_get_entropy_fn get_entropy, | |||
| RAND_DRBG_cleanup_entropy_fn cleanup_entropy, | |||
| RAND_DRBG_get_nonce_fn get_nonce, | |||
| RAND_DRBG_cleanup_nonce_fn cleanup_nonce); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,94 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_RANDERR_H | |||
| # define HEADER_RANDERR_H | |||
| # include <openssl/symhacks.h> | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_RAND_strings(void); | |||
| /* | |||
| * RAND function codes. | |||
| */ | |||
| # define RAND_F_DATA_COLLECT_METHOD 127 | |||
| # define RAND_F_DRBG_BYTES 101 | |||
| # define RAND_F_DRBG_GET_ENTROPY 105 | |||
| # define RAND_F_DRBG_SETUP 117 | |||
| # define RAND_F_GET_ENTROPY 106 | |||
| # define RAND_F_RAND_BYTES 100 | |||
| # define RAND_F_RAND_DRBG_ENABLE_LOCKING 119 | |||
| # define RAND_F_RAND_DRBG_GENERATE 107 | |||
| # define RAND_F_RAND_DRBG_GET_ENTROPY 120 | |||
| # define RAND_F_RAND_DRBG_GET_NONCE 123 | |||
| # define RAND_F_RAND_DRBG_INSTANTIATE 108 | |||
| # define RAND_F_RAND_DRBG_NEW 109 | |||
| # define RAND_F_RAND_DRBG_RESEED 110 | |||
| # define RAND_F_RAND_DRBG_RESTART 102 | |||
| # define RAND_F_RAND_DRBG_SET 104 | |||
| # define RAND_F_RAND_DRBG_SET_DEFAULTS 121 | |||
| # define RAND_F_RAND_DRBG_UNINSTANTIATE 118 | |||
| # define RAND_F_RAND_LOAD_FILE 111 | |||
| # define RAND_F_RAND_POOL_ACQUIRE_ENTROPY 122 | |||
| # define RAND_F_RAND_POOL_ADD 103 | |||
| # define RAND_F_RAND_POOL_ADD_BEGIN 113 | |||
| # define RAND_F_RAND_POOL_ADD_END 114 | |||
| # define RAND_F_RAND_POOL_ATTACH 124 | |||
| # define RAND_F_RAND_POOL_BYTES_NEEDED 115 | |||
| # define RAND_F_RAND_POOL_GROW 125 | |||
| # define RAND_F_RAND_POOL_NEW 116 | |||
| # define RAND_F_RAND_PSEUDO_BYTES 126 | |||
| # define RAND_F_RAND_WRITE_FILE 112 | |||
| /* | |||
| * RAND reason codes. | |||
| */ | |||
| # define RAND_R_ADDITIONAL_INPUT_TOO_LONG 102 | |||
| # define RAND_R_ALREADY_INSTANTIATED 103 | |||
| # define RAND_R_ARGUMENT_OUT_OF_RANGE 105 | |||
| # define RAND_R_CANNOT_OPEN_FILE 121 | |||
| # define RAND_R_DRBG_ALREADY_INITIALIZED 129 | |||
| # define RAND_R_DRBG_NOT_INITIALISED 104 | |||
| # define RAND_R_ENTROPY_INPUT_TOO_LONG 106 | |||
| # define RAND_R_ENTROPY_OUT_OF_RANGE 124 | |||
| # define RAND_R_ERROR_ENTROPY_POOL_WAS_IGNORED 127 | |||
| # define RAND_R_ERROR_INITIALISING_DRBG 107 | |||
| # define RAND_R_ERROR_INSTANTIATING_DRBG 108 | |||
| # define RAND_R_ERROR_RETRIEVING_ADDITIONAL_INPUT 109 | |||
| # define RAND_R_ERROR_RETRIEVING_ENTROPY 110 | |||
| # define RAND_R_ERROR_RETRIEVING_NONCE 111 | |||
| # define RAND_R_FAILED_TO_CREATE_LOCK 126 | |||
| # define RAND_R_FUNC_NOT_IMPLEMENTED 101 | |||
| # define RAND_R_FWRITE_ERROR 123 | |||
| # define RAND_R_GENERATE_ERROR 112 | |||
| # define RAND_R_INTERNAL_ERROR 113 | |||
| # define RAND_R_IN_ERROR_STATE 114 | |||
| # define RAND_R_NOT_A_REGULAR_FILE 122 | |||
| # define RAND_R_NOT_INSTANTIATED 115 | |||
| # define RAND_R_NO_DRBG_IMPLEMENTATION_SELECTED 128 | |||
| # define RAND_R_PARENT_LOCKING_NOT_ENABLED 130 | |||
| # define RAND_R_PARENT_STRENGTH_TOO_WEAK 131 | |||
| # define RAND_R_PERSONALISATION_STRING_TOO_LONG 116 | |||
| # define RAND_R_PREDICTION_RESISTANCE_NOT_SUPPORTED 133 | |||
| # define RAND_R_PRNG_NOT_SEEDED 100 | |||
| # define RAND_R_RANDOM_POOL_OVERFLOW 125 | |||
| # define RAND_R_RANDOM_POOL_UNDERFLOW 134 | |||
| # define RAND_R_REQUEST_TOO_LARGE_FOR_DRBG 117 | |||
| # define RAND_R_RESEED_ERROR 118 | |||
| # define RAND_R_SELFTEST_FAILURE 119 | |||
| # define RAND_R_TOO_LITTLE_NONCE_REQUESTED 135 | |||
| # define RAND_R_TOO_MUCH_NONCE_REQUESTED 136 | |||
| # define RAND_R_UNSUPPORTED_DRBG_FLAGS 132 | |||
| # define RAND_R_UNSUPPORTED_DRBG_TYPE 120 | |||
| #endif | |||
| @ -1,51 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_RC2_H | |||
| # define HEADER_RC2_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_RC2 | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| typedef unsigned int RC2_INT; | |||
| # define RC2_ENCRYPT 1 | |||
| # define RC2_DECRYPT 0 | |||
| # define RC2_BLOCK 8 | |||
| # define RC2_KEY_LENGTH 16 | |||
| typedef struct rc2_key_st { | |||
| RC2_INT data[64]; | |||
| } RC2_KEY; | |||
| void RC2_set_key(RC2_KEY *key, int len, const unsigned char *data, int bits); | |||
| void RC2_ecb_encrypt(const unsigned char *in, unsigned char *out, | |||
| RC2_KEY *key, int enc); | |||
| void RC2_encrypt(unsigned long *data, RC2_KEY *key); | |||
| void RC2_decrypt(unsigned long *data, RC2_KEY *key); | |||
| void RC2_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, | |||
| RC2_KEY *ks, unsigned char *iv, int enc); | |||
| void RC2_cfb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, RC2_KEY *schedule, unsigned char *ivec, | |||
| int *num, int enc); | |||
| void RC2_ofb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, RC2_KEY *schedule, unsigned char *ivec, | |||
| int *num); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,36 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_RC4_H | |||
| # define HEADER_RC4_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_RC4 | |||
| # include <stddef.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| typedef struct rc4_key_st { | |||
| RC4_INT x, y; | |||
| RC4_INT data[256]; | |||
| } RC4_KEY; | |||
| const char *RC4_options(void); | |||
| void RC4_set_key(RC4_KEY *key, int len, const unsigned char *data); | |||
| void RC4(RC4_KEY *key, size_t len, const unsigned char *indata, | |||
| unsigned char *outdata); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,63 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_RC5_H | |||
| # define HEADER_RC5_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_RC5 | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| # define RC5_ENCRYPT 1 | |||
| # define RC5_DECRYPT 0 | |||
| # define RC5_32_INT unsigned int | |||
| # define RC5_32_BLOCK 8 | |||
| # define RC5_32_KEY_LENGTH 16/* This is a default, max is 255 */ | |||
| /* | |||
| * This are the only values supported. Tweak the code if you want more The | |||
| * most supported modes will be RC5-32/12/16 RC5-32/16/8 | |||
| */ | |||
| # define RC5_8_ROUNDS 8 | |||
| # define RC5_12_ROUNDS 12 | |||
| # define RC5_16_ROUNDS 16 | |||
| typedef struct rc5_key_st { | |||
| /* Number of rounds */ | |||
| int rounds; | |||
| RC5_32_INT data[2 * (RC5_16_ROUNDS + 1)]; | |||
| } RC5_32_KEY; | |||
| void RC5_32_set_key(RC5_32_KEY *key, int len, const unsigned char *data, | |||
| int rounds); | |||
| void RC5_32_ecb_encrypt(const unsigned char *in, unsigned char *out, | |||
| RC5_32_KEY *key, int enc); | |||
| void RC5_32_encrypt(unsigned long *data, RC5_32_KEY *key); | |||
| void RC5_32_decrypt(unsigned long *data, RC5_32_KEY *key); | |||
| void RC5_32_cbc_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, RC5_32_KEY *ks, unsigned char *iv, | |||
| int enc); | |||
| void RC5_32_cfb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, RC5_32_KEY *schedule, | |||
| unsigned char *ivec, int *num, int enc); | |||
| void RC5_32_ofb64_encrypt(const unsigned char *in, unsigned char *out, | |||
| long length, RC5_32_KEY *schedule, | |||
| unsigned char *ivec, int *num); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,47 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_RIPEMD_H | |||
| # define HEADER_RIPEMD_H | |||
| # include <openssl/opensslconf.h> | |||
| #ifndef OPENSSL_NO_RMD160 | |||
| # include <openssl/e_os2.h> | |||
| # include <stddef.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| # define RIPEMD160_LONG unsigned int | |||
| # define RIPEMD160_CBLOCK 64 | |||
| # define RIPEMD160_LBLOCK (RIPEMD160_CBLOCK/4) | |||
| # define RIPEMD160_DIGEST_LENGTH 20 | |||
| typedef struct RIPEMD160state_st { | |||
| RIPEMD160_LONG A, B, C, D, E; | |||
| RIPEMD160_LONG Nl, Nh; | |||
| RIPEMD160_LONG data[RIPEMD160_LBLOCK]; | |||
| unsigned int num; | |||
| } RIPEMD160_CTX; | |||
| int RIPEMD160_Init(RIPEMD160_CTX *c); | |||
| int RIPEMD160_Update(RIPEMD160_CTX *c, const void *data, size_t len); | |||
| int RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c); | |||
| unsigned char *RIPEMD160(const unsigned char *d, size_t n, unsigned char *md); | |||
| void RIPEMD160_Transform(RIPEMD160_CTX *c, const unsigned char *b); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,513 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_RSA_H | |||
| # define HEADER_RSA_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_RSA | |||
| # include <openssl/asn1.h> | |||
| # include <openssl/bio.h> | |||
| # include <openssl/crypto.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # include <openssl/bn.h> | |||
| # endif | |||
| # include <openssl/rsaerr.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| /* The types RSA and RSA_METHOD are defined in ossl_typ.h */ | |||
| # ifndef OPENSSL_RSA_MAX_MODULUS_BITS | |||
| # define OPENSSL_RSA_MAX_MODULUS_BITS 16384 | |||
| # endif | |||
| # define OPENSSL_RSA_FIPS_MIN_MODULUS_BITS 1024 | |||
| # ifndef OPENSSL_RSA_SMALL_MODULUS_BITS | |||
| # define OPENSSL_RSA_SMALL_MODULUS_BITS 3072 | |||
| # endif | |||
| # ifndef OPENSSL_RSA_MAX_PUBEXP_BITS | |||
| /* exponent limit enforced for "large" modulus only */ | |||
| # define OPENSSL_RSA_MAX_PUBEXP_BITS 64 | |||
| # endif | |||
| # define RSA_3 0x3L | |||
| # define RSA_F4 0x10001L | |||
| /* based on RFC 8017 appendix A.1.2 */ | |||
| # define RSA_ASN1_VERSION_DEFAULT 0 | |||
| # define RSA_ASN1_VERSION_MULTI 1 | |||
| # define RSA_DEFAULT_PRIME_NUM 2 | |||
| # define RSA_METHOD_FLAG_NO_CHECK 0x0001/* don't check pub/private | |||
| * match */ | |||
| # define RSA_FLAG_CACHE_PUBLIC 0x0002 | |||
| # define RSA_FLAG_CACHE_PRIVATE 0x0004 | |||
| # define RSA_FLAG_BLINDING 0x0008 | |||
| # define RSA_FLAG_THREAD_SAFE 0x0010 | |||
| /* | |||
| * This flag means the private key operations will be handled by rsa_mod_exp | |||
| * and that they do not depend on the private key components being present: | |||
| * for example a key stored in external hardware. Without this flag | |||
| * bn_mod_exp gets called when private key components are absent. | |||
| */ | |||
| # define RSA_FLAG_EXT_PKEY 0x0020 | |||
| /* | |||
| * new with 0.9.6j and 0.9.7b; the built-in | |||
| * RSA implementation now uses blinding by | |||
| * default (ignoring RSA_FLAG_BLINDING), | |||
| * but other engines might not need it | |||
| */ | |||
| # define RSA_FLAG_NO_BLINDING 0x0080 | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| /* | |||
| * Does nothing. Previously this switched off constant time behaviour. | |||
| */ | |||
| # define RSA_FLAG_NO_CONSTTIME 0x0000 | |||
| # endif | |||
| # if OPENSSL_API_COMPAT < 0x00908000L | |||
| /* deprecated name for the flag*/ | |||
| /* | |||
| * new with 0.9.7h; the built-in RSA | |||
| * implementation now uses constant time | |||
| * modular exponentiation for secret exponents | |||
| * by default. This flag causes the | |||
| * faster variable sliding window method to | |||
| * be used for all exponents. | |||
| */ | |||
| # define RSA_FLAG_NO_EXP_CONSTTIME RSA_FLAG_NO_CONSTTIME | |||
| # endif | |||
| # define EVP_PKEY_CTX_set_rsa_padding(ctx, pad) \ | |||
| RSA_pkey_ctx_ctrl(ctx, -1, EVP_PKEY_CTRL_RSA_PADDING, pad, NULL) | |||
| # define EVP_PKEY_CTX_get_rsa_padding(ctx, ppad) \ | |||
| RSA_pkey_ctx_ctrl(ctx, -1, EVP_PKEY_CTRL_GET_RSA_PADDING, 0, ppad) | |||
| # define EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, len) \ | |||
| RSA_pkey_ctx_ctrl(ctx, (EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY), \ | |||
| EVP_PKEY_CTRL_RSA_PSS_SALTLEN, len, NULL) | |||
| /* Salt length matches digest */ | |||
| # define RSA_PSS_SALTLEN_DIGEST -1 | |||
| /* Verify only: auto detect salt length */ | |||
| # define RSA_PSS_SALTLEN_AUTO -2 | |||
| /* Set salt length to maximum possible */ | |||
| # define RSA_PSS_SALTLEN_MAX -3 | |||
| /* Old compatible max salt length for sign only */ | |||
| # define RSA_PSS_SALTLEN_MAX_SIGN -2 | |||
| # define EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(ctx, len) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN, \ | |||
| EVP_PKEY_CTRL_RSA_PSS_SALTLEN, len, NULL) | |||
| # define EVP_PKEY_CTX_get_rsa_pss_saltlen(ctx, plen) \ | |||
| RSA_pkey_ctx_ctrl(ctx, (EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY), \ | |||
| EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN, 0, plen) | |||
| # define EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, bits) \ | |||
| RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN, \ | |||
| EVP_PKEY_CTRL_RSA_KEYGEN_BITS, bits, NULL) | |||
| # define EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp) \ | |||
| RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN, \ | |||
| EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, 0, pubexp) | |||
| # define EVP_PKEY_CTX_set_rsa_keygen_primes(ctx, primes) \ | |||
| RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN, \ | |||
| EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES, primes, NULL) | |||
| # define EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md) \ | |||
| RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT, \ | |||
| EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)(md)) | |||
| # define EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(ctx, md) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN, \ | |||
| EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)(md)) | |||
| # define EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ | |||
| EVP_PKEY_CTRL_RSA_OAEP_MD, 0, (void *)(md)) | |||
| # define EVP_PKEY_CTX_get_rsa_mgf1_md(ctx, pmd) \ | |||
| RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT, \ | |||
| EVP_PKEY_CTRL_GET_RSA_MGF1_MD, 0, (void *)(pmd)) | |||
| # define EVP_PKEY_CTX_get_rsa_oaep_md(ctx, pmd) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ | |||
| EVP_PKEY_CTRL_GET_RSA_OAEP_MD, 0, (void *)(pmd)) | |||
| # define EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, l, llen) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ | |||
| EVP_PKEY_CTRL_RSA_OAEP_LABEL, llen, (void *)(l)) | |||
| # define EVP_PKEY_CTX_get0_rsa_oaep_label(ctx, l) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ | |||
| EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL, 0, (void *)(l)) | |||
| # define EVP_PKEY_CTX_set_rsa_pss_keygen_md(ctx, md) \ | |||
| EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, \ | |||
| EVP_PKEY_OP_KEYGEN, EVP_PKEY_CTRL_MD, \ | |||
| 0, (void *)(md)) | |||
| # define EVP_PKEY_CTRL_RSA_PADDING (EVP_PKEY_ALG_CTRL + 1) | |||
| # define EVP_PKEY_CTRL_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 2) | |||
| # define EVP_PKEY_CTRL_RSA_KEYGEN_BITS (EVP_PKEY_ALG_CTRL + 3) | |||
| # define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 4) | |||
| # define EVP_PKEY_CTRL_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 5) | |||
| # define EVP_PKEY_CTRL_GET_RSA_PADDING (EVP_PKEY_ALG_CTRL + 6) | |||
| # define EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 7) | |||
| # define EVP_PKEY_CTRL_GET_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 8) | |||
| # define EVP_PKEY_CTRL_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 9) | |||
| # define EVP_PKEY_CTRL_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 10) | |||
| # define EVP_PKEY_CTRL_GET_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 11) | |||
| # define EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 12) | |||
| # define EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES (EVP_PKEY_ALG_CTRL + 13) | |||
| # define RSA_PKCS1_PADDING 1 | |||
| # define RSA_SSLV23_PADDING 2 | |||
| # define RSA_NO_PADDING 3 | |||
| # define RSA_PKCS1_OAEP_PADDING 4 | |||
| # define RSA_X931_PADDING 5 | |||
| /* EVP_PKEY_ only */ | |||
| # define RSA_PKCS1_PSS_PADDING 6 | |||
| # define RSA_PKCS1_PADDING_SIZE 11 | |||
| # define RSA_set_app_data(s,arg) RSA_set_ex_data(s,0,arg) | |||
| # define RSA_get_app_data(s) RSA_get_ex_data(s,0) | |||
| RSA *RSA_new(void); | |||
| RSA *RSA_new_method(ENGINE *engine); | |||
| int RSA_bits(const RSA *rsa); | |||
| int RSA_size(const RSA *rsa); | |||
| int RSA_security_bits(const RSA *rsa); | |||
| int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d); | |||
| int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q); | |||
| int RSA_set0_crt_params(RSA *r,BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp); | |||
| int RSA_set0_multi_prime_params(RSA *r, BIGNUM *primes[], BIGNUM *exps[], | |||
| BIGNUM *coeffs[], int pnum); | |||
| void RSA_get0_key(const RSA *r, | |||
| const BIGNUM **n, const BIGNUM **e, const BIGNUM **d); | |||
| void RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q); | |||
| int RSA_get_multi_prime_extra_count(const RSA *r); | |||
| int RSA_get0_multi_prime_factors(const RSA *r, const BIGNUM *primes[]); | |||
| void RSA_get0_crt_params(const RSA *r, | |||
| const BIGNUM **dmp1, const BIGNUM **dmq1, | |||
| const BIGNUM **iqmp); | |||
| int RSA_get0_multi_prime_crt_params(const RSA *r, const BIGNUM *exps[], | |||
| const BIGNUM *coeffs[]); | |||
| const BIGNUM *RSA_get0_n(const RSA *d); | |||
| const BIGNUM *RSA_get0_e(const RSA *d); | |||
| const BIGNUM *RSA_get0_d(const RSA *d); | |||
| const BIGNUM *RSA_get0_p(const RSA *d); | |||
| const BIGNUM *RSA_get0_q(const RSA *d); | |||
| const BIGNUM *RSA_get0_dmp1(const RSA *r); | |||
| const BIGNUM *RSA_get0_dmq1(const RSA *r); | |||
| const BIGNUM *RSA_get0_iqmp(const RSA *r); | |||
| const RSA_PSS_PARAMS *RSA_get0_pss_params(const RSA *r); | |||
| void RSA_clear_flags(RSA *r, int flags); | |||
| int RSA_test_flags(const RSA *r, int flags); | |||
| void RSA_set_flags(RSA *r, int flags); | |||
| int RSA_get_version(RSA *r); | |||
| ENGINE *RSA_get0_engine(const RSA *r); | |||
| /* Deprecated version */ | |||
| DEPRECATEDIN_0_9_8(RSA *RSA_generate_key(int bits, unsigned long e, void | |||
| (*callback) (int, int, void *), | |||
| void *cb_arg)) | |||
| /* New version */ | |||
| int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); | |||
| /* Multi-prime version */ | |||
| int RSA_generate_multi_prime_key(RSA *rsa, int bits, int primes, | |||
| BIGNUM *e, BN_GENCB *cb); | |||
| int RSA_X931_derive_ex(RSA *rsa, BIGNUM *p1, BIGNUM *p2, BIGNUM *q1, | |||
| BIGNUM *q2, const BIGNUM *Xp1, const BIGNUM *Xp2, | |||
| const BIGNUM *Xp, const BIGNUM *Xq1, const BIGNUM *Xq2, | |||
| const BIGNUM *Xq, const BIGNUM *e, BN_GENCB *cb); | |||
| int RSA_X931_generate_key_ex(RSA *rsa, int bits, const BIGNUM *e, | |||
| BN_GENCB *cb); | |||
| int RSA_check_key(const RSA *); | |||
| int RSA_check_key_ex(const RSA *, BN_GENCB *cb); | |||
| /* next 4 return -1 on error */ | |||
| int RSA_public_encrypt(int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, int padding); | |||
| int RSA_private_encrypt(int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, int padding); | |||
| int RSA_public_decrypt(int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, int padding); | |||
| int RSA_private_decrypt(int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, int padding); | |||
| void RSA_free(RSA *r); | |||
| /* "up" the RSA object's reference count */ | |||
| int RSA_up_ref(RSA *r); | |||
| int RSA_flags(const RSA *r); | |||
| void RSA_set_default_method(const RSA_METHOD *meth); | |||
| const RSA_METHOD *RSA_get_default_method(void); | |||
| const RSA_METHOD *RSA_null_method(void); | |||
| const RSA_METHOD *RSA_get_method(const RSA *rsa); | |||
| int RSA_set_method(RSA *rsa, const RSA_METHOD *meth); | |||
| /* these are the actual RSA functions */ | |||
| const RSA_METHOD *RSA_PKCS1_OpenSSL(void); | |||
| int RSA_pkey_ctx_ctrl(EVP_PKEY_CTX *ctx, int optype, int cmd, int p1, void *p2); | |||
| DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPublicKey) | |||
| DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPrivateKey) | |||
| struct rsa_pss_params_st { | |||
| X509_ALGOR *hashAlgorithm; | |||
| X509_ALGOR *maskGenAlgorithm; | |||
| ASN1_INTEGER *saltLength; | |||
| ASN1_INTEGER *trailerField; | |||
| /* Decoded hash algorithm from maskGenAlgorithm */ | |||
| X509_ALGOR *maskHash; | |||
| }; | |||
| DECLARE_ASN1_FUNCTIONS(RSA_PSS_PARAMS) | |||
| typedef struct rsa_oaep_params_st { | |||
| X509_ALGOR *hashFunc; | |||
| X509_ALGOR *maskGenFunc; | |||
| X509_ALGOR *pSourceFunc; | |||
| /* Decoded hash algorithm from maskGenFunc */ | |||
| X509_ALGOR *maskHash; | |||
| } RSA_OAEP_PARAMS; | |||
| DECLARE_ASN1_FUNCTIONS(RSA_OAEP_PARAMS) | |||
| # ifndef OPENSSL_NO_STDIO | |||
| int RSA_print_fp(FILE *fp, const RSA *r, int offset); | |||
| # endif | |||
| int RSA_print(BIO *bp, const RSA *r, int offset); | |||
| /* | |||
| * The following 2 functions sign and verify a X509_SIG ASN1 object inside | |||
| * PKCS#1 padded RSA encryption | |||
| */ | |||
| int RSA_sign(int type, const unsigned char *m, unsigned int m_length, | |||
| unsigned char *sigret, unsigned int *siglen, RSA *rsa); | |||
| int RSA_verify(int type, const unsigned char *m, unsigned int m_length, | |||
| const unsigned char *sigbuf, unsigned int siglen, RSA *rsa); | |||
| /* | |||
| * The following 2 function sign and verify a ASN1_OCTET_STRING object inside | |||
| * PKCS#1 padded RSA encryption | |||
| */ | |||
| int RSA_sign_ASN1_OCTET_STRING(int type, | |||
| const unsigned char *m, unsigned int m_length, | |||
| unsigned char *sigret, unsigned int *siglen, | |||
| RSA *rsa); | |||
| int RSA_verify_ASN1_OCTET_STRING(int type, const unsigned char *m, | |||
| unsigned int m_length, unsigned char *sigbuf, | |||
| unsigned int siglen, RSA *rsa); | |||
| int RSA_blinding_on(RSA *rsa, BN_CTX *ctx); | |||
| void RSA_blinding_off(RSA *rsa); | |||
| BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *ctx); | |||
| int RSA_padding_add_PKCS1_type_1(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl); | |||
| int RSA_padding_check_PKCS1_type_1(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl, | |||
| int rsa_len); | |||
| int RSA_padding_add_PKCS1_type_2(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl); | |||
| int RSA_padding_check_PKCS1_type_2(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl, | |||
| int rsa_len); | |||
| int PKCS1_MGF1(unsigned char *mask, long len, const unsigned char *seed, | |||
| long seedlen, const EVP_MD *dgst); | |||
| int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl, | |||
| const unsigned char *p, int pl); | |||
| int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl, int rsa_len, | |||
| const unsigned char *p, int pl); | |||
| int RSA_padding_add_PKCS1_OAEP_mgf1(unsigned char *to, int tlen, | |||
| const unsigned char *from, int flen, | |||
| const unsigned char *param, int plen, | |||
| const EVP_MD *md, const EVP_MD *mgf1md); | |||
| int RSA_padding_check_PKCS1_OAEP_mgf1(unsigned char *to, int tlen, | |||
| const unsigned char *from, int flen, | |||
| int num, const unsigned char *param, | |||
| int plen, const EVP_MD *md, | |||
| const EVP_MD *mgf1md); | |||
| int RSA_padding_add_SSLv23(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl); | |||
| int RSA_padding_check_SSLv23(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl, int rsa_len); | |||
| int RSA_padding_add_none(unsigned char *to, int tlen, const unsigned char *f, | |||
| int fl); | |||
| int RSA_padding_check_none(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl, int rsa_len); | |||
| int RSA_padding_add_X931(unsigned char *to, int tlen, const unsigned char *f, | |||
| int fl); | |||
| int RSA_padding_check_X931(unsigned char *to, int tlen, | |||
| const unsigned char *f, int fl, int rsa_len); | |||
| int RSA_X931_hash_id(int nid); | |||
| int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash, | |||
| const EVP_MD *Hash, const unsigned char *EM, | |||
| int sLen); | |||
| int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM, | |||
| const unsigned char *mHash, const EVP_MD *Hash, | |||
| int sLen); | |||
| int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash, | |||
| const EVP_MD *Hash, const EVP_MD *mgf1Hash, | |||
| const unsigned char *EM, int sLen); | |||
| int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM, | |||
| const unsigned char *mHash, | |||
| const EVP_MD *Hash, const EVP_MD *mgf1Hash, | |||
| int sLen); | |||
| #define RSA_get_ex_new_index(l, p, newf, dupf, freef) \ | |||
| CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, l, p, newf, dupf, freef) | |||
| int RSA_set_ex_data(RSA *r, int idx, void *arg); | |||
| void *RSA_get_ex_data(const RSA *r, int idx); | |||
| RSA *RSAPublicKey_dup(RSA *rsa); | |||
| RSA *RSAPrivateKey_dup(RSA *rsa); | |||
| /* | |||
| * If this flag is set the RSA method is FIPS compliant and can be used in | |||
| * FIPS mode. This is set in the validated module method. If an application | |||
| * sets this flag in its own methods it is its responsibility to ensure the | |||
| * result is compliant. | |||
| */ | |||
| # define RSA_FLAG_FIPS_METHOD 0x0400 | |||
| /* | |||
| * If this flag is set the operations normally disabled in FIPS mode are | |||
| * permitted it is then the applications responsibility to ensure that the | |||
| * usage is compliant. | |||
| */ | |||
| # define RSA_FLAG_NON_FIPS_ALLOW 0x0400 | |||
| /* | |||
| * Application has decided PRNG is good enough to generate a key: don't | |||
| * check. | |||
| */ | |||
| # define RSA_FLAG_CHECKED 0x0800 | |||
| RSA_METHOD *RSA_meth_new(const char *name, int flags); | |||
| void RSA_meth_free(RSA_METHOD *meth); | |||
| RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth); | |||
| const char *RSA_meth_get0_name(const RSA_METHOD *meth); | |||
| int RSA_meth_set1_name(RSA_METHOD *meth, const char *name); | |||
| int RSA_meth_get_flags(const RSA_METHOD *meth); | |||
| int RSA_meth_set_flags(RSA_METHOD *meth, int flags); | |||
| void *RSA_meth_get0_app_data(const RSA_METHOD *meth); | |||
| int RSA_meth_set0_app_data(RSA_METHOD *meth, void *app_data); | |||
| int (*RSA_meth_get_pub_enc(const RSA_METHOD *meth)) | |||
| (int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, int padding); | |||
| int RSA_meth_set_pub_enc(RSA_METHOD *rsa, | |||
| int (*pub_enc) (int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, | |||
| int padding)); | |||
| int (*RSA_meth_get_pub_dec(const RSA_METHOD *meth)) | |||
| (int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, int padding); | |||
| int RSA_meth_set_pub_dec(RSA_METHOD *rsa, | |||
| int (*pub_dec) (int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, | |||
| int padding)); | |||
| int (*RSA_meth_get_priv_enc(const RSA_METHOD *meth)) | |||
| (int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, int padding); | |||
| int RSA_meth_set_priv_enc(RSA_METHOD *rsa, | |||
| int (*priv_enc) (int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, | |||
| int padding)); | |||
| int (*RSA_meth_get_priv_dec(const RSA_METHOD *meth)) | |||
| (int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, int padding); | |||
| int RSA_meth_set_priv_dec(RSA_METHOD *rsa, | |||
| int (*priv_dec) (int flen, const unsigned char *from, | |||
| unsigned char *to, RSA *rsa, | |||
| int padding)); | |||
| int (*RSA_meth_get_mod_exp(const RSA_METHOD *meth)) | |||
| (BIGNUM *r0, const BIGNUM *i, RSA *rsa, BN_CTX *ctx); | |||
| int RSA_meth_set_mod_exp(RSA_METHOD *rsa, | |||
| int (*mod_exp) (BIGNUM *r0, const BIGNUM *i, RSA *rsa, | |||
| BN_CTX *ctx)); | |||
| int (*RSA_meth_get_bn_mod_exp(const RSA_METHOD *meth)) | |||
| (BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |||
| const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |||
| int RSA_meth_set_bn_mod_exp(RSA_METHOD *rsa, | |||
| int (*bn_mod_exp) (BIGNUM *r, | |||
| const BIGNUM *a, | |||
| const BIGNUM *p, | |||
| const BIGNUM *m, | |||
| BN_CTX *ctx, | |||
| BN_MONT_CTX *m_ctx)); | |||
| int (*RSA_meth_get_init(const RSA_METHOD *meth)) (RSA *rsa); | |||
| int RSA_meth_set_init(RSA_METHOD *rsa, int (*init) (RSA *rsa)); | |||
| int (*RSA_meth_get_finish(const RSA_METHOD *meth)) (RSA *rsa); | |||
| int RSA_meth_set_finish(RSA_METHOD *rsa, int (*finish) (RSA *rsa)); | |||
| int (*RSA_meth_get_sign(const RSA_METHOD *meth)) | |||
| (int type, | |||
| const unsigned char *m, unsigned int m_length, | |||
| unsigned char *sigret, unsigned int *siglen, | |||
| const RSA *rsa); | |||
| int RSA_meth_set_sign(RSA_METHOD *rsa, | |||
| int (*sign) (int type, const unsigned char *m, | |||
| unsigned int m_length, | |||
| unsigned char *sigret, unsigned int *siglen, | |||
| const RSA *rsa)); | |||
| int (*RSA_meth_get_verify(const RSA_METHOD *meth)) | |||
| (int dtype, const unsigned char *m, | |||
| unsigned int m_length, const unsigned char *sigbuf, | |||
| unsigned int siglen, const RSA *rsa); | |||
| int RSA_meth_set_verify(RSA_METHOD *rsa, | |||
| int (*verify) (int dtype, const unsigned char *m, | |||
| unsigned int m_length, | |||
| const unsigned char *sigbuf, | |||
| unsigned int siglen, const RSA *rsa)); | |||
| int (*RSA_meth_get_keygen(const RSA_METHOD *meth)) | |||
| (RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); | |||
| int RSA_meth_set_keygen(RSA_METHOD *rsa, | |||
| int (*keygen) (RSA *rsa, int bits, BIGNUM *e, | |||
| BN_GENCB *cb)); | |||
| int (*RSA_meth_get_multi_prime_keygen(const RSA_METHOD *meth)) | |||
| (RSA *rsa, int bits, int primes, BIGNUM *e, BN_GENCB *cb); | |||
| int RSA_meth_set_multi_prime_keygen(RSA_METHOD *meth, | |||
| int (*keygen) (RSA *rsa, int bits, | |||
| int primes, BIGNUM *e, | |||
| BN_GENCB *cb)); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,167 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_RSAERR_H | |||
| # define HEADER_RSAERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_RSA_strings(void); | |||
| /* | |||
| * RSA function codes. | |||
| */ | |||
| # define RSA_F_CHECK_PADDING_MD 140 | |||
| # define RSA_F_ENCODE_PKCS1 146 | |||
| # define RSA_F_INT_RSA_VERIFY 145 | |||
| # define RSA_F_OLD_RSA_PRIV_DECODE 147 | |||
| # define RSA_F_PKEY_PSS_INIT 165 | |||
| # define RSA_F_PKEY_RSA_CTRL 143 | |||
| # define RSA_F_PKEY_RSA_CTRL_STR 144 | |||
| # define RSA_F_PKEY_RSA_SIGN 142 | |||
| # define RSA_F_PKEY_RSA_VERIFY 149 | |||
| # define RSA_F_PKEY_RSA_VERIFYRECOVER 141 | |||
| # define RSA_F_RSA_ALGOR_TO_MD 156 | |||
| # define RSA_F_RSA_BUILTIN_KEYGEN 129 | |||
| # define RSA_F_RSA_CHECK_KEY 123 | |||
| # define RSA_F_RSA_CHECK_KEY_EX 160 | |||
| # define RSA_F_RSA_CMS_DECRYPT 159 | |||
| # define RSA_F_RSA_CMS_VERIFY 158 | |||
| # define RSA_F_RSA_ITEM_VERIFY 148 | |||
| # define RSA_F_RSA_METH_DUP 161 | |||
| # define RSA_F_RSA_METH_NEW 162 | |||
| # define RSA_F_RSA_METH_SET1_NAME 163 | |||
| # define RSA_F_RSA_MGF1_TO_MD 157 | |||
| # define RSA_F_RSA_MULTIP_INFO_NEW 166 | |||
| # define RSA_F_RSA_NEW_METHOD 106 | |||
| # define RSA_F_RSA_NULL 124 | |||
| # define RSA_F_RSA_NULL_PRIVATE_DECRYPT 132 | |||
| # define RSA_F_RSA_NULL_PRIVATE_ENCRYPT 133 | |||
| # define RSA_F_RSA_NULL_PUBLIC_DECRYPT 134 | |||
| # define RSA_F_RSA_NULL_PUBLIC_ENCRYPT 135 | |||
| # define RSA_F_RSA_OSSL_PRIVATE_DECRYPT 101 | |||
| # define RSA_F_RSA_OSSL_PRIVATE_ENCRYPT 102 | |||
| # define RSA_F_RSA_OSSL_PUBLIC_DECRYPT 103 | |||
| # define RSA_F_RSA_OSSL_PUBLIC_ENCRYPT 104 | |||
| # define RSA_F_RSA_PADDING_ADD_NONE 107 | |||
| # define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP 121 | |||
| # define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP_MGF1 154 | |||
| # define RSA_F_RSA_PADDING_ADD_PKCS1_PSS 125 | |||
| # define RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1 152 | |||
| # define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1 108 | |||
| # define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2 109 | |||
| # define RSA_F_RSA_PADDING_ADD_SSLV23 110 | |||
| # define RSA_F_RSA_PADDING_ADD_X931 127 | |||
| # define RSA_F_RSA_PADDING_CHECK_NONE 111 | |||
| # define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP 122 | |||
| # define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP_MGF1 153 | |||
| # define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1 112 | |||
| # define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2 113 | |||
| # define RSA_F_RSA_PADDING_CHECK_SSLV23 114 | |||
| # define RSA_F_RSA_PADDING_CHECK_X931 128 | |||
| # define RSA_F_RSA_PARAM_DECODE 164 | |||
| # define RSA_F_RSA_PRINT 115 | |||
| # define RSA_F_RSA_PRINT_FP 116 | |||
| # define RSA_F_RSA_PRIV_DECODE 150 | |||
| # define RSA_F_RSA_PRIV_ENCODE 138 | |||
| # define RSA_F_RSA_PSS_GET_PARAM 151 | |||
| # define RSA_F_RSA_PSS_TO_CTX 155 | |||
| # define RSA_F_RSA_PUB_DECODE 139 | |||
| # define RSA_F_RSA_SETUP_BLINDING 136 | |||
| # define RSA_F_RSA_SIGN 117 | |||
| # define RSA_F_RSA_SIGN_ASN1_OCTET_STRING 118 | |||
| # define RSA_F_RSA_VERIFY 119 | |||
| # define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING 120 | |||
| # define RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1 126 | |||
| # define RSA_F_SETUP_TBUF 167 | |||
| /* | |||
| * RSA reason codes. | |||
| */ | |||
| # define RSA_R_ALGORITHM_MISMATCH 100 | |||
| # define RSA_R_BAD_E_VALUE 101 | |||
| # define RSA_R_BAD_FIXED_HEADER_DECRYPT 102 | |||
| # define RSA_R_BAD_PAD_BYTE_COUNT 103 | |||
| # define RSA_R_BAD_SIGNATURE 104 | |||
| # define RSA_R_BLOCK_TYPE_IS_NOT_01 106 | |||
| # define RSA_R_BLOCK_TYPE_IS_NOT_02 107 | |||
| # define RSA_R_DATA_GREATER_THAN_MOD_LEN 108 | |||
| # define RSA_R_DATA_TOO_LARGE 109 | |||
| # define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 110 | |||
| # define RSA_R_DATA_TOO_LARGE_FOR_MODULUS 132 | |||
| # define RSA_R_DATA_TOO_SMALL 111 | |||
| # define RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE 122 | |||
| # define RSA_R_DIGEST_DOES_NOT_MATCH 158 | |||
| # define RSA_R_DIGEST_NOT_ALLOWED 145 | |||
| # define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY 112 | |||
| # define RSA_R_DMP1_NOT_CONGRUENT_TO_D 124 | |||
| # define RSA_R_DMQ1_NOT_CONGRUENT_TO_D 125 | |||
| # define RSA_R_D_E_NOT_CONGRUENT_TO_1 123 | |||
| # define RSA_R_FIRST_OCTET_INVALID 133 | |||
| # define RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 144 | |||
| # define RSA_R_INVALID_DIGEST 157 | |||
| # define RSA_R_INVALID_DIGEST_LENGTH 143 | |||
| # define RSA_R_INVALID_HEADER 137 | |||
| # define RSA_R_INVALID_LABEL 160 | |||
| # define RSA_R_INVALID_MESSAGE_LENGTH 131 | |||
| # define RSA_R_INVALID_MGF1_MD 156 | |||
| # define RSA_R_INVALID_MULTI_PRIME_KEY 167 | |||
| # define RSA_R_INVALID_OAEP_PARAMETERS 161 | |||
| # define RSA_R_INVALID_PADDING 138 | |||
| # define RSA_R_INVALID_PADDING_MODE 141 | |||
| # define RSA_R_INVALID_PSS_PARAMETERS 149 | |||
| # define RSA_R_INVALID_PSS_SALTLEN 146 | |||
| # define RSA_R_INVALID_SALT_LENGTH 150 | |||
| # define RSA_R_INVALID_TRAILER 139 | |||
| # define RSA_R_INVALID_X931_DIGEST 142 | |||
| # define RSA_R_IQMP_NOT_INVERSE_OF_Q 126 | |||
| # define RSA_R_KEY_PRIME_NUM_INVALID 165 | |||
| # define RSA_R_KEY_SIZE_TOO_SMALL 120 | |||
| # define RSA_R_LAST_OCTET_INVALID 134 | |||
| # define RSA_R_MISSING_PRIVATE_KEY 179 | |||
| # define RSA_R_MGF1_DIGEST_NOT_ALLOWED 152 | |||
| # define RSA_R_MODULUS_TOO_LARGE 105 | |||
| # define RSA_R_MP_COEFFICIENT_NOT_INVERSE_OF_R 168 | |||
| # define RSA_R_MP_EXPONENT_NOT_CONGRUENT_TO_D 169 | |||
| # define RSA_R_MP_R_NOT_PRIME 170 | |||
| # define RSA_R_NO_PUBLIC_EXPONENT 140 | |||
| # define RSA_R_NULL_BEFORE_BLOCK_MISSING 113 | |||
| # define RSA_R_N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES 172 | |||
| # define RSA_R_N_DOES_NOT_EQUAL_P_Q 127 | |||
| # define RSA_R_OAEP_DECODING_ERROR 121 | |||
| # define RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 148 | |||
| # define RSA_R_PADDING_CHECK_FAILED 114 | |||
| # define RSA_R_PKCS_DECODING_ERROR 159 | |||
| # define RSA_R_PSS_SALTLEN_TOO_SMALL 164 | |||
| # define RSA_R_P_NOT_PRIME 128 | |||
| # define RSA_R_Q_NOT_PRIME 129 | |||
| # define RSA_R_RSA_OPERATIONS_NOT_SUPPORTED 130 | |||
| # define RSA_R_SLEN_CHECK_FAILED 136 | |||
| # define RSA_R_SLEN_RECOVERY_FAILED 135 | |||
| # define RSA_R_SSLV3_ROLLBACK_ATTACK 115 | |||
| # define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116 | |||
| # define RSA_R_UNKNOWN_ALGORITHM_TYPE 117 | |||
| # define RSA_R_UNKNOWN_DIGEST 166 | |||
| # define RSA_R_UNKNOWN_MASK_DIGEST 151 | |||
| # define RSA_R_UNKNOWN_PADDING_TYPE 118 | |||
| # define RSA_R_UNSUPPORTED_ENCRYPTION_TYPE 162 | |||
| # define RSA_R_UNSUPPORTED_LABEL_SOURCE 163 | |||
| # define RSA_R_UNSUPPORTED_MASK_ALGORITHM 153 | |||
| # define RSA_R_UNSUPPORTED_MASK_PARAMETER 154 | |||
| # define RSA_R_UNSUPPORTED_SIGNATURE_TYPE 155 | |||
| # define RSA_R_VALUE_MISSING 147 | |||
| # define RSA_R_WRONG_SIGNATURE_LENGTH 119 | |||
| #endif | |||
| @ -1,207 +0,0 @@ | |||
| /* | |||
| * Copyright 1999-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_SAFESTACK_H | |||
| # define HEADER_SAFESTACK_H | |||
| # include <openssl/stack.h> | |||
| # include <openssl/e_os2.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # define STACK_OF(type) struct stack_st_##type | |||
| # define SKM_DEFINE_STACK_OF(t1, t2, t3) \ | |||
| STACK_OF(t1); \ | |||
| typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \ | |||
| typedef void (*sk_##t1##_freefunc)(t3 *a); \ | |||
| typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \ | |||
| static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \ | |||
| { \ | |||
| return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \ | |||
| } \ | |||
| static ossl_unused ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \ | |||
| { \ | |||
| return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); \ | |||
| } \ | |||
| static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \ | |||
| { \ | |||
| return (STACK_OF(t1) *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \ | |||
| } \ | |||
| static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \ | |||
| { \ | |||
| return (STACK_OF(t1) *)OPENSSL_sk_new_null(); \ | |||
| } \ | |||
| static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n) \ | |||
| { \ | |||
| return (STACK_OF(t1) *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); \ | |||
| } \ | |||
| static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n) \ | |||
| { \ | |||
| return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \ | |||
| { \ | |||
| OPENSSL_sk_free((OPENSSL_STACK *)sk); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \ | |||
| { \ | |||
| OPENSSL_sk_zero((OPENSSL_STACK *)sk); \ | |||
| } \ | |||
| static ossl_unused ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \ | |||
| { \ | |||
| return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); \ | |||
| } \ | |||
| static ossl_unused ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \ | |||
| { \ | |||
| return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, \ | |||
| (const void *)ptr); \ | |||
| } \ | |||
| static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \ | |||
| { \ | |||
| return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); \ | |||
| } \ | |||
| static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \ | |||
| { \ | |||
| return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); \ | |||
| } \ | |||
| static ossl_unused ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \ | |||
| { \ | |||
| return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \ | |||
| } \ | |||
| static ossl_unused ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \ | |||
| { \ | |||
| return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \ | |||
| { \ | |||
| OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); \ | |||
| } \ | |||
| static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \ | |||
| { \ | |||
| return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); \ | |||
| } \ | |||
| static ossl_unused ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \ | |||
| { \ | |||
| return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); \ | |||
| } \ | |||
| static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \ | |||
| { \ | |||
| return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); \ | |||
| } \ | |||
| static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \ | |||
| { \ | |||
| return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); \ | |||
| } \ | |||
| static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \ | |||
| { \ | |||
| OPENSSL_sk_sort((OPENSSL_STACK *)sk); \ | |||
| } \ | |||
| static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \ | |||
| { \ | |||
| return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \ | |||
| } \ | |||
| static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_dup(const STACK_OF(t1) *sk) \ | |||
| { \ | |||
| return (STACK_OF(t1) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); \ | |||
| } \ | |||
| static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk, \ | |||
| sk_##t1##_copyfunc copyfunc, \ | |||
| sk_##t1##_freefunc freefunc) \ | |||
| { \ | |||
| return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, \ | |||
| (OPENSSL_sk_copyfunc)copyfunc, \ | |||
| (OPENSSL_sk_freefunc)freefunc); \ | |||
| } \ | |||
| static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \ | |||
| { \ | |||
| return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); \ | |||
| } | |||
| # define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2) | |||
| # define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t) | |||
| # define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \ | |||
| SKM_DEFINE_STACK_OF(t1, const t2, t2) | |||
| # define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t) | |||
| /*- | |||
| * Strings are special: normally an lhash entry will point to a single | |||
| * (somewhat) mutable object. In the case of strings: | |||
| * | |||
| * a) Instead of a single char, there is an array of chars, NUL-terminated. | |||
| * b) The string may have be immutable. | |||
| * | |||
| * So, they need their own declarations. Especially important for | |||
| * type-checking tools, such as Deputy. | |||
| * | |||
| * In practice, however, it appears to be hard to have a const | |||
| * string. For now, I'm settling for dealing with the fact it is a | |||
| * string at all. | |||
| */ | |||
| typedef char *OPENSSL_STRING; | |||
| typedef const char *OPENSSL_CSTRING; | |||
| /*- | |||
| * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but | |||
| * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned | |||
| * above, instead of a single char each entry is a NUL-terminated array of | |||
| * chars. So, we have to implement STRING specially for STACK_OF. This is | |||
| * dealt with in the autogenerated macros below. | |||
| */ | |||
| DEFINE_SPECIAL_STACK_OF(OPENSSL_STRING, char) | |||
| DEFINE_SPECIAL_STACK_OF_CONST(OPENSSL_CSTRING, char) | |||
| /* | |||
| * Similarly, we sometimes use a block of characters, NOT nul-terminated. | |||
| * These should also be distinguished from "normal" stacks. | |||
| */ | |||
| typedef void *OPENSSL_BLOCK; | |||
| DEFINE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void) | |||
| /* | |||
| * If called without higher optimization (min. -xO3) the Oracle Developer | |||
| * Studio compiler generates code for the defined (static inline) functions | |||
| * above. | |||
| * This would later lead to the linker complaining about missing symbols when | |||
| * this header file is included but the resulting object is not linked against | |||
| * the Crypto library (openssl#6912). | |||
| */ | |||
| # ifdef __SUNPRO_C | |||
| # pragma weak OPENSSL_sk_num | |||
| # pragma weak OPENSSL_sk_value | |||
| # pragma weak OPENSSL_sk_new | |||
| # pragma weak OPENSSL_sk_new_null | |||
| # pragma weak OPENSSL_sk_new_reserve | |||
| # pragma weak OPENSSL_sk_reserve | |||
| # pragma weak OPENSSL_sk_free | |||
| # pragma weak OPENSSL_sk_zero | |||
| # pragma weak OPENSSL_sk_delete | |||
| # pragma weak OPENSSL_sk_delete_ptr | |||
| # pragma weak OPENSSL_sk_push | |||
| # pragma weak OPENSSL_sk_unshift | |||
| # pragma weak OPENSSL_sk_pop | |||
| # pragma weak OPENSSL_sk_shift | |||
| # pragma weak OPENSSL_sk_pop_free | |||
| # pragma weak OPENSSL_sk_insert | |||
| # pragma weak OPENSSL_sk_set | |||
| # pragma weak OPENSSL_sk_find | |||
| # pragma weak OPENSSL_sk_find_ex | |||
| # pragma weak OPENSSL_sk_sort | |||
| # pragma weak OPENSSL_sk_is_sorted | |||
| # pragma weak OPENSSL_sk_dup | |||
| # pragma weak OPENSSL_sk_deep_copy | |||
| # pragma weak OPENSSL_sk_set_cmp_func | |||
| # endif /* __SUNPRO_C */ | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,96 +0,0 @@ | |||
| /* | |||
| * Copyright 2007-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| /* | |||
| * Copyright (c) 2007 KISA(Korea Information Security Agency). All rights reserved. | |||
| * | |||
| * Redistribution and use in source and binary forms, with or without | |||
| * modification, are permitted provided that the following conditions | |||
| * are met: | |||
| * 1. Redistributions of source code must retain the above copyright | |||
| * notice, this list of conditions and the following disclaimer. | |||
| * 2. Neither the name of author nor the names of its contributors may | |||
| * be used to endorse or promote products derived from this software | |||
| * without specific prior written permission. | |||
| * | |||
| * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND | |||
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |||
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |||
| * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE | |||
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |||
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |||
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |||
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |||
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |||
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |||
| * SUCH DAMAGE. | |||
| */ | |||
| #ifndef HEADER_SEED_H | |||
| # define HEADER_SEED_H | |||
| # include <openssl/opensslconf.h> | |||
| # ifndef OPENSSL_NO_SEED | |||
| # include <openssl/e_os2.h> | |||
| # include <openssl/crypto.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /* look whether we need 'long' to get 32 bits */ | |||
| # ifdef AES_LONG | |||
| # ifndef SEED_LONG | |||
| # define SEED_LONG 1 | |||
| # endif | |||
| # endif | |||
| # include <sys/types.h> | |||
| # define SEED_BLOCK_SIZE 16 | |||
| # define SEED_KEY_LENGTH 16 | |||
| typedef struct seed_key_st { | |||
| # ifdef SEED_LONG | |||
| unsigned long data[32]; | |||
| # else | |||
| unsigned int data[32]; | |||
| # endif | |||
| } SEED_KEY_SCHEDULE; | |||
| void SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH], | |||
| SEED_KEY_SCHEDULE *ks); | |||
| void SEED_encrypt(const unsigned char s[SEED_BLOCK_SIZE], | |||
| unsigned char d[SEED_BLOCK_SIZE], | |||
| const SEED_KEY_SCHEDULE *ks); | |||
| void SEED_decrypt(const unsigned char s[SEED_BLOCK_SIZE], | |||
| unsigned char d[SEED_BLOCK_SIZE], | |||
| const SEED_KEY_SCHEDULE *ks); | |||
| void SEED_ecb_encrypt(const unsigned char *in, unsigned char *out, | |||
| const SEED_KEY_SCHEDULE *ks, int enc); | |||
| void SEED_cbc_encrypt(const unsigned char *in, unsigned char *out, size_t len, | |||
| const SEED_KEY_SCHEDULE *ks, | |||
| unsigned char ivec[SEED_BLOCK_SIZE], int enc); | |||
| void SEED_cfb128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const SEED_KEY_SCHEDULE *ks, | |||
| unsigned char ivec[SEED_BLOCK_SIZE], int *num, | |||
| int enc); | |||
| void SEED_ofb128_encrypt(const unsigned char *in, unsigned char *out, | |||
| size_t len, const SEED_KEY_SCHEDULE *ks, | |||
| unsigned char ivec[SEED_BLOCK_SIZE], int *num); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,119 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_SHA_H | |||
| # define HEADER_SHA_H | |||
| # include <openssl/e_os2.h> | |||
| # include <stddef.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /*- | |||
| * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |||
| * ! SHA_LONG has to be at least 32 bits wide. ! | |||
| * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |||
| */ | |||
| # define SHA_LONG unsigned int | |||
| # define SHA_LBLOCK 16 | |||
| # define SHA_CBLOCK (SHA_LBLOCK*4)/* SHA treats input data as a | |||
| * contiguous array of 32 bit wide | |||
| * big-endian values. */ | |||
| # define SHA_LAST_BLOCK (SHA_CBLOCK-8) | |||
| # define SHA_DIGEST_LENGTH 20 | |||
| typedef struct SHAstate_st { | |||
| SHA_LONG h0, h1, h2, h3, h4; | |||
| SHA_LONG Nl, Nh; | |||
| SHA_LONG data[SHA_LBLOCK]; | |||
| unsigned int num; | |||
| } SHA_CTX; | |||
| int SHA1_Init(SHA_CTX *c); | |||
| int SHA1_Update(SHA_CTX *c, const void *data, size_t len); | |||
| int SHA1_Final(unsigned char *md, SHA_CTX *c); | |||
| unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md); | |||
| void SHA1_Transform(SHA_CTX *c, const unsigned char *data); | |||
| # define SHA256_CBLOCK (SHA_LBLOCK*4)/* SHA-256 treats input data as a | |||
| * contiguous array of 32 bit wide | |||
| * big-endian values. */ | |||
| typedef struct SHA256state_st { | |||
| SHA_LONG h[8]; | |||
| SHA_LONG Nl, Nh; | |||
| SHA_LONG data[SHA_LBLOCK]; | |||
| unsigned int num, md_len; | |||
| } SHA256_CTX; | |||
| int SHA224_Init(SHA256_CTX *c); | |||
| int SHA224_Update(SHA256_CTX *c, const void *data, size_t len); | |||
| int SHA224_Final(unsigned char *md, SHA256_CTX *c); | |||
| unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md); | |||
| int SHA256_Init(SHA256_CTX *c); | |||
| int SHA256_Update(SHA256_CTX *c, const void *data, size_t len); | |||
| int SHA256_Final(unsigned char *md, SHA256_CTX *c); | |||
| unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md); | |||
| void SHA256_Transform(SHA256_CTX *c, const unsigned char *data); | |||
| # define SHA224_DIGEST_LENGTH 28 | |||
| # define SHA256_DIGEST_LENGTH 32 | |||
| # define SHA384_DIGEST_LENGTH 48 | |||
| # define SHA512_DIGEST_LENGTH 64 | |||
| /* | |||
| * Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64 | |||
| * being exactly 64-bit wide. See Implementation Notes in sha512.c | |||
| * for further details. | |||
| */ | |||
| /* | |||
| * SHA-512 treats input data as a | |||
| * contiguous array of 64 bit | |||
| * wide big-endian values. | |||
| */ | |||
| # define SHA512_CBLOCK (SHA_LBLOCK*8) | |||
| # if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__) | |||
| # define SHA_LONG64 unsigned __int64 | |||
| # define U64(C) C##UI64 | |||
| # elif defined(__arch64__) | |||
| # define SHA_LONG64 unsigned long | |||
| # define U64(C) C##UL | |||
| # else | |||
| # define SHA_LONG64 unsigned long long | |||
| # define U64(C) C##ULL | |||
| # endif | |||
| typedef struct SHA512state_st { | |||
| SHA_LONG64 h[8]; | |||
| SHA_LONG64 Nl, Nh; | |||
| union { | |||
| SHA_LONG64 d[SHA_LBLOCK]; | |||
| unsigned char p[SHA512_CBLOCK]; | |||
| } u; | |||
| unsigned int num, md_len; | |||
| } SHA512_CTX; | |||
| int SHA384_Init(SHA512_CTX *c); | |||
| int SHA384_Update(SHA512_CTX *c, const void *data, size_t len); | |||
| int SHA384_Final(unsigned char *md, SHA512_CTX *c); | |||
| unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md); | |||
| int SHA512_Init(SHA512_CTX *c); | |||
| int SHA512_Update(SHA512_CTX *c, const void *data, size_t len); | |||
| int SHA512_Final(unsigned char *md, SHA512_CTX *c); | |||
| unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md); | |||
| void SHA512_Transform(SHA512_CTX *c, const unsigned char *data); | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,135 +0,0 @@ | |||
| /* | |||
| * Copyright 2004-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * Copyright (c) 2004, EdelKey Project. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| * | |||
| * Originally written by Christophe Renou and Peter Sylvester, | |||
| * for the EdelKey project. | |||
| */ | |||
| #ifndef HEADER_SRP_H | |||
| # define HEADER_SRP_H | |||
| #include <openssl/opensslconf.h> | |||
| #ifndef OPENSSL_NO_SRP | |||
| # include <stdio.h> | |||
| # include <string.h> | |||
| # include <openssl/safestack.h> | |||
| # include <openssl/bn.h> | |||
| # include <openssl/crypto.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| typedef struct SRP_gN_cache_st { | |||
| char *b64_bn; | |||
| BIGNUM *bn; | |||
| } SRP_gN_cache; | |||
| DEFINE_STACK_OF(SRP_gN_cache) | |||
| typedef struct SRP_user_pwd_st { | |||
| /* Owned by us. */ | |||
| char *id; | |||
| BIGNUM *s; | |||
| BIGNUM *v; | |||
| /* Not owned by us. */ | |||
| const BIGNUM *g; | |||
| const BIGNUM *N; | |||
| /* Owned by us. */ | |||
| char *info; | |||
| } SRP_user_pwd; | |||
| void SRP_user_pwd_free(SRP_user_pwd *user_pwd); | |||
| DEFINE_STACK_OF(SRP_user_pwd) | |||
| typedef struct SRP_VBASE_st { | |||
| STACK_OF(SRP_user_pwd) *users_pwd; | |||
| STACK_OF(SRP_gN_cache) *gN_cache; | |||
| /* to simulate a user */ | |||
| char *seed_key; | |||
| const BIGNUM *default_g; | |||
| const BIGNUM *default_N; | |||
| } SRP_VBASE; | |||
| /* | |||
| * Internal structure storing N and g pair | |||
| */ | |||
| typedef struct SRP_gN_st { | |||
| char *id; | |||
| const BIGNUM *g; | |||
| const BIGNUM *N; | |||
| } SRP_gN; | |||
| DEFINE_STACK_OF(SRP_gN) | |||
| SRP_VBASE *SRP_VBASE_new(char *seed_key); | |||
| void SRP_VBASE_free(SRP_VBASE *vb); | |||
| int SRP_VBASE_init(SRP_VBASE *vb, char *verifier_file); | |||
| /* This method ignores the configured seed and fails for an unknown user. */ | |||
| DEPRECATEDIN_1_1_0(SRP_user_pwd *SRP_VBASE_get_by_user(SRP_VBASE *vb, char *username)) | |||
| /* NOTE: unlike in SRP_VBASE_get_by_user, caller owns the returned pointer.*/ | |||
| SRP_user_pwd *SRP_VBASE_get1_by_user(SRP_VBASE *vb, char *username); | |||
| char *SRP_create_verifier(const char *user, const char *pass, char **salt, | |||
| char **verifier, const char *N, const char *g); | |||
| int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt, | |||
| BIGNUM **verifier, const BIGNUM *N, | |||
| const BIGNUM *g); | |||
| # define SRP_NO_ERROR 0 | |||
| # define SRP_ERR_VBASE_INCOMPLETE_FILE 1 | |||
| # define SRP_ERR_VBASE_BN_LIB 2 | |||
| # define SRP_ERR_OPEN_FILE 3 | |||
| # define SRP_ERR_MEMORY 4 | |||
| # define DB_srptype 0 | |||
| # define DB_srpverifier 1 | |||
| # define DB_srpsalt 2 | |||
| # define DB_srpid 3 | |||
| # define DB_srpgN 4 | |||
| # define DB_srpinfo 5 | |||
| # undef DB_NUMBER | |||
| # define DB_NUMBER 6 | |||
| # define DB_SRP_INDEX 'I' | |||
| # define DB_SRP_VALID 'V' | |||
| # define DB_SRP_REVOKED 'R' | |||
| # define DB_SRP_MODIF 'v' | |||
| /* see srp.c */ | |||
| char *SRP_check_known_gN_param(const BIGNUM *g, const BIGNUM *N); | |||
| SRP_gN *SRP_get_default_gN(const char *id); | |||
| /* server side .... */ | |||
| BIGNUM *SRP_Calc_server_key(const BIGNUM *A, const BIGNUM *v, const BIGNUM *u, | |||
| const BIGNUM *b, const BIGNUM *N); | |||
| BIGNUM *SRP_Calc_B(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g, | |||
| const BIGNUM *v); | |||
| int SRP_Verify_A_mod_N(const BIGNUM *A, const BIGNUM *N); | |||
| BIGNUM *SRP_Calc_u(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N); | |||
| /* client side .... */ | |||
| BIGNUM *SRP_Calc_x(const BIGNUM *s, const char *user, const char *pass); | |||
| BIGNUM *SRP_Calc_A(const BIGNUM *a, const BIGNUM *N, const BIGNUM *g); | |||
| BIGNUM *SRP_Calc_client_key(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g, | |||
| const BIGNUM *x, const BIGNUM *a, const BIGNUM *u); | |||
| int SRP_Verify_B_mod_N(const BIGNUM *B, const BIGNUM *N); | |||
| # define SRP_MINIMAL_N 1024 | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| # endif | |||
| #endif | |||
| @ -1,50 +0,0 @@ | |||
| /* | |||
| * Copyright 2011-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| /* | |||
| * DTLS code by Eric Rescorla <ekr@rtfm.com> | |||
| * | |||
| * Copyright (C) 2006, Network Resonance, Inc. Copyright (C) 2011, RTFM, Inc. | |||
| */ | |||
| #ifndef HEADER_D1_SRTP_H | |||
| # define HEADER_D1_SRTP_H | |||
| # include <openssl/ssl.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # define SRTP_AES128_CM_SHA1_80 0x0001 | |||
| # define SRTP_AES128_CM_SHA1_32 0x0002 | |||
| # define SRTP_AES128_F8_SHA1_80 0x0003 | |||
| # define SRTP_AES128_F8_SHA1_32 0x0004 | |||
| # define SRTP_NULL_SHA1_80 0x0005 | |||
| # define SRTP_NULL_SHA1_32 0x0006 | |||
| /* AEAD SRTP protection profiles from RFC 7714 */ | |||
| # define SRTP_AEAD_AES_128_GCM 0x0007 | |||
| # define SRTP_AEAD_AES_256_GCM 0x0008 | |||
| # ifndef OPENSSL_NO_SRTP | |||
| __owur int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles); | |||
| __owur int SSL_set_tlsext_use_srtp(SSL *ssl, const char *profiles); | |||
| __owur STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *ssl); | |||
| __owur SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s); | |||
| # endif | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,24 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_SSL2_H | |||
| # define HEADER_SSL2_H | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| # define SSL2_VERSION 0x0002 | |||
| # define SSL2_MT_CLIENT_HELLO 1 | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,342 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_SSL3_H | |||
| # define HEADER_SSL3_H | |||
| # include <openssl/comp.h> | |||
| # include <openssl/buffer.h> | |||
| # include <openssl/evp.h> | |||
| # include <openssl/ssl.h> | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| /* | |||
| * Signalling cipher suite value from RFC 5746 | |||
| * (TLS_EMPTY_RENEGOTIATION_INFO_SCSV) | |||
| */ | |||
| # define SSL3_CK_SCSV 0x030000FF | |||
| /* | |||
| * Signalling cipher suite value from draft-ietf-tls-downgrade-scsv-00 | |||
| * (TLS_FALLBACK_SCSV) | |||
| */ | |||
| # define SSL3_CK_FALLBACK_SCSV 0x03005600 | |||
| # define SSL3_CK_RSA_NULL_MD5 0x03000001 | |||
| # define SSL3_CK_RSA_NULL_SHA 0x03000002 | |||
| # define SSL3_CK_RSA_RC4_40_MD5 0x03000003 | |||
| # define SSL3_CK_RSA_RC4_128_MD5 0x03000004 | |||
| # define SSL3_CK_RSA_RC4_128_SHA 0x03000005 | |||
| # define SSL3_CK_RSA_RC2_40_MD5 0x03000006 | |||
| # define SSL3_CK_RSA_IDEA_128_SHA 0x03000007 | |||
| # define SSL3_CK_RSA_DES_40_CBC_SHA 0x03000008 | |||
| # define SSL3_CK_RSA_DES_64_CBC_SHA 0x03000009 | |||
| # define SSL3_CK_RSA_DES_192_CBC3_SHA 0x0300000A | |||
| # define SSL3_CK_DH_DSS_DES_40_CBC_SHA 0x0300000B | |||
| # define SSL3_CK_DH_DSS_DES_64_CBC_SHA 0x0300000C | |||
| # define SSL3_CK_DH_DSS_DES_192_CBC3_SHA 0x0300000D | |||
| # define SSL3_CK_DH_RSA_DES_40_CBC_SHA 0x0300000E | |||
| # define SSL3_CK_DH_RSA_DES_64_CBC_SHA 0x0300000F | |||
| # define SSL3_CK_DH_RSA_DES_192_CBC3_SHA 0x03000010 | |||
| # define SSL3_CK_DHE_DSS_DES_40_CBC_SHA 0x03000011 | |||
| # define SSL3_CK_EDH_DSS_DES_40_CBC_SHA SSL3_CK_DHE_DSS_DES_40_CBC_SHA | |||
| # define SSL3_CK_DHE_DSS_DES_64_CBC_SHA 0x03000012 | |||
| # define SSL3_CK_EDH_DSS_DES_64_CBC_SHA SSL3_CK_DHE_DSS_DES_64_CBC_SHA | |||
| # define SSL3_CK_DHE_DSS_DES_192_CBC3_SHA 0x03000013 | |||
| # define SSL3_CK_EDH_DSS_DES_192_CBC3_SHA SSL3_CK_DHE_DSS_DES_192_CBC3_SHA | |||
| # define SSL3_CK_DHE_RSA_DES_40_CBC_SHA 0x03000014 | |||
| # define SSL3_CK_EDH_RSA_DES_40_CBC_SHA SSL3_CK_DHE_RSA_DES_40_CBC_SHA | |||
| # define SSL3_CK_DHE_RSA_DES_64_CBC_SHA 0x03000015 | |||
| # define SSL3_CK_EDH_RSA_DES_64_CBC_SHA SSL3_CK_DHE_RSA_DES_64_CBC_SHA | |||
| # define SSL3_CK_DHE_RSA_DES_192_CBC3_SHA 0x03000016 | |||
| # define SSL3_CK_EDH_RSA_DES_192_CBC3_SHA SSL3_CK_DHE_RSA_DES_192_CBC3_SHA | |||
| # define SSL3_CK_ADH_RC4_40_MD5 0x03000017 | |||
| # define SSL3_CK_ADH_RC4_128_MD5 0x03000018 | |||
| # define SSL3_CK_ADH_DES_40_CBC_SHA 0x03000019 | |||
| # define SSL3_CK_ADH_DES_64_CBC_SHA 0x0300001A | |||
| # define SSL3_CK_ADH_DES_192_CBC_SHA 0x0300001B | |||
| /* a bundle of RFC standard cipher names, generated from ssl3_ciphers[] */ | |||
| # define SSL3_RFC_RSA_NULL_MD5 "TLS_RSA_WITH_NULL_MD5" | |||
| # define SSL3_RFC_RSA_NULL_SHA "TLS_RSA_WITH_NULL_SHA" | |||
| # define SSL3_RFC_RSA_DES_192_CBC3_SHA "TLS_RSA_WITH_3DES_EDE_CBC_SHA" | |||
| # define SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA" | |||
| # define SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA" | |||
| # define SSL3_RFC_ADH_DES_192_CBC_SHA "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA" | |||
| # define SSL3_RFC_RSA_IDEA_128_SHA "TLS_RSA_WITH_IDEA_CBC_SHA" | |||
| # define SSL3_RFC_RSA_RC4_128_MD5 "TLS_RSA_WITH_RC4_128_MD5" | |||
| # define SSL3_RFC_RSA_RC4_128_SHA "TLS_RSA_WITH_RC4_128_SHA" | |||
| # define SSL3_RFC_ADH_RC4_128_MD5 "TLS_DH_anon_WITH_RC4_128_MD5" | |||
| # define SSL3_TXT_RSA_NULL_MD5 "NULL-MD5" | |||
| # define SSL3_TXT_RSA_NULL_SHA "NULL-SHA" | |||
| # define SSL3_TXT_RSA_RC4_40_MD5 "EXP-RC4-MD5" | |||
| # define SSL3_TXT_RSA_RC4_128_MD5 "RC4-MD5" | |||
| # define SSL3_TXT_RSA_RC4_128_SHA "RC4-SHA" | |||
| # define SSL3_TXT_RSA_RC2_40_MD5 "EXP-RC2-CBC-MD5" | |||
| # define SSL3_TXT_RSA_IDEA_128_SHA "IDEA-CBC-SHA" | |||
| # define SSL3_TXT_RSA_DES_40_CBC_SHA "EXP-DES-CBC-SHA" | |||
| # define SSL3_TXT_RSA_DES_64_CBC_SHA "DES-CBC-SHA" | |||
| # define SSL3_TXT_RSA_DES_192_CBC3_SHA "DES-CBC3-SHA" | |||
| # define SSL3_TXT_DH_DSS_DES_40_CBC_SHA "EXP-DH-DSS-DES-CBC-SHA" | |||
| # define SSL3_TXT_DH_DSS_DES_64_CBC_SHA "DH-DSS-DES-CBC-SHA" | |||
| # define SSL3_TXT_DH_DSS_DES_192_CBC3_SHA "DH-DSS-DES-CBC3-SHA" | |||
| # define SSL3_TXT_DH_RSA_DES_40_CBC_SHA "EXP-DH-RSA-DES-CBC-SHA" | |||
| # define SSL3_TXT_DH_RSA_DES_64_CBC_SHA "DH-RSA-DES-CBC-SHA" | |||
| # define SSL3_TXT_DH_RSA_DES_192_CBC3_SHA "DH-RSA-DES-CBC3-SHA" | |||
| # define SSL3_TXT_DHE_DSS_DES_40_CBC_SHA "EXP-DHE-DSS-DES-CBC-SHA" | |||
| # define SSL3_TXT_DHE_DSS_DES_64_CBC_SHA "DHE-DSS-DES-CBC-SHA" | |||
| # define SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA "DHE-DSS-DES-CBC3-SHA" | |||
| # define SSL3_TXT_DHE_RSA_DES_40_CBC_SHA "EXP-DHE-RSA-DES-CBC-SHA" | |||
| # define SSL3_TXT_DHE_RSA_DES_64_CBC_SHA "DHE-RSA-DES-CBC-SHA" | |||
| # define SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA "DHE-RSA-DES-CBC3-SHA" | |||
| /* | |||
| * This next block of six "EDH" labels is for backward compatibility with | |||
| * older versions of OpenSSL. New code should use the six "DHE" labels above | |||
| * instead: | |||
| */ | |||
| # define SSL3_TXT_EDH_DSS_DES_40_CBC_SHA "EXP-EDH-DSS-DES-CBC-SHA" | |||
| # define SSL3_TXT_EDH_DSS_DES_64_CBC_SHA "EDH-DSS-DES-CBC-SHA" | |||
| # define SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA "EDH-DSS-DES-CBC3-SHA" | |||
| # define SSL3_TXT_EDH_RSA_DES_40_CBC_SHA "EXP-EDH-RSA-DES-CBC-SHA" | |||
| # define SSL3_TXT_EDH_RSA_DES_64_CBC_SHA "EDH-RSA-DES-CBC-SHA" | |||
| # define SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA "EDH-RSA-DES-CBC3-SHA" | |||
| # define SSL3_TXT_ADH_RC4_40_MD5 "EXP-ADH-RC4-MD5" | |||
| # define SSL3_TXT_ADH_RC4_128_MD5 "ADH-RC4-MD5" | |||
| # define SSL3_TXT_ADH_DES_40_CBC_SHA "EXP-ADH-DES-CBC-SHA" | |||
| # define SSL3_TXT_ADH_DES_64_CBC_SHA "ADH-DES-CBC-SHA" | |||
| # define SSL3_TXT_ADH_DES_192_CBC_SHA "ADH-DES-CBC3-SHA" | |||
| # define SSL3_SSL_SESSION_ID_LENGTH 32 | |||
| # define SSL3_MAX_SSL_SESSION_ID_LENGTH 32 | |||
| # define SSL3_MASTER_SECRET_SIZE 48 | |||
| # define SSL3_RANDOM_SIZE 32 | |||
| # define SSL3_SESSION_ID_SIZE 32 | |||
| # define SSL3_RT_HEADER_LENGTH 5 | |||
| # define SSL3_HM_HEADER_LENGTH 4 | |||
| # ifndef SSL3_ALIGN_PAYLOAD | |||
| /* | |||
| * Some will argue that this increases memory footprint, but it's not | |||
| * actually true. Point is that malloc has to return at least 64-bit aligned | |||
| * pointers, meaning that allocating 5 bytes wastes 3 bytes in either case. | |||
| * Suggested pre-gaping simply moves these wasted bytes from the end of | |||
| * allocated region to its front, but makes data payload aligned, which | |||
| * improves performance:-) | |||
| */ | |||
| # define SSL3_ALIGN_PAYLOAD 8 | |||
| # else | |||
| # if (SSL3_ALIGN_PAYLOAD&(SSL3_ALIGN_PAYLOAD-1))!=0 | |||
| # error "insane SSL3_ALIGN_PAYLOAD" | |||
| # undef SSL3_ALIGN_PAYLOAD | |||
| # endif | |||
| # endif | |||
| /* | |||
| * This is the maximum MAC (digest) size used by the SSL library. Currently | |||
| * maximum of 20 is used by SHA1, but we reserve for future extension for | |||
| * 512-bit hashes. | |||
| */ | |||
| # define SSL3_RT_MAX_MD_SIZE 64 | |||
| /* | |||
| * Maximum block size used in all ciphersuites. Currently 16 for AES. | |||
| */ | |||
| # define SSL_RT_MAX_CIPHER_BLOCK_SIZE 16 | |||
| # define SSL3_RT_MAX_EXTRA (16384) | |||
| /* Maximum plaintext length: defined by SSL/TLS standards */ | |||
| # define SSL3_RT_MAX_PLAIN_LENGTH 16384 | |||
| /* Maximum compression overhead: defined by SSL/TLS standards */ | |||
| # define SSL3_RT_MAX_COMPRESSED_OVERHEAD 1024 | |||
| /* | |||
| * The standards give a maximum encryption overhead of 1024 bytes. In | |||
| * practice the value is lower than this. The overhead is the maximum number | |||
| * of padding bytes (256) plus the mac size. | |||
| */ | |||
| # define SSL3_RT_MAX_ENCRYPTED_OVERHEAD (256 + SSL3_RT_MAX_MD_SIZE) | |||
| # define SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD 256 | |||
| /* | |||
| * OpenSSL currently only uses a padding length of at most one block so the | |||
| * send overhead is smaller. | |||
| */ | |||
| # define SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ | |||
| (SSL_RT_MAX_CIPHER_BLOCK_SIZE + SSL3_RT_MAX_MD_SIZE) | |||
| /* If compression isn't used don't include the compression overhead */ | |||
| # ifdef OPENSSL_NO_COMP | |||
| # define SSL3_RT_MAX_COMPRESSED_LENGTH SSL3_RT_MAX_PLAIN_LENGTH | |||
| # else | |||
| # define SSL3_RT_MAX_COMPRESSED_LENGTH \ | |||
| (SSL3_RT_MAX_PLAIN_LENGTH+SSL3_RT_MAX_COMPRESSED_OVERHEAD) | |||
| # endif | |||
| # define SSL3_RT_MAX_ENCRYPTED_LENGTH \ | |||
| (SSL3_RT_MAX_ENCRYPTED_OVERHEAD+SSL3_RT_MAX_COMPRESSED_LENGTH) | |||
| # define SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH \ | |||
| (SSL3_RT_MAX_PLAIN_LENGTH + SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD) | |||
| # define SSL3_RT_MAX_PACKET_SIZE \ | |||
| (SSL3_RT_MAX_ENCRYPTED_LENGTH+SSL3_RT_HEADER_LENGTH) | |||
| # define SSL3_MD_CLIENT_FINISHED_CONST "\x43\x4C\x4E\x54" | |||
| # define SSL3_MD_SERVER_FINISHED_CONST "\x53\x52\x56\x52" | |||
| # define SSL3_VERSION 0x0300 | |||
| # define SSL3_VERSION_MAJOR 0x03 | |||
| # define SSL3_VERSION_MINOR 0x00 | |||
| # define SSL3_RT_CHANGE_CIPHER_SPEC 20 | |||
| # define SSL3_RT_ALERT 21 | |||
| # define SSL3_RT_HANDSHAKE 22 | |||
| # define SSL3_RT_APPLICATION_DATA 23 | |||
| # define DTLS1_RT_HEARTBEAT 24 | |||
| /* Pseudo content types to indicate additional parameters */ | |||
| # define TLS1_RT_CRYPTO 0x1000 | |||
| # define TLS1_RT_CRYPTO_PREMASTER (TLS1_RT_CRYPTO | 0x1) | |||
| # define TLS1_RT_CRYPTO_CLIENT_RANDOM (TLS1_RT_CRYPTO | 0x2) | |||
| # define TLS1_RT_CRYPTO_SERVER_RANDOM (TLS1_RT_CRYPTO | 0x3) | |||
| # define TLS1_RT_CRYPTO_MASTER (TLS1_RT_CRYPTO | 0x4) | |||
| # define TLS1_RT_CRYPTO_READ 0x0000 | |||
| # define TLS1_RT_CRYPTO_WRITE 0x0100 | |||
| # define TLS1_RT_CRYPTO_MAC (TLS1_RT_CRYPTO | 0x5) | |||
| # define TLS1_RT_CRYPTO_KEY (TLS1_RT_CRYPTO | 0x6) | |||
| # define TLS1_RT_CRYPTO_IV (TLS1_RT_CRYPTO | 0x7) | |||
| # define TLS1_RT_CRYPTO_FIXED_IV (TLS1_RT_CRYPTO | 0x8) | |||
| /* Pseudo content types for SSL/TLS header info */ | |||
| # define SSL3_RT_HEADER 0x100 | |||
| # define SSL3_RT_INNER_CONTENT_TYPE 0x101 | |||
| # define SSL3_AL_WARNING 1 | |||
| # define SSL3_AL_FATAL 2 | |||
| # define SSL3_AD_CLOSE_NOTIFY 0 | |||
| # define SSL3_AD_UNEXPECTED_MESSAGE 10/* fatal */ | |||
| # define SSL3_AD_BAD_RECORD_MAC 20/* fatal */ | |||
| # define SSL3_AD_DECOMPRESSION_FAILURE 30/* fatal */ | |||
| # define SSL3_AD_HANDSHAKE_FAILURE 40/* fatal */ | |||
| # define SSL3_AD_NO_CERTIFICATE 41 | |||
| # define SSL3_AD_BAD_CERTIFICATE 42 | |||
| # define SSL3_AD_UNSUPPORTED_CERTIFICATE 43 | |||
| # define SSL3_AD_CERTIFICATE_REVOKED 44 | |||
| # define SSL3_AD_CERTIFICATE_EXPIRED 45 | |||
| # define SSL3_AD_CERTIFICATE_UNKNOWN 46 | |||
| # define SSL3_AD_ILLEGAL_PARAMETER 47/* fatal */ | |||
| # define TLS1_HB_REQUEST 1 | |||
| # define TLS1_HB_RESPONSE 2 | |||
| # define SSL3_CT_RSA_SIGN 1 | |||
| # define SSL3_CT_DSS_SIGN 2 | |||
| # define SSL3_CT_RSA_FIXED_DH 3 | |||
| # define SSL3_CT_DSS_FIXED_DH 4 | |||
| # define SSL3_CT_RSA_EPHEMERAL_DH 5 | |||
| # define SSL3_CT_DSS_EPHEMERAL_DH 6 | |||
| # define SSL3_CT_FORTEZZA_DMS 20 | |||
| /* | |||
| * SSL3_CT_NUMBER is used to size arrays and it must be large enough to | |||
| * contain all of the cert types defined for *either* SSLv3 and TLSv1. | |||
| */ | |||
| # define SSL3_CT_NUMBER 10 | |||
| # if defined(TLS_CT_NUMBER) | |||
| # if TLS_CT_NUMBER != SSL3_CT_NUMBER | |||
| # error "SSL/TLS CT_NUMBER values do not match" | |||
| # endif | |||
| # endif | |||
| /* No longer used as of OpenSSL 1.1.1 */ | |||
| # define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS 0x0001 | |||
| /* Removed from OpenSSL 1.1.0 */ | |||
| # define TLS1_FLAGS_TLS_PADDING_BUG 0x0 | |||
| # define TLS1_FLAGS_SKIP_CERT_VERIFY 0x0010 | |||
| /* Set if we encrypt then mac instead of usual mac then encrypt */ | |||
| # define TLS1_FLAGS_ENCRYPT_THEN_MAC_READ 0x0100 | |||
| # define TLS1_FLAGS_ENCRYPT_THEN_MAC TLS1_FLAGS_ENCRYPT_THEN_MAC_READ | |||
| /* Set if extended master secret extension received from peer */ | |||
| # define TLS1_FLAGS_RECEIVED_EXTMS 0x0200 | |||
| # define TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE 0x0400 | |||
| # define TLS1_FLAGS_STATELESS 0x0800 | |||
| /* Set if extended master secret extension required on renegotiation */ | |||
| # define TLS1_FLAGS_REQUIRED_EXTMS 0x1000 | |||
| # define SSL3_MT_HELLO_REQUEST 0 | |||
| # define SSL3_MT_CLIENT_HELLO 1 | |||
| # define SSL3_MT_SERVER_HELLO 2 | |||
| # define SSL3_MT_NEWSESSION_TICKET 4 | |||
| # define SSL3_MT_END_OF_EARLY_DATA 5 | |||
| # define SSL3_MT_ENCRYPTED_EXTENSIONS 8 | |||
| # define SSL3_MT_CERTIFICATE 11 | |||
| # define SSL3_MT_SERVER_KEY_EXCHANGE 12 | |||
| # define SSL3_MT_CERTIFICATE_REQUEST 13 | |||
| # define SSL3_MT_SERVER_DONE 14 | |||
| # define SSL3_MT_CERTIFICATE_VERIFY 15 | |||
| # define SSL3_MT_CLIENT_KEY_EXCHANGE 16 | |||
| # define SSL3_MT_FINISHED 20 | |||
| # define SSL3_MT_CERTIFICATE_URL 21 | |||
| # define SSL3_MT_CERTIFICATE_STATUS 22 | |||
| # define SSL3_MT_SUPPLEMENTAL_DATA 23 | |||
| # define SSL3_MT_KEY_UPDATE 24 | |||
| # ifndef OPENSSL_NO_NEXTPROTONEG | |||
| # define SSL3_MT_NEXT_PROTO 67 | |||
| # endif | |||
| # define SSL3_MT_MESSAGE_HASH 254 | |||
| # define DTLS1_MT_HELLO_VERIFY_REQUEST 3 | |||
| /* Dummy message type for handling CCS like a normal handshake message */ | |||
| # define SSL3_MT_CHANGE_CIPHER_SPEC 0x0101 | |||
| # define SSL3_MT_CCS 1 | |||
| /* These are used when changing over to a new cipher */ | |||
| # define SSL3_CC_READ 0x001 | |||
| # define SSL3_CC_WRITE 0x002 | |||
| # define SSL3_CC_CLIENT 0x010 | |||
| # define SSL3_CC_SERVER 0x020 | |||
| # define SSL3_CC_EARLY 0x040 | |||
| # define SSL3_CC_HANDSHAKE 0x080 | |||
| # define SSL3_CC_APPLICATION 0x100 | |||
| # define SSL3_CHANGE_CIPHER_CLIENT_WRITE (SSL3_CC_CLIENT|SSL3_CC_WRITE) | |||
| # define SSL3_CHANGE_CIPHER_SERVER_READ (SSL3_CC_SERVER|SSL3_CC_READ) | |||
| # define SSL3_CHANGE_CIPHER_CLIENT_READ (SSL3_CC_CLIENT|SSL3_CC_READ) | |||
| # define SSL3_CHANGE_CIPHER_SERVER_WRITE (SSL3_CC_SERVER|SSL3_CC_WRITE) | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,773 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_SSLERR_H | |||
| # define HEADER_SSLERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_SSL_strings(void); | |||
| /* | |||
| * SSL function codes. | |||
| */ | |||
| # define SSL_F_ADD_CLIENT_KEY_SHARE_EXT 438 | |||
| # define SSL_F_ADD_KEY_SHARE 512 | |||
| # define SSL_F_BYTES_TO_CIPHER_LIST 519 | |||
| # define SSL_F_CHECK_SUITEB_CIPHER_LIST 331 | |||
| # define SSL_F_CIPHERSUITE_CB 622 | |||
| # define SSL_F_CONSTRUCT_CA_NAMES 552 | |||
| # define SSL_F_CONSTRUCT_KEY_EXCHANGE_TBS 553 | |||
| # define SSL_F_CONSTRUCT_STATEFUL_TICKET 636 | |||
| # define SSL_F_CONSTRUCT_STATELESS_TICKET 637 | |||
| # define SSL_F_CREATE_SYNTHETIC_MESSAGE_HASH 539 | |||
| # define SSL_F_CREATE_TICKET_PREQUEL 638 | |||
| # define SSL_F_CT_MOVE_SCTS 345 | |||
| # define SSL_F_CT_STRICT 349 | |||
| # define SSL_F_CUSTOM_EXT_ADD 554 | |||
| # define SSL_F_CUSTOM_EXT_PARSE 555 | |||
| # define SSL_F_D2I_SSL_SESSION 103 | |||
| # define SSL_F_DANE_CTX_ENABLE 347 | |||
| # define SSL_F_DANE_MTYPE_SET 393 | |||
| # define SSL_F_DANE_TLSA_ADD 394 | |||
| # define SSL_F_DERIVE_SECRET_KEY_AND_IV 514 | |||
| # define SSL_F_DO_DTLS1_WRITE 245 | |||
| # define SSL_F_DO_SSL3_WRITE 104 | |||
| # define SSL_F_DTLS1_BUFFER_RECORD 247 | |||
| # define SSL_F_DTLS1_CHECK_TIMEOUT_NUM 318 | |||
| # define SSL_F_DTLS1_HEARTBEAT 305 | |||
| # define SSL_F_DTLS1_HM_FRAGMENT_NEW 623 | |||
| # define SSL_F_DTLS1_PREPROCESS_FRAGMENT 288 | |||
| # define SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS 424 | |||
| # define SSL_F_DTLS1_PROCESS_RECORD 257 | |||
| # define SSL_F_DTLS1_READ_BYTES 258 | |||
| # define SSL_F_DTLS1_READ_FAILED 339 | |||
| # define SSL_F_DTLS1_RETRANSMIT_MESSAGE 390 | |||
| # define SSL_F_DTLS1_WRITE_APP_DATA_BYTES 268 | |||
| # define SSL_F_DTLS1_WRITE_BYTES 545 | |||
| # define SSL_F_DTLSV1_LISTEN 350 | |||
| # define SSL_F_DTLS_CONSTRUCT_CHANGE_CIPHER_SPEC 371 | |||
| # define SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST 385 | |||
| # define SSL_F_DTLS_GET_REASSEMBLED_MESSAGE 370 | |||
| # define SSL_F_DTLS_PROCESS_HELLO_VERIFY 386 | |||
| # define SSL_F_DTLS_RECORD_LAYER_NEW 635 | |||
| # define SSL_F_DTLS_WAIT_FOR_DRY 592 | |||
| # define SSL_F_EARLY_DATA_COUNT_OK 532 | |||
| # define SSL_F_FINAL_EARLY_DATA 556 | |||
| # define SSL_F_FINAL_EC_PT_FORMATS 485 | |||
| # define SSL_F_FINAL_EMS 486 | |||
| # define SSL_F_FINAL_KEY_SHARE 503 | |||
| # define SSL_F_FINAL_MAXFRAGMENTLEN 557 | |||
| # define SSL_F_FINAL_RENEGOTIATE 483 | |||
| # define SSL_F_FINAL_SERVER_NAME 558 | |||
| # define SSL_F_FINAL_SIG_ALGS 497 | |||
| # define SSL_F_GET_CERT_VERIFY_TBS_DATA 588 | |||
| # define SSL_F_NSS_KEYLOG_INT 500 | |||
| # define SSL_F_OPENSSL_INIT_SSL 342 | |||
| # define SSL_F_OSSL_STATEM_CLIENT13_READ_TRANSITION 436 | |||
| # define SSL_F_OSSL_STATEM_CLIENT13_WRITE_TRANSITION 598 | |||
| # define SSL_F_OSSL_STATEM_CLIENT_CONSTRUCT_MESSAGE 430 | |||
| # define SSL_F_OSSL_STATEM_CLIENT_POST_PROCESS_MESSAGE 593 | |||
| # define SSL_F_OSSL_STATEM_CLIENT_PROCESS_MESSAGE 594 | |||
| # define SSL_F_OSSL_STATEM_CLIENT_READ_TRANSITION 417 | |||
| # define SSL_F_OSSL_STATEM_CLIENT_WRITE_TRANSITION 599 | |||
| # define SSL_F_OSSL_STATEM_SERVER13_READ_TRANSITION 437 | |||
| # define SSL_F_OSSL_STATEM_SERVER13_WRITE_TRANSITION 600 | |||
| # define SSL_F_OSSL_STATEM_SERVER_CONSTRUCT_MESSAGE 431 | |||
| # define SSL_F_OSSL_STATEM_SERVER_POST_PROCESS_MESSAGE 601 | |||
| # define SSL_F_OSSL_STATEM_SERVER_POST_WORK 602 | |||
| # define SSL_F_OSSL_STATEM_SERVER_PRE_WORK 640 | |||
| # define SSL_F_OSSL_STATEM_SERVER_PROCESS_MESSAGE 603 | |||
| # define SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION 418 | |||
| # define SSL_F_OSSL_STATEM_SERVER_WRITE_TRANSITION 604 | |||
| # define SSL_F_PARSE_CA_NAMES 541 | |||
| # define SSL_F_PITEM_NEW 624 | |||
| # define SSL_F_PQUEUE_NEW 625 | |||
| # define SSL_F_PROCESS_KEY_SHARE_EXT 439 | |||
| # define SSL_F_READ_STATE_MACHINE 352 | |||
| # define SSL_F_SET_CLIENT_CIPHERSUITE 540 | |||
| # define SSL_F_SRP_GENERATE_CLIENT_MASTER_SECRET 595 | |||
| # define SSL_F_SRP_GENERATE_SERVER_MASTER_SECRET 589 | |||
| # define SSL_F_SRP_VERIFY_SERVER_PARAM 596 | |||
| # define SSL_F_SSL3_CHANGE_CIPHER_STATE 129 | |||
| # define SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM 130 | |||
| # define SSL_F_SSL3_CTRL 213 | |||
| # define SSL_F_SSL3_CTX_CTRL 133 | |||
| # define SSL_F_SSL3_DIGEST_CACHED_RECORDS 293 | |||
| # define SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC 292 | |||
| # define SSL_F_SSL3_ENC 608 | |||
| # define SSL_F_SSL3_FINAL_FINISH_MAC 285 | |||
| # define SSL_F_SSL3_FINISH_MAC 587 | |||
| # define SSL_F_SSL3_GENERATE_KEY_BLOCK 238 | |||
| # define SSL_F_SSL3_GENERATE_MASTER_SECRET 388 | |||
| # define SSL_F_SSL3_GET_RECORD 143 | |||
| # define SSL_F_SSL3_INIT_FINISHED_MAC 397 | |||
| # define SSL_F_SSL3_OUTPUT_CERT_CHAIN 147 | |||
| # define SSL_F_SSL3_READ_BYTES 148 | |||
| # define SSL_F_SSL3_READ_N 149 | |||
| # define SSL_F_SSL3_SETUP_KEY_BLOCK 157 | |||
| # define SSL_F_SSL3_SETUP_READ_BUFFER 156 | |||
| # define SSL_F_SSL3_SETUP_WRITE_BUFFER 291 | |||
| # define SSL_F_SSL3_WRITE_BYTES 158 | |||
| # define SSL_F_SSL3_WRITE_PENDING 159 | |||
| # define SSL_F_SSL_ADD_CERT_CHAIN 316 | |||
| # define SSL_F_SSL_ADD_CERT_TO_BUF 319 | |||
| # define SSL_F_SSL_ADD_CERT_TO_WPACKET 493 | |||
| # define SSL_F_SSL_ADD_CLIENTHELLO_RENEGOTIATE_EXT 298 | |||
| # define SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT 277 | |||
| # define SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT 307 | |||
| # define SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK 215 | |||
| # define SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK 216 | |||
| # define SSL_F_SSL_ADD_SERVERHELLO_RENEGOTIATE_EXT 299 | |||
| # define SSL_F_SSL_ADD_SERVERHELLO_TLSEXT 278 | |||
| # define SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT 308 | |||
| # define SSL_F_SSL_BAD_METHOD 160 | |||
| # define SSL_F_SSL_BUILD_CERT_CHAIN 332 | |||
| # define SSL_F_SSL_BYTES_TO_CIPHER_LIST 161 | |||
| # define SSL_F_SSL_CACHE_CIPHERLIST 520 | |||
| # define SSL_F_SSL_CERT_ADD0_CHAIN_CERT 346 | |||
| # define SSL_F_SSL_CERT_DUP 221 | |||
| # define SSL_F_SSL_CERT_NEW 162 | |||
| # define SSL_F_SSL_CERT_SET0_CHAIN 340 | |||
| # define SSL_F_SSL_CHECK_PRIVATE_KEY 163 | |||
| # define SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT 280 | |||
| # define SSL_F_SSL_CHECK_SRP_EXT_CLIENTHELLO 606 | |||
| # define SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG 279 | |||
| # define SSL_F_SSL_CHOOSE_CLIENT_VERSION 607 | |||
| # define SSL_F_SSL_CIPHER_DESCRIPTION 626 | |||
| # define SSL_F_SSL_CIPHER_LIST_TO_BYTES 425 | |||
| # define SSL_F_SSL_CIPHER_PROCESS_RULESTR 230 | |||
| # define SSL_F_SSL_CIPHER_STRENGTH_SORT 231 | |||
| # define SSL_F_SSL_CLEAR 164 | |||
| # define SSL_F_SSL_CLIENT_HELLO_GET1_EXTENSIONS_PRESENT 627 | |||
| # define SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD 165 | |||
| # define SSL_F_SSL_CONF_CMD 334 | |||
| # define SSL_F_SSL_CREATE_CIPHER_LIST 166 | |||
| # define SSL_F_SSL_CTRL 232 | |||
| # define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY 168 | |||
| # define SSL_F_SSL_CTX_ENABLE_CT 398 | |||
| # define SSL_F_SSL_CTX_MAKE_PROFILES 309 | |||
| # define SSL_F_SSL_CTX_NEW 169 | |||
| # define SSL_F_SSL_CTX_SET_ALPN_PROTOS 343 | |||
| # define SSL_F_SSL_CTX_SET_CIPHER_LIST 269 | |||
| # define SSL_F_SSL_CTX_SET_CLIENT_CERT_ENGINE 290 | |||
| # define SSL_F_SSL_CTX_SET_CT_VALIDATION_CALLBACK 396 | |||
| # define SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT 219 | |||
| # define SSL_F_SSL_CTX_SET_SSL_VERSION 170 | |||
| # define SSL_F_SSL_CTX_SET_TLSEXT_MAX_FRAGMENT_LENGTH 551 | |||
| # define SSL_F_SSL_CTX_USE_CERTIFICATE 171 | |||
| # define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1 172 | |||
| # define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE 173 | |||
| # define SSL_F_SSL_CTX_USE_PRIVATEKEY 174 | |||
| # define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1 175 | |||
| # define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE 176 | |||
| # define SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT 272 | |||
| # define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY 177 | |||
| # define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1 178 | |||
| # define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE 179 | |||
| # define SSL_F_SSL_CTX_USE_SERVERINFO 336 | |||
| # define SSL_F_SSL_CTX_USE_SERVERINFO_EX 543 | |||
| # define SSL_F_SSL_CTX_USE_SERVERINFO_FILE 337 | |||
| # define SSL_F_SSL_DANE_DUP 403 | |||
| # define SSL_F_SSL_DANE_ENABLE 395 | |||
| # define SSL_F_SSL_DERIVE 590 | |||
| # define SSL_F_SSL_DO_CONFIG 391 | |||
| # define SSL_F_SSL_DO_HANDSHAKE 180 | |||
| # define SSL_F_SSL_DUP_CA_LIST 408 | |||
| # define SSL_F_SSL_ENABLE_CT 402 | |||
| # define SSL_F_SSL_GENERATE_PKEY_GROUP 559 | |||
| # define SSL_F_SSL_GENERATE_SESSION_ID 547 | |||
| # define SSL_F_SSL_GET_NEW_SESSION 181 | |||
| # define SSL_F_SSL_GET_PREV_SESSION 217 | |||
| # define SSL_F_SSL_GET_SERVER_CERT_INDEX 322 | |||
| # define SSL_F_SSL_GET_SIGN_PKEY 183 | |||
| # define SSL_F_SSL_HANDSHAKE_HASH 560 | |||
| # define SSL_F_SSL_INIT_WBIO_BUFFER 184 | |||
| # define SSL_F_SSL_KEY_UPDATE 515 | |||
| # define SSL_F_SSL_LOAD_CLIENT_CA_FILE 185 | |||
| # define SSL_F_SSL_LOG_MASTER_SECRET 498 | |||
| # define SSL_F_SSL_LOG_RSA_CLIENT_KEY_EXCHANGE 499 | |||
| # define SSL_F_SSL_MODULE_INIT 392 | |||
| # define SSL_F_SSL_NEW 186 | |||
| # define SSL_F_SSL_NEXT_PROTO_VALIDATE 565 | |||
| # define SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT 300 | |||
| # define SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT 302 | |||
| # define SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT 310 | |||
| # define SSL_F_SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT 301 | |||
| # define SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT 303 | |||
| # define SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT 311 | |||
| # define SSL_F_SSL_PEEK 270 | |||
| # define SSL_F_SSL_PEEK_EX 432 | |||
| # define SSL_F_SSL_PEEK_INTERNAL 522 | |||
| # define SSL_F_SSL_READ 223 | |||
| # define SSL_F_SSL_READ_EARLY_DATA 529 | |||
| # define SSL_F_SSL_READ_EX 434 | |||
| # define SSL_F_SSL_READ_INTERNAL 523 | |||
| # define SSL_F_SSL_RENEGOTIATE 516 | |||
| # define SSL_F_SSL_RENEGOTIATE_ABBREVIATED 546 | |||
| # define SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT 320 | |||
| # define SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT 321 | |||
| # define SSL_F_SSL_SESSION_DUP 348 | |||
| # define SSL_F_SSL_SESSION_NEW 189 | |||
| # define SSL_F_SSL_SESSION_PRINT_FP 190 | |||
| # define SSL_F_SSL_SESSION_SET1_ID 423 | |||
| # define SSL_F_SSL_SESSION_SET1_ID_CONTEXT 312 | |||
| # define SSL_F_SSL_SET_ALPN_PROTOS 344 | |||
| # define SSL_F_SSL_SET_CERT 191 | |||
| # define SSL_F_SSL_SET_CERT_AND_KEY 621 | |||
| # define SSL_F_SSL_SET_CIPHER_LIST 271 | |||
| # define SSL_F_SSL_SET_CT_VALIDATION_CALLBACK 399 | |||
| # define SSL_F_SSL_SET_FD 192 | |||
| # define SSL_F_SSL_SET_PKEY 193 | |||
| # define SSL_F_SSL_SET_RFD 194 | |||
| # define SSL_F_SSL_SET_SESSION 195 | |||
| # define SSL_F_SSL_SET_SESSION_ID_CONTEXT 218 | |||
| # define SSL_F_SSL_SET_SESSION_TICKET_EXT 294 | |||
| # define SSL_F_SSL_SET_TLSEXT_MAX_FRAGMENT_LENGTH 550 | |||
| # define SSL_F_SSL_SET_WFD 196 | |||
| # define SSL_F_SSL_SHUTDOWN 224 | |||
| # define SSL_F_SSL_SRP_CTX_INIT 313 | |||
| # define SSL_F_SSL_START_ASYNC_JOB 389 | |||
| # define SSL_F_SSL_UNDEFINED_FUNCTION 197 | |||
| # define SSL_F_SSL_UNDEFINED_VOID_FUNCTION 244 | |||
| # define SSL_F_SSL_USE_CERTIFICATE 198 | |||
| # define SSL_F_SSL_USE_CERTIFICATE_ASN1 199 | |||
| # define SSL_F_SSL_USE_CERTIFICATE_FILE 200 | |||
| # define SSL_F_SSL_USE_PRIVATEKEY 201 | |||
| # define SSL_F_SSL_USE_PRIVATEKEY_ASN1 202 | |||
| # define SSL_F_SSL_USE_PRIVATEKEY_FILE 203 | |||
| # define SSL_F_SSL_USE_PSK_IDENTITY_HINT 273 | |||
| # define SSL_F_SSL_USE_RSAPRIVATEKEY 204 | |||
| # define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1 205 | |||
| # define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE 206 | |||
| # define SSL_F_SSL_VALIDATE_CT 400 | |||
| # define SSL_F_SSL_VERIFY_CERT_CHAIN 207 | |||
| # define SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE 616 | |||
| # define SSL_F_SSL_WRITE 208 | |||
| # define SSL_F_SSL_WRITE_EARLY_DATA 526 | |||
| # define SSL_F_SSL_WRITE_EARLY_FINISH 527 | |||
| # define SSL_F_SSL_WRITE_EX 433 | |||
| # define SSL_F_SSL_WRITE_INTERNAL 524 | |||
| # define SSL_F_STATE_MACHINE 353 | |||
| # define SSL_F_TLS12_CHECK_PEER_SIGALG 333 | |||
| # define SSL_F_TLS12_COPY_SIGALGS 533 | |||
| # define SSL_F_TLS13_CHANGE_CIPHER_STATE 440 | |||
| # define SSL_F_TLS13_ENC 609 | |||
| # define SSL_F_TLS13_FINAL_FINISH_MAC 605 | |||
| # define SSL_F_TLS13_GENERATE_SECRET 591 | |||
| # define SSL_F_TLS13_HKDF_EXPAND 561 | |||
| # define SSL_F_TLS13_RESTORE_HANDSHAKE_DIGEST_FOR_PHA 617 | |||
| # define SSL_F_TLS13_SAVE_HANDSHAKE_DIGEST_FOR_PHA 618 | |||
| # define SSL_F_TLS13_SETUP_KEY_BLOCK 441 | |||
| # define SSL_F_TLS1_CHANGE_CIPHER_STATE 209 | |||
| # define SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS 341 | |||
| # define SSL_F_TLS1_ENC 401 | |||
| # define SSL_F_TLS1_EXPORT_KEYING_MATERIAL 314 | |||
| # define SSL_F_TLS1_GET_CURVELIST 338 | |||
| # define SSL_F_TLS1_PRF 284 | |||
| # define SSL_F_TLS1_SAVE_U16 628 | |||
| # define SSL_F_TLS1_SETUP_KEY_BLOCK 211 | |||
| # define SSL_F_TLS1_SET_GROUPS 629 | |||
| # define SSL_F_TLS1_SET_RAW_SIGALGS 630 | |||
| # define SSL_F_TLS1_SET_SERVER_SIGALGS 335 | |||
| # define SSL_F_TLS1_SET_SHARED_SIGALGS 631 | |||
| # define SSL_F_TLS1_SET_SIGALGS 632 | |||
| # define SSL_F_TLS_CHOOSE_SIGALG 513 | |||
| # define SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK 354 | |||
| # define SSL_F_TLS_COLLECT_EXTENSIONS 435 | |||
| # define SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES 542 | |||
| # define SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST 372 | |||
| # define SSL_F_TLS_CONSTRUCT_CERT_STATUS 429 | |||
| # define SSL_F_TLS_CONSTRUCT_CERT_STATUS_BODY 494 | |||
| # define SSL_F_TLS_CONSTRUCT_CERT_VERIFY 496 | |||
| # define SSL_F_TLS_CONSTRUCT_CHANGE_CIPHER_SPEC 427 | |||
| # define SSL_F_TLS_CONSTRUCT_CKE_DHE 404 | |||
| # define SSL_F_TLS_CONSTRUCT_CKE_ECDHE 405 | |||
| # define SSL_F_TLS_CONSTRUCT_CKE_GOST 406 | |||
| # define SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE 407 | |||
| # define SSL_F_TLS_CONSTRUCT_CKE_RSA 409 | |||
| # define SSL_F_TLS_CONSTRUCT_CKE_SRP 410 | |||
| # define SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE 484 | |||
| # define SSL_F_TLS_CONSTRUCT_CLIENT_HELLO 487 | |||
| # define SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE 488 | |||
| # define SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY 489 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_ALPN 466 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_CERTIFICATE 355 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_COOKIE 535 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA 530 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_EC_PT_FORMATS 467 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_EMS 468 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_ETM 469 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_HELLO 356 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_KEY_EXCHANGE 357 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE 470 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_MAXFRAGMENTLEN 549 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_NPN 471 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_PADDING 472 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_POST_HANDSHAKE_AUTH 619 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_PSK 501 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_PSK_KEX_MODES 509 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_RENEGOTIATE 473 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_SCT 474 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_SERVER_NAME 475 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET 476 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_SIG_ALGS 477 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_SRP 478 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST 479 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS 480 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS 481 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP 482 | |||
| # define SSL_F_TLS_CONSTRUCT_CTOS_VERIFY 358 | |||
| # define SSL_F_TLS_CONSTRUCT_ENCRYPTED_EXTENSIONS 443 | |||
| # define SSL_F_TLS_CONSTRUCT_END_OF_EARLY_DATA 536 | |||
| # define SSL_F_TLS_CONSTRUCT_EXTENSIONS 447 | |||
| # define SSL_F_TLS_CONSTRUCT_FINISHED 359 | |||
| # define SSL_F_TLS_CONSTRUCT_HELLO_REQUEST 373 | |||
| # define SSL_F_TLS_CONSTRUCT_HELLO_RETRY_REQUEST 510 | |||
| # define SSL_F_TLS_CONSTRUCT_KEY_UPDATE 517 | |||
| # define SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET 428 | |||
| # define SSL_F_TLS_CONSTRUCT_NEXT_PROTO 426 | |||
| # define SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE 490 | |||
| # define SSL_F_TLS_CONSTRUCT_SERVER_HELLO 491 | |||
| # define SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE 492 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_ALPN 451 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_CERTIFICATE 374 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_COOKIE 613 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG 452 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_DONE 375 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA 531 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA_INFO 525 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS 453 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_EMS 454 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_ETM 455 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_HELLO 376 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_KEY_EXCHANGE 377 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE 456 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_MAXFRAGMENTLEN 548 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG 457 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_PSK 504 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE 458 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME 459 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET 460 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST 461 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS 544 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_VERSIONS 611 | |||
| # define SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP 462 | |||
| # define SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO 521 | |||
| # define SSL_F_TLS_FINISH_HANDSHAKE 597 | |||
| # define SSL_F_TLS_GET_MESSAGE_BODY 351 | |||
| # define SSL_F_TLS_GET_MESSAGE_HEADER 387 | |||
| # define SSL_F_TLS_HANDLE_ALPN 562 | |||
| # define SSL_F_TLS_HANDLE_STATUS_REQUEST 563 | |||
| # define SSL_F_TLS_PARSE_CERTIFICATE_AUTHORITIES 566 | |||
| # define SSL_F_TLS_PARSE_CLIENTHELLO_TLSEXT 449 | |||
| # define SSL_F_TLS_PARSE_CTOS_ALPN 567 | |||
| # define SSL_F_TLS_PARSE_CTOS_COOKIE 614 | |||
| # define SSL_F_TLS_PARSE_CTOS_EARLY_DATA 568 | |||
| # define SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS 569 | |||
| # define SSL_F_TLS_PARSE_CTOS_EMS 570 | |||
| # define SSL_F_TLS_PARSE_CTOS_KEY_SHARE 463 | |||
| # define SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN 571 | |||
| # define SSL_F_TLS_PARSE_CTOS_POST_HANDSHAKE_AUTH 620 | |||
| # define SSL_F_TLS_PARSE_CTOS_PSK 505 | |||
| # define SSL_F_TLS_PARSE_CTOS_PSK_KEX_MODES 572 | |||
| # define SSL_F_TLS_PARSE_CTOS_RENEGOTIATE 464 | |||
| # define SSL_F_TLS_PARSE_CTOS_SERVER_NAME 573 | |||
| # define SSL_F_TLS_PARSE_CTOS_SESSION_TICKET 574 | |||
| # define SSL_F_TLS_PARSE_CTOS_SIG_ALGS 575 | |||
| # define SSL_F_TLS_PARSE_CTOS_SIG_ALGS_CERT 615 | |||
| # define SSL_F_TLS_PARSE_CTOS_SRP 576 | |||
| # define SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST 577 | |||
| # define SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS 578 | |||
| # define SSL_F_TLS_PARSE_CTOS_USE_SRTP 465 | |||
| # define SSL_F_TLS_PARSE_STOC_ALPN 579 | |||
| # define SSL_F_TLS_PARSE_STOC_COOKIE 534 | |||
| # define SSL_F_TLS_PARSE_STOC_EARLY_DATA 538 | |||
| # define SSL_F_TLS_PARSE_STOC_EARLY_DATA_INFO 528 | |||
| # define SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS 580 | |||
| # define SSL_F_TLS_PARSE_STOC_KEY_SHARE 445 | |||
| # define SSL_F_TLS_PARSE_STOC_MAXFRAGMENTLEN 581 | |||
| # define SSL_F_TLS_PARSE_STOC_NPN 582 | |||
| # define SSL_F_TLS_PARSE_STOC_PSK 502 | |||
| # define SSL_F_TLS_PARSE_STOC_RENEGOTIATE 448 | |||
| # define SSL_F_TLS_PARSE_STOC_SCT 564 | |||
| # define SSL_F_TLS_PARSE_STOC_SERVER_NAME 583 | |||
| # define SSL_F_TLS_PARSE_STOC_SESSION_TICKET 584 | |||
| # define SSL_F_TLS_PARSE_STOC_STATUS_REQUEST 585 | |||
| # define SSL_F_TLS_PARSE_STOC_SUPPORTED_VERSIONS 612 | |||
| # define SSL_F_TLS_PARSE_STOC_USE_SRTP 446 | |||
| # define SSL_F_TLS_POST_PROCESS_CLIENT_HELLO 378 | |||
| # define SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE 384 | |||
| # define SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE 360 | |||
| # define SSL_F_TLS_PROCESS_AS_HELLO_RETRY_REQUEST 610 | |||
| # define SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST 361 | |||
| # define SSL_F_TLS_PROCESS_CERT_STATUS 362 | |||
| # define SSL_F_TLS_PROCESS_CERT_STATUS_BODY 495 | |||
| # define SSL_F_TLS_PROCESS_CERT_VERIFY 379 | |||
| # define SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC 363 | |||
| # define SSL_F_TLS_PROCESS_CKE_DHE 411 | |||
| # define SSL_F_TLS_PROCESS_CKE_ECDHE 412 | |||
| # define SSL_F_TLS_PROCESS_CKE_GOST 413 | |||
| # define SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE 414 | |||
| # define SSL_F_TLS_PROCESS_CKE_RSA 415 | |||
| # define SSL_F_TLS_PROCESS_CKE_SRP 416 | |||
| # define SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE 380 | |||
| # define SSL_F_TLS_PROCESS_CLIENT_HELLO 381 | |||
| # define SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE 382 | |||
| # define SSL_F_TLS_PROCESS_ENCRYPTED_EXTENSIONS 444 | |||
| # define SSL_F_TLS_PROCESS_END_OF_EARLY_DATA 537 | |||
| # define SSL_F_TLS_PROCESS_FINISHED 364 | |||
| # define SSL_F_TLS_PROCESS_HELLO_REQ 507 | |||
| # define SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST 511 | |||
| # define SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT 442 | |||
| # define SSL_F_TLS_PROCESS_KEY_EXCHANGE 365 | |||
| # define SSL_F_TLS_PROCESS_KEY_UPDATE 518 | |||
| # define SSL_F_TLS_PROCESS_NEW_SESSION_TICKET 366 | |||
| # define SSL_F_TLS_PROCESS_NEXT_PROTO 383 | |||
| # define SSL_F_TLS_PROCESS_SERVER_CERTIFICATE 367 | |||
| # define SSL_F_TLS_PROCESS_SERVER_DONE 368 | |||
| # define SSL_F_TLS_PROCESS_SERVER_HELLO 369 | |||
| # define SSL_F_TLS_PROCESS_SKE_DHE 419 | |||
| # define SSL_F_TLS_PROCESS_SKE_ECDHE 420 | |||
| # define SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE 421 | |||
| # define SSL_F_TLS_PROCESS_SKE_SRP 422 | |||
| # define SSL_F_TLS_PSK_DO_BINDER 506 | |||
| # define SSL_F_TLS_SCAN_CLIENTHELLO_TLSEXT 450 | |||
| # define SSL_F_TLS_SETUP_HANDSHAKE 508 | |||
| # define SSL_F_USE_CERTIFICATE_CHAIN_FILE 220 | |||
| # define SSL_F_WPACKET_INTERN_INIT_LEN 633 | |||
| # define SSL_F_WPACKET_START_SUB_PACKET_LEN__ 634 | |||
| # define SSL_F_WRITE_STATE_MACHINE 586 | |||
| /* | |||
| * SSL reason codes. | |||
| */ | |||
| # define SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY 291 | |||
| # define SSL_R_APP_DATA_IN_HANDSHAKE 100 | |||
| # define SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT 272 | |||
| # define SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE 143 | |||
| # define SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE 158 | |||
| # define SSL_R_BAD_CHANGE_CIPHER_SPEC 103 | |||
| # define SSL_R_BAD_CIPHER 186 | |||
| # define SSL_R_BAD_DATA 390 | |||
| # define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK 106 | |||
| # define SSL_R_BAD_DECOMPRESSION 107 | |||
| # define SSL_R_BAD_DH_VALUE 102 | |||
| # define SSL_R_BAD_DIGEST_LENGTH 111 | |||
| # define SSL_R_BAD_EARLY_DATA 233 | |||
| # define SSL_R_BAD_ECC_CERT 304 | |||
| # define SSL_R_BAD_ECPOINT 306 | |||
| # define SSL_R_BAD_EXTENSION 110 | |||
| # define SSL_R_BAD_HANDSHAKE_LENGTH 332 | |||
| # define SSL_R_BAD_HANDSHAKE_STATE 236 | |||
| # define SSL_R_BAD_HELLO_REQUEST 105 | |||
| # define SSL_R_BAD_HRR_VERSION 263 | |||
| # define SSL_R_BAD_KEY_SHARE 108 | |||
| # define SSL_R_BAD_KEY_UPDATE 122 | |||
| # define SSL_R_BAD_LEGACY_VERSION 292 | |||
| # define SSL_R_BAD_LENGTH 271 | |||
| # define SSL_R_BAD_PACKET 240 | |||
| # define SSL_R_BAD_PACKET_LENGTH 115 | |||
| # define SSL_R_BAD_PROTOCOL_VERSION_NUMBER 116 | |||
| # define SSL_R_BAD_PSK 219 | |||
| # define SSL_R_BAD_PSK_IDENTITY 114 | |||
| # define SSL_R_BAD_RECORD_TYPE 443 | |||
| # define SSL_R_BAD_RSA_ENCRYPT 119 | |||
| # define SSL_R_BAD_SIGNATURE 123 | |||
| # define SSL_R_BAD_SRP_A_LENGTH 347 | |||
| # define SSL_R_BAD_SRP_PARAMETERS 371 | |||
| # define SSL_R_BAD_SRTP_MKI_VALUE 352 | |||
| # define SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST 353 | |||
| # define SSL_R_BAD_SSL_FILETYPE 124 | |||
| # define SSL_R_BAD_VALUE 384 | |||
| # define SSL_R_BAD_WRITE_RETRY 127 | |||
| # define SSL_R_BINDER_DOES_NOT_VERIFY 253 | |||
| # define SSL_R_BIO_NOT_SET 128 | |||
| # define SSL_R_BLOCK_CIPHER_PAD_IS_WRONG 129 | |||
| # define SSL_R_BN_LIB 130 | |||
| # define SSL_R_CALLBACK_FAILED 234 | |||
| # define SSL_R_CANNOT_CHANGE_CIPHER 109 | |||
| # define SSL_R_CA_DN_LENGTH_MISMATCH 131 | |||
| # define SSL_R_CA_KEY_TOO_SMALL 397 | |||
| # define SSL_R_CA_MD_TOO_WEAK 398 | |||
| # define SSL_R_CCS_RECEIVED_EARLY 133 | |||
| # define SSL_R_CERTIFICATE_VERIFY_FAILED 134 | |||
| # define SSL_R_CERT_CB_ERROR 377 | |||
| # define SSL_R_CERT_LENGTH_MISMATCH 135 | |||
| # define SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED 218 | |||
| # define SSL_R_CIPHER_CODE_WRONG_LENGTH 137 | |||
| # define SSL_R_CIPHER_OR_HASH_UNAVAILABLE 138 | |||
| # define SSL_R_CLIENTHELLO_TLSEXT 226 | |||
| # define SSL_R_COMPRESSED_LENGTH_TOO_LONG 140 | |||
| # define SSL_R_COMPRESSION_DISABLED 343 | |||
| # define SSL_R_COMPRESSION_FAILURE 141 | |||
| # define SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE 307 | |||
| # define SSL_R_COMPRESSION_LIBRARY_ERROR 142 | |||
| # define SSL_R_CONNECTION_TYPE_NOT_SET 144 | |||
| # define SSL_R_CONTEXT_NOT_DANE_ENABLED 167 | |||
| # define SSL_R_COOKIE_GEN_CALLBACK_FAILURE 400 | |||
| # define SSL_R_COOKIE_MISMATCH 308 | |||
| # define SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED 206 | |||
| # define SSL_R_DANE_ALREADY_ENABLED 172 | |||
| # define SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL 173 | |||
| # define SSL_R_DANE_NOT_ENABLED 175 | |||
| # define SSL_R_DANE_TLSA_BAD_CERTIFICATE 180 | |||
| # define SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE 184 | |||
| # define SSL_R_DANE_TLSA_BAD_DATA_LENGTH 189 | |||
| # define SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH 192 | |||
| # define SSL_R_DANE_TLSA_BAD_MATCHING_TYPE 200 | |||
| # define SSL_R_DANE_TLSA_BAD_PUBLIC_KEY 201 | |||
| # define SSL_R_DANE_TLSA_BAD_SELECTOR 202 | |||
| # define SSL_R_DANE_TLSA_NULL_DATA 203 | |||
| # define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED 145 | |||
| # define SSL_R_DATA_LENGTH_TOO_LONG 146 | |||
| # define SSL_R_DECRYPTION_FAILED 147 | |||
| # define SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC 281 | |||
| # define SSL_R_DH_KEY_TOO_SMALL 394 | |||
| # define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG 148 | |||
| # define SSL_R_DIGEST_CHECK_FAILED 149 | |||
| # define SSL_R_DTLS_MESSAGE_TOO_BIG 334 | |||
| # define SSL_R_DUPLICATE_COMPRESSION_ID 309 | |||
| # define SSL_R_ECC_CERT_NOT_FOR_SIGNING 318 | |||
| # define SSL_R_ECDH_REQUIRED_FOR_SUITEB_MODE 374 | |||
| # define SSL_R_EE_KEY_TOO_SMALL 399 | |||
| # define SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST 354 | |||
| # define SSL_R_ENCRYPTED_LENGTH_TOO_LONG 150 | |||
| # define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST 151 | |||
| # define SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN 204 | |||
| # define SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE 194 | |||
| # define SSL_R_EXCESSIVE_MESSAGE_SIZE 152 | |||
| # define SSL_R_EXTENSION_NOT_RECEIVED 279 | |||
| # define SSL_R_EXTRA_DATA_IN_MESSAGE 153 | |||
| # define SSL_R_EXT_LENGTH_MISMATCH 163 | |||
| # define SSL_R_FAILED_TO_INIT_ASYNC 405 | |||
| # define SSL_R_FRAGMENTED_CLIENT_HELLO 401 | |||
| # define SSL_R_GOT_A_FIN_BEFORE_A_CCS 154 | |||
| # define SSL_R_HTTPS_PROXY_REQUEST 155 | |||
| # define SSL_R_HTTP_REQUEST 156 | |||
| # define SSL_R_ILLEGAL_POINT_COMPRESSION 162 | |||
| # define SSL_R_ILLEGAL_SUITEB_DIGEST 380 | |||
| # define SSL_R_INAPPROPRIATE_FALLBACK 373 | |||
| # define SSL_R_INCONSISTENT_COMPRESSION 340 | |||
| # define SSL_R_INCONSISTENT_EARLY_DATA_ALPN 222 | |||
| # define SSL_R_INCONSISTENT_EARLY_DATA_SNI 231 | |||
| # define SSL_R_INCONSISTENT_EXTMS 104 | |||
| # define SSL_R_INSUFFICIENT_SECURITY 241 | |||
| # define SSL_R_INVALID_ALERT 205 | |||
| # define SSL_R_INVALID_CCS_MESSAGE 260 | |||
| # define SSL_R_INVALID_CERTIFICATE_OR_ALG 238 | |||
| # define SSL_R_INVALID_COMMAND 280 | |||
| # define SSL_R_INVALID_COMPRESSION_ALGORITHM 341 | |||
| # define SSL_R_INVALID_CONFIG 283 | |||
| # define SSL_R_INVALID_CONFIGURATION_NAME 113 | |||
| # define SSL_R_INVALID_CONTEXT 282 | |||
| # define SSL_R_INVALID_CT_VALIDATION_TYPE 212 | |||
| # define SSL_R_INVALID_KEY_UPDATE_TYPE 120 | |||
| # define SSL_R_INVALID_MAX_EARLY_DATA 174 | |||
| # define SSL_R_INVALID_NULL_CMD_NAME 385 | |||
| # define SSL_R_INVALID_SEQUENCE_NUMBER 402 | |||
| # define SSL_R_INVALID_SERVERINFO_DATA 388 | |||
| # define SSL_R_INVALID_SESSION_ID 999 | |||
| # define SSL_R_INVALID_SRP_USERNAME 357 | |||
| # define SSL_R_INVALID_STATUS_RESPONSE 328 | |||
| # define SSL_R_INVALID_TICKET_KEYS_LENGTH 325 | |||
| # define SSL_R_LENGTH_MISMATCH 159 | |||
| # define SSL_R_LENGTH_TOO_LONG 404 | |||
| # define SSL_R_LENGTH_TOO_SHORT 160 | |||
| # define SSL_R_LIBRARY_BUG 274 | |||
| # define SSL_R_LIBRARY_HAS_NO_CIPHERS 161 | |||
| # define SSL_R_MISSING_DSA_SIGNING_CERT 165 | |||
| # define SSL_R_MISSING_ECDSA_SIGNING_CERT 381 | |||
| # define SSL_R_MISSING_FATAL 256 | |||
| # define SSL_R_MISSING_PARAMETERS 290 | |||
| # define SSL_R_MISSING_RSA_CERTIFICATE 168 | |||
| # define SSL_R_MISSING_RSA_ENCRYPTING_CERT 169 | |||
| # define SSL_R_MISSING_RSA_SIGNING_CERT 170 | |||
| # define SSL_R_MISSING_SIGALGS_EXTENSION 112 | |||
| # define SSL_R_MISSING_SIGNING_CERT 221 | |||
| # define SSL_R_MISSING_SRP_PARAM 358 | |||
| # define SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION 209 | |||
| # define SSL_R_MISSING_TMP_DH_KEY 171 | |||
| # define SSL_R_MISSING_TMP_ECDH_KEY 311 | |||
| # define SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA 293 | |||
| # define SSL_R_NOT_ON_RECORD_BOUNDARY 182 | |||
| # define SSL_R_NOT_REPLACING_CERTIFICATE 289 | |||
| # define SSL_R_NOT_SERVER 284 | |||
| # define SSL_R_NO_APPLICATION_PROTOCOL 235 | |||
| # define SSL_R_NO_CERTIFICATES_RETURNED 176 | |||
| # define SSL_R_NO_CERTIFICATE_ASSIGNED 177 | |||
| # define SSL_R_NO_CERTIFICATE_SET 179 | |||
| # define SSL_R_NO_CHANGE_FOLLOWING_HRR 214 | |||
| # define SSL_R_NO_CIPHERS_AVAILABLE 181 | |||
| # define SSL_R_NO_CIPHERS_SPECIFIED 183 | |||
| # define SSL_R_NO_CIPHER_MATCH 185 | |||
| # define SSL_R_NO_CLIENT_CERT_METHOD 331 | |||
| # define SSL_R_NO_COMPRESSION_SPECIFIED 187 | |||
| # define SSL_R_NO_COOKIE_CALLBACK_SET 287 | |||
| # define SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER 330 | |||
| # define SSL_R_NO_METHOD_SPECIFIED 188 | |||
| # define SSL_R_NO_PEM_EXTENSIONS 389 | |||
| # define SSL_R_NO_PRIVATE_KEY_ASSIGNED 190 | |||
| # define SSL_R_NO_PROTOCOLS_AVAILABLE 191 | |||
| # define SSL_R_NO_RENEGOTIATION 339 | |||
| # define SSL_R_NO_REQUIRED_DIGEST 324 | |||
| # define SSL_R_NO_SHARED_CIPHER 193 | |||
| # define SSL_R_NO_SHARED_GROUPS 410 | |||
| # define SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS 376 | |||
| # define SSL_R_NO_SRTP_PROFILES 359 | |||
| # define SSL_R_NO_SUITABLE_KEY_SHARE 101 | |||
| # define SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM 118 | |||
| # define SSL_R_NO_VALID_SCTS 216 | |||
| # define SSL_R_NO_VERIFY_COOKIE_CALLBACK 403 | |||
| # define SSL_R_NULL_SSL_CTX 195 | |||
| # define SSL_R_NULL_SSL_METHOD_PASSED 196 | |||
| # define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED 197 | |||
| # define SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED 344 | |||
| # define SSL_R_OVERFLOW_ERROR 237 | |||
| # define SSL_R_PACKET_LENGTH_TOO_LONG 198 | |||
| # define SSL_R_PARSE_TLSEXT 227 | |||
| # define SSL_R_PATH_TOO_LONG 270 | |||
| # define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE 199 | |||
| # define SSL_R_PEM_NAME_BAD_PREFIX 391 | |||
| # define SSL_R_PEM_NAME_TOO_SHORT 392 | |||
| # define SSL_R_PIPELINE_FAILURE 406 | |||
| # define SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR 278 | |||
| # define SSL_R_PRIVATE_KEY_MISMATCH 288 | |||
| # define SSL_R_PROTOCOL_IS_SHUTDOWN 207 | |||
| # define SSL_R_PSK_IDENTITY_NOT_FOUND 223 | |||
| # define SSL_R_PSK_NO_CLIENT_CB 224 | |||
| # define SSL_R_PSK_NO_SERVER_CB 225 | |||
| # define SSL_R_READ_BIO_NOT_SET 211 | |||
| # define SSL_R_READ_TIMEOUT_EXPIRED 312 | |||
| # define SSL_R_RECORD_LENGTH_MISMATCH 213 | |||
| # define SSL_R_RECORD_TOO_SMALL 298 | |||
| # define SSL_R_RENEGOTIATE_EXT_TOO_LONG 335 | |||
| # define SSL_R_RENEGOTIATION_ENCODING_ERR 336 | |||
| # define SSL_R_RENEGOTIATION_MISMATCH 337 | |||
| # define SSL_R_REQUEST_PENDING 285 | |||
| # define SSL_R_REQUEST_SENT 286 | |||
| # define SSL_R_REQUIRED_CIPHER_MISSING 215 | |||
| # define SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING 342 | |||
| # define SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING 345 | |||
| # define SSL_R_SCT_VERIFICATION_FAILED 208 | |||
| # define SSL_R_SERVERHELLO_TLSEXT 275 | |||
| # define SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED 277 | |||
| # define SSL_R_SHUTDOWN_WHILE_IN_INIT 407 | |||
| # define SSL_R_SIGNATURE_ALGORITHMS_ERROR 360 | |||
| # define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE 220 | |||
| # define SSL_R_SRP_A_CALC 361 | |||
| # define SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES 362 | |||
| # define SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG 363 | |||
| # define SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE 364 | |||
| # define SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH 232 | |||
| # define SSL_R_SSL3_EXT_INVALID_SERVERNAME 319 | |||
| # define SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE 320 | |||
| # define SSL_R_SSL3_SESSION_ID_TOO_LONG 300 | |||
| # define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE 1042 | |||
| # define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC 1020 | |||
| # define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED 1045 | |||
| # define SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED 1044 | |||
| # define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN 1046 | |||
| # define SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE 1030 | |||
| # define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE 1040 | |||
| # define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER 1047 | |||
| # define SSL_R_SSLV3_ALERT_NO_CERTIFICATE 1041 | |||
| # define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE 1010 | |||
| # define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE 1043 | |||
| # define SSL_R_SSL_COMMAND_SECTION_EMPTY 117 | |||
| # define SSL_R_SSL_COMMAND_SECTION_NOT_FOUND 125 | |||
| # define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION 228 | |||
| # define SSL_R_SSL_HANDSHAKE_FAILURE 229 | |||
| # define SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS 230 | |||
| # define SSL_R_SSL_NEGATIVE_LENGTH 372 | |||
| # define SSL_R_SSL_SECTION_EMPTY 126 | |||
| # define SSL_R_SSL_SECTION_NOT_FOUND 136 | |||
| # define SSL_R_SSL_SESSION_ID_CALLBACK_FAILED 301 | |||
| # define SSL_R_SSL_SESSION_ID_CONFLICT 302 | |||
| # define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG 273 | |||
| # define SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH 303 | |||
| # define SSL_R_SSL_SESSION_ID_TOO_LONG 408 | |||
| # define SSL_R_SSL_SESSION_VERSION_MISMATCH 210 | |||
| # define SSL_R_STILL_IN_INIT 121 | |||
| # define SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED 1116 | |||
| # define SSL_R_TLSV13_ALERT_MISSING_EXTENSION 1109 | |||
| # define SSL_R_TLSV1_ALERT_ACCESS_DENIED 1049 | |||
| # define SSL_R_TLSV1_ALERT_DECODE_ERROR 1050 | |||
| # define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED 1021 | |||
| # define SSL_R_TLSV1_ALERT_DECRYPT_ERROR 1051 | |||
| # define SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION 1060 | |||
| # define SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK 1086 | |||
| # define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY 1071 | |||
| # define SSL_R_TLSV1_ALERT_INTERNAL_ERROR 1080 | |||
| # define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION 1100 | |||
| # define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION 1070 | |||
| # define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW 1022 | |||
| # define SSL_R_TLSV1_ALERT_UNKNOWN_CA 1048 | |||
| # define SSL_R_TLSV1_ALERT_USER_CANCELLED 1090 | |||
| # define SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE 1114 | |||
| # define SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE 1113 | |||
| # define SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE 1111 | |||
| # define SSL_R_TLSV1_UNRECOGNIZED_NAME 1112 | |||
| # define SSL_R_TLSV1_UNSUPPORTED_EXTENSION 1110 | |||
| # define SSL_R_TLS_HEARTBEAT_PEER_DOESNT_ACCEPT 365 | |||
| # define SSL_R_TLS_HEARTBEAT_PENDING 366 | |||
| # define SSL_R_TLS_ILLEGAL_EXPORTER_LABEL 367 | |||
| # define SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST 157 | |||
| # define SSL_R_TOO_MANY_KEY_UPDATES 132 | |||
| # define SSL_R_TOO_MANY_WARN_ALERTS 409 | |||
| # define SSL_R_TOO_MUCH_EARLY_DATA 164 | |||
| # define SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS 314 | |||
| # define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS 239 | |||
| # define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES 242 | |||
| # define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES 243 | |||
| # define SSL_R_UNEXPECTED_CCS_MESSAGE 262 | |||
| # define SSL_R_UNEXPECTED_END_OF_EARLY_DATA 178 | |||
| # define SSL_R_UNEXPECTED_MESSAGE 244 | |||
| # define SSL_R_UNEXPECTED_RECORD 245 | |||
| # define SSL_R_UNINITIALIZED 276 | |||
| # define SSL_R_UNKNOWN_ALERT_TYPE 246 | |||
| # define SSL_R_UNKNOWN_CERTIFICATE_TYPE 247 | |||
| # define SSL_R_UNKNOWN_CIPHER_RETURNED 248 | |||
| # define SSL_R_UNKNOWN_CIPHER_TYPE 249 | |||
| # define SSL_R_UNKNOWN_CMD_NAME 386 | |||
| # define SSL_R_UNKNOWN_COMMAND 139 | |||
| # define SSL_R_UNKNOWN_DIGEST 368 | |||
| # define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE 250 | |||
| # define SSL_R_UNKNOWN_PKEY_TYPE 251 | |||
| # define SSL_R_UNKNOWN_PROTOCOL 252 | |||
| # define SSL_R_UNKNOWN_SSL_VERSION 254 | |||
| # define SSL_R_UNKNOWN_STATE 255 | |||
| # define SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED 338 | |||
| # define SSL_R_UNSOLICITED_EXTENSION 217 | |||
| # define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM 257 | |||
| # define SSL_R_UNSUPPORTED_ELLIPTIC_CURVE 315 | |||
| # define SSL_R_UNSUPPORTED_PROTOCOL 258 | |||
| # define SSL_R_UNSUPPORTED_SSL_VERSION 259 | |||
| # define SSL_R_UNSUPPORTED_STATUS_TYPE 329 | |||
| # define SSL_R_USE_SRTP_NOT_NEGOTIATED 369 | |||
| # define SSL_R_VERSION_TOO_HIGH 166 | |||
| # define SSL_R_VERSION_TOO_LOW 396 | |||
| # define SSL_R_WRONG_CERTIFICATE_TYPE 383 | |||
| # define SSL_R_WRONG_CIPHER_RETURNED 261 | |||
| # define SSL_R_WRONG_CURVE 378 | |||
| # define SSL_R_WRONG_SIGNATURE_LENGTH 264 | |||
| # define SSL_R_WRONG_SIGNATURE_SIZE 265 | |||
| # define SSL_R_WRONG_SIGNATURE_TYPE 370 | |||
| # define SSL_R_WRONG_SSL_VERSION 266 | |||
| # define SSL_R_WRONG_VERSION_NUMBER 267 | |||
| # define SSL_R_X509_LIB 268 | |||
| # define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS 269 | |||
| #endif | |||
| @ -1,83 +0,0 @@ | |||
| /* | |||
| * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_STACK_H | |||
| # define HEADER_STACK_H | |||
| #ifdef __cplusplus | |||
| extern "C" { | |||
| #endif | |||
| typedef struct stack_st OPENSSL_STACK; /* Use STACK_OF(...) instead */ | |||
| typedef int (*OPENSSL_sk_compfunc)(const void *, const void *); | |||
| typedef void (*OPENSSL_sk_freefunc)(void *); | |||
| typedef void *(*OPENSSL_sk_copyfunc)(const void *); | |||
| int OPENSSL_sk_num(const OPENSSL_STACK *); | |||
| void *OPENSSL_sk_value(const OPENSSL_STACK *, int); | |||
| void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, const void *data); | |||
| OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc cmp); | |||
| OPENSSL_STACK *OPENSSL_sk_new_null(void); | |||
| OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n); | |||
| int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n); | |||
| void OPENSSL_sk_free(OPENSSL_STACK *); | |||
| void OPENSSL_sk_pop_free(OPENSSL_STACK *st, void (*func) (void *)); | |||
| OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *, | |||
| OPENSSL_sk_copyfunc c, | |||
| OPENSSL_sk_freefunc f); | |||
| int OPENSSL_sk_insert(OPENSSL_STACK *sk, const void *data, int where); | |||
| void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc); | |||
| void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, const void *p); | |||
| int OPENSSL_sk_find(OPENSSL_STACK *st, const void *data); | |||
| int OPENSSL_sk_find_ex(OPENSSL_STACK *st, const void *data); | |||
| int OPENSSL_sk_push(OPENSSL_STACK *st, const void *data); | |||
| int OPENSSL_sk_unshift(OPENSSL_STACK *st, const void *data); | |||
| void *OPENSSL_sk_shift(OPENSSL_STACK *st); | |||
| void *OPENSSL_sk_pop(OPENSSL_STACK *st); | |||
| void OPENSSL_sk_zero(OPENSSL_STACK *st); | |||
| OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk, | |||
| OPENSSL_sk_compfunc cmp); | |||
| OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *st); | |||
| void OPENSSL_sk_sort(OPENSSL_STACK *st); | |||
| int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st); | |||
| # if OPENSSL_API_COMPAT < 0x10100000L | |||
| # define _STACK OPENSSL_STACK | |||
| # define sk_num OPENSSL_sk_num | |||
| # define sk_value OPENSSL_sk_value | |||
| # define sk_set OPENSSL_sk_set | |||
| # define sk_new OPENSSL_sk_new | |||
| # define sk_new_null OPENSSL_sk_new_null | |||
| # define sk_free OPENSSL_sk_free | |||
| # define sk_pop_free OPENSSL_sk_pop_free | |||
| # define sk_deep_copy OPENSSL_sk_deep_copy | |||
| # define sk_insert OPENSSL_sk_insert | |||
| # define sk_delete OPENSSL_sk_delete | |||
| # define sk_delete_ptr OPENSSL_sk_delete_ptr | |||
| # define sk_find OPENSSL_sk_find | |||
| # define sk_find_ex OPENSSL_sk_find_ex | |||
| # define sk_push OPENSSL_sk_push | |||
| # define sk_unshift OPENSSL_sk_unshift | |||
| # define sk_shift OPENSSL_sk_shift | |||
| # define sk_pop OPENSSL_sk_pop | |||
| # define sk_zero OPENSSL_sk_zero | |||
| # define sk_set_cmp_func OPENSSL_sk_set_cmp_func | |||
| # define sk_dup OPENSSL_sk_dup | |||
| # define sk_sort OPENSSL_sk_sort | |||
| # define sk_is_sorted OPENSSL_sk_is_sorted | |||
| # endif | |||
| #ifdef __cplusplus | |||
| } | |||
| #endif | |||
| #endif | |||
| @ -1,266 +0,0 @@ | |||
| /* | |||
| * Copyright 2016-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_OSSL_STORE_H | |||
| # define HEADER_OSSL_STORE_H | |||
| # include <stdarg.h> | |||
| # include <openssl/ossl_typ.h> | |||
| # include <openssl/pem.h> | |||
| # include <openssl/storeerr.h> | |||
| # ifdef __cplusplus | |||
| extern "C" { | |||
| # endif | |||
| /*- | |||
| * The main OSSL_STORE functions. | |||
| * ------------------------------ | |||
| * | |||
| * These allow applications to open a channel to a resource with supported | |||
| * data (keys, certs, crls, ...), read the data a piece at a time and decide | |||
| * what to do with it, and finally close. | |||
| */ | |||
| typedef struct ossl_store_ctx_st OSSL_STORE_CTX; | |||
| /* | |||
| * Typedef for the OSSL_STORE_INFO post processing callback. This can be used | |||
| * to massage the given OSSL_STORE_INFO, or to drop it entirely (by returning | |||
| * NULL). | |||
| */ | |||
| typedef OSSL_STORE_INFO *(*OSSL_STORE_post_process_info_fn)(OSSL_STORE_INFO *, | |||
| void *); | |||
| /* | |||
| * Open a channel given a URI. The given UI method will be used any time the | |||
| * loader needs extra input, for example when a password or pin is needed, and | |||
| * will be passed the same user data every time it's needed in this context. | |||
| * | |||
| * Returns a context reference which represents the channel to communicate | |||
| * through. | |||
| */ | |||
| OSSL_STORE_CTX *OSSL_STORE_open(const char *uri, const UI_METHOD *ui_method, | |||
| void *ui_data, | |||
| OSSL_STORE_post_process_info_fn post_process, | |||
| void *post_process_data); | |||
| /* | |||
| * Control / fine tune the OSSL_STORE channel. |cmd| determines what is to be | |||
| * done, and depends on the underlying loader (use OSSL_STORE_get0_scheme to | |||
| * determine which loader is used), except for common commands (see below). | |||
| * Each command takes different arguments. | |||
| */ | |||
| int OSSL_STORE_ctrl(OSSL_STORE_CTX *ctx, int cmd, ... /* args */); | |||
| int OSSL_STORE_vctrl(OSSL_STORE_CTX *ctx, int cmd, va_list args); | |||
| /* | |||
| * Common ctrl commands that different loaders may choose to support. | |||
| */ | |||
| /* int on = 0 or 1; STORE_ctrl(ctx, STORE_C_USE_SECMEM, &on); */ | |||
| # define OSSL_STORE_C_USE_SECMEM 1 | |||
| /* Where custom commands start */ | |||
| # define OSSL_STORE_C_CUSTOM_START 100 | |||
| /* | |||
| * Read one data item (a key, a cert, a CRL) that is supported by the OSSL_STORE | |||
| * functionality, given a context. | |||
| * Returns a OSSL_STORE_INFO pointer, from which OpenSSL typed data can be | |||
| * extracted with OSSL_STORE_INFO_get0_PKEY(), OSSL_STORE_INFO_get0_CERT(), ... | |||
| * NULL is returned on error, which may include that the data found at the URI | |||
| * can't be figured out for certain or is ambiguous. | |||
| */ | |||
| OSSL_STORE_INFO *OSSL_STORE_load(OSSL_STORE_CTX *ctx); | |||
| /* | |||
| * Check if end of data (end of file) is reached | |||
| * Returns 1 on end, 0 otherwise. | |||
| */ | |||
| int OSSL_STORE_eof(OSSL_STORE_CTX *ctx); | |||
| /* | |||
| * Check if an error occurred | |||
| * Returns 1 if it did, 0 otherwise. | |||
| */ | |||
| int OSSL_STORE_error(OSSL_STORE_CTX *ctx); | |||
| /* | |||
| * Close the channel | |||
| * Returns 1 on success, 0 on error. | |||
| */ | |||
| int OSSL_STORE_close(OSSL_STORE_CTX *ctx); | |||
| /*- | |||
| * Extracting OpenSSL types from and creating new OSSL_STORE_INFOs | |||
| * --------------------------------------------------------------- | |||
| */ | |||
| /* | |||
| * Types of data that can be ossl_stored in a OSSL_STORE_INFO. | |||
| * OSSL_STORE_INFO_NAME is typically found when getting a listing of | |||
| * available "files" / "tokens" / what have you. | |||
| */ | |||
| # define OSSL_STORE_INFO_NAME 1 /* char * */ | |||
| # define OSSL_STORE_INFO_PARAMS 2 /* EVP_PKEY * */ | |||
| # define OSSL_STORE_INFO_PKEY 3 /* EVP_PKEY * */ | |||
| # define OSSL_STORE_INFO_CERT 4 /* X509 * */ | |||
| # define OSSL_STORE_INFO_CRL 5 /* X509_CRL * */ | |||
| /* | |||
| * Functions to generate OSSL_STORE_INFOs, one function for each type we | |||
| * support having in them, as well as a generic constructor. | |||
| * | |||
| * In all cases, ownership of the object is transferred to the OSSL_STORE_INFO | |||
| * and will therefore be freed when the OSSL_STORE_INFO is freed. | |||
| */ | |||
| OSSL_STORE_INFO *OSSL_STORE_INFO_new_NAME(char *name); | |||
| int OSSL_STORE_INFO_set0_NAME_description(OSSL_STORE_INFO *info, char *desc); | |||
| OSSL_STORE_INFO *OSSL_STORE_INFO_new_PARAMS(EVP_PKEY *params); | |||
| OSSL_STORE_INFO *OSSL_STORE_INFO_new_PKEY(EVP_PKEY *pkey); | |||
| OSSL_STORE_INFO *OSSL_STORE_INFO_new_CERT(X509 *x509); | |||
| OSSL_STORE_INFO *OSSL_STORE_INFO_new_CRL(X509_CRL *crl); | |||
| /* | |||
| * Functions to try to extract data from a OSSL_STORE_INFO. | |||
| */ | |||
| int OSSL_STORE_INFO_get_type(const OSSL_STORE_INFO *info); | |||
| const char *OSSL_STORE_INFO_get0_NAME(const OSSL_STORE_INFO *info); | |||
| char *OSSL_STORE_INFO_get1_NAME(const OSSL_STORE_INFO *info); | |||
| const char *OSSL_STORE_INFO_get0_NAME_description(const OSSL_STORE_INFO *info); | |||
| char *OSSL_STORE_INFO_get1_NAME_description(const OSSL_STORE_INFO *info); | |||
| EVP_PKEY *OSSL_STORE_INFO_get0_PARAMS(const OSSL_STORE_INFO *info); | |||
| EVP_PKEY *OSSL_STORE_INFO_get1_PARAMS(const OSSL_STORE_INFO *info); | |||
| EVP_PKEY *OSSL_STORE_INFO_get0_PKEY(const OSSL_STORE_INFO *info); | |||
| EVP_PKEY *OSSL_STORE_INFO_get1_PKEY(const OSSL_STORE_INFO *info); | |||
| X509 *OSSL_STORE_INFO_get0_CERT(const OSSL_STORE_INFO *info); | |||
| X509 *OSSL_STORE_INFO_get1_CERT(const OSSL_STORE_INFO *info); | |||
| X509_CRL *OSSL_STORE_INFO_get0_CRL(const OSSL_STORE_INFO *info); | |||
| X509_CRL *OSSL_STORE_INFO_get1_CRL(const OSSL_STORE_INFO *info); | |||
| const char *OSSL_STORE_INFO_type_string(int type); | |||
| /* | |||
| * Free the OSSL_STORE_INFO | |||
| */ | |||
| void OSSL_STORE_INFO_free(OSSL_STORE_INFO *info); | |||
| /*- | |||
| * Functions to construct a search URI from a base URI and search criteria | |||
| * ----------------------------------------------------------------------- | |||
| */ | |||
| /* OSSL_STORE search types */ | |||
| # define OSSL_STORE_SEARCH_BY_NAME 1 /* subject in certs, issuer in CRLs */ | |||
| # define OSSL_STORE_SEARCH_BY_ISSUER_SERIAL 2 | |||
| # define OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT 3 | |||
| # define OSSL_STORE_SEARCH_BY_ALIAS 4 | |||
| /* To check what search types the scheme handler supports */ | |||
| int OSSL_STORE_supports_search(OSSL_STORE_CTX *ctx, int search_type); | |||
| /* Search term constructors */ | |||
| /* | |||
| * The input is considered to be owned by the caller, and must therefore | |||
| * remain present throughout the lifetime of the returned OSSL_STORE_SEARCH | |||
| */ | |||
| OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_name(X509_NAME *name); | |||
| OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_issuer_serial(X509_NAME *name, | |||
| const ASN1_INTEGER | |||
| *serial); | |||
| OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_key_fingerprint(const EVP_MD *digest, | |||
| const unsigned char | |||
| *bytes, size_t len); | |||
| OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_alias(const char *alias); | |||
| /* Search term destructor */ | |||
| void OSSL_STORE_SEARCH_free(OSSL_STORE_SEARCH *search); | |||
| /* Search term accessors */ | |||
| int OSSL_STORE_SEARCH_get_type(const OSSL_STORE_SEARCH *criterion); | |||
| X509_NAME *OSSL_STORE_SEARCH_get0_name(OSSL_STORE_SEARCH *criterion); | |||
| const ASN1_INTEGER *OSSL_STORE_SEARCH_get0_serial(const OSSL_STORE_SEARCH | |||
| *criterion); | |||
| const unsigned char *OSSL_STORE_SEARCH_get0_bytes(const OSSL_STORE_SEARCH | |||
| *criterion, size_t *length); | |||
| const char *OSSL_STORE_SEARCH_get0_string(const OSSL_STORE_SEARCH *criterion); | |||
| const EVP_MD *OSSL_STORE_SEARCH_get0_digest(const OSSL_STORE_SEARCH *criterion); | |||
| /* | |||
| * Add search criterion and expected return type (which can be unspecified) | |||
| * to the loading channel. This MUST happen before the first OSSL_STORE_load(). | |||
| */ | |||
| int OSSL_STORE_expect(OSSL_STORE_CTX *ctx, int expected_type); | |||
| int OSSL_STORE_find(OSSL_STORE_CTX *ctx, OSSL_STORE_SEARCH *search); | |||
| /*- | |||
| * Function to register a loader for the given URI scheme. | |||
| * ------------------------------------------------------- | |||
| * | |||
| * The loader receives all the main components of an URI except for the | |||
| * scheme. | |||
| */ | |||
| typedef struct ossl_store_loader_st OSSL_STORE_LOADER; | |||
| OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(ENGINE *e, const char *scheme); | |||
| const ENGINE *OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER *loader); | |||
| const char *OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER *loader); | |||
| /* struct ossl_store_loader_ctx_st is defined differently by each loader */ | |||
| typedef struct ossl_store_loader_ctx_st OSSL_STORE_LOADER_CTX; | |||
| typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_open_fn)(const OSSL_STORE_LOADER | |||
| *loader, | |||
| const char *uri, | |||
| const UI_METHOD *ui_method, | |||
| void *ui_data); | |||
| int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader, | |||
| OSSL_STORE_open_fn open_function); | |||
| typedef int (*OSSL_STORE_ctrl_fn)(OSSL_STORE_LOADER_CTX *ctx, int cmd, | |||
| va_list args); | |||
| int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader, | |||
| OSSL_STORE_ctrl_fn ctrl_function); | |||
| typedef int (*OSSL_STORE_expect_fn)(OSSL_STORE_LOADER_CTX *ctx, int expected); | |||
| int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER *loader, | |||
| OSSL_STORE_expect_fn expect_function); | |||
| typedef int (*OSSL_STORE_find_fn)(OSSL_STORE_LOADER_CTX *ctx, | |||
| OSSL_STORE_SEARCH *criteria); | |||
| int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER *loader, | |||
| OSSL_STORE_find_fn find_function); | |||
| typedef OSSL_STORE_INFO *(*OSSL_STORE_load_fn)(OSSL_STORE_LOADER_CTX *ctx, | |||
| const UI_METHOD *ui_method, | |||
| void *ui_data); | |||
| int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader, | |||
| OSSL_STORE_load_fn load_function); | |||
| typedef int (*OSSL_STORE_eof_fn)(OSSL_STORE_LOADER_CTX *ctx); | |||
| int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader, | |||
| OSSL_STORE_eof_fn eof_function); | |||
| typedef int (*OSSL_STORE_error_fn)(OSSL_STORE_LOADER_CTX *ctx); | |||
| int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader, | |||
| OSSL_STORE_error_fn error_function); | |||
| typedef int (*OSSL_STORE_close_fn)(OSSL_STORE_LOADER_CTX *ctx); | |||
| int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader, | |||
| OSSL_STORE_close_fn close_function); | |||
| void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader); | |||
| int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader); | |||
| OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme); | |||
| /*- | |||
| * Functions to list STORE loaders | |||
| * ------------------------------- | |||
| */ | |||
| int OSSL_STORE_do_all_loaders(void (*do_function) (const OSSL_STORE_LOADER | |||
| *loader, void *do_arg), | |||
| void *do_arg); | |||
| # ifdef __cplusplus | |||
| } | |||
| # endif | |||
| #endif | |||
| @ -1,91 +0,0 @@ | |||
| /* | |||
| * Generated by util/mkerr.pl DO NOT EDIT | |||
| * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_OSSL_STOREERR_H | |||
| # define HEADER_OSSL_STOREERR_H | |||
| # ifndef HEADER_SYMHACKS_H | |||
| # include <openssl/symhacks.h> | |||
| # endif | |||
| # ifdef __cplusplus | |||
| extern "C" | |||
| # endif | |||
| int ERR_load_OSSL_STORE_strings(void); | |||
| /* | |||
| * OSSL_STORE function codes. | |||
| */ | |||
| # define OSSL_STORE_F_FILE_CTRL 129 | |||
| # define OSSL_STORE_F_FILE_FIND 138 | |||
| # define OSSL_STORE_F_FILE_GET_PASS 118 | |||
| # define OSSL_STORE_F_FILE_LOAD 119 | |||
| # define OSSL_STORE_F_FILE_LOAD_TRY_DECODE 124 | |||
| # define OSSL_STORE_F_FILE_NAME_TO_URI 126 | |||
| # define OSSL_STORE_F_FILE_OPEN 120 | |||
| # define OSSL_STORE_F_OSSL_STORE_ATTACH_PEM_BIO 127 | |||
| # define OSSL_STORE_F_OSSL_STORE_EXPECT 130 | |||
| # define OSSL_STORE_F_OSSL_STORE_FILE_ATTACH_PEM_BIO_INT 128 | |||
| # define OSSL_STORE_F_OSSL_STORE_FIND 131 | |||
| # define OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT 100 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CERT 101 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CRL 102 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME 103 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME_DESCRIPTION 135 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PARAMS 104 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PKEY 105 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CERT 106 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CRL 107 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_NEW_EMBEDDED 123 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_NEW_NAME 109 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PARAMS 110 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PKEY 111 | |||
| # define OSSL_STORE_F_OSSL_STORE_INFO_SET0_NAME_DESCRIPTION 134 | |||
| # define OSSL_STORE_F_OSSL_STORE_INIT_ONCE 112 | |||
| # define OSSL_STORE_F_OSSL_STORE_LOADER_NEW 113 | |||
| # define OSSL_STORE_F_OSSL_STORE_OPEN 114 | |||
| # define OSSL_STORE_F_OSSL_STORE_OPEN_INT 115 | |||
| # define OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT 117 | |||
| # define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ALIAS 132 | |||
| # define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ISSUER_SERIAL 133 | |||
| # define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT 136 | |||
| # define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_NAME 137 | |||
| # define OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT 116 | |||
| # define OSSL_STORE_F_TRY_DECODE_PARAMS 121 | |||
| # define OSSL_STORE_F_TRY_DECODE_PKCS12 122 | |||
| # define OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED 125 | |||
| /* | |||
| * OSSL_STORE reason codes. | |||
| */ | |||
| # define OSSL_STORE_R_AMBIGUOUS_CONTENT_TYPE 107 | |||
| # define OSSL_STORE_R_BAD_PASSWORD_READ 115 | |||
| # define OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC 113 | |||
| # define OSSL_STORE_R_FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST 121 | |||
| # define OSSL_STORE_R_INVALID_SCHEME 106 | |||
| # define OSSL_STORE_R_IS_NOT_A 112 | |||
| # define OSSL_STORE_R_LOADER_INCOMPLETE 116 | |||
| # define OSSL_STORE_R_LOADING_STARTED 117 | |||
| # define OSSL_STORE_R_NOT_A_CERTIFICATE 100 | |||
| # define OSSL_STORE_R_NOT_A_CRL 101 | |||
| # define OSSL_STORE_R_NOT_A_KEY 102 | |||
| # define OSSL_STORE_R_NOT_A_NAME 103 | |||
| # define OSSL_STORE_R_NOT_PARAMETERS 104 | |||
| # define OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR 114 | |||
| # define OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE 108 | |||
| # define OSSL_STORE_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES 119 | |||
| # define OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED 109 | |||
| # define OSSL_STORE_R_UNREGISTERED_SCHEME 105 | |||
| # define OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE 110 | |||
| # define OSSL_STORE_R_UNSUPPORTED_OPERATION 118 | |||
| # define OSSL_STORE_R_UNSUPPORTED_SEARCH_TYPE 120 | |||
| # define OSSL_STORE_R_URI_AUTHORITY_UNSUPPORTED 111 | |||
| #endif | |||
| @ -1,37 +0,0 @@ | |||
| /* | |||
| * Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved. | |||
| * | |||
| * Licensed under the OpenSSL license (the "License"). You may not use | |||
| * this file except in compliance with the License. You can obtain a copy | |||
| * in the file LICENSE in the source distribution or at | |||
| * https://www.openssl.org/source/license.html | |||
| */ | |||
| #ifndef HEADER_SYMHACKS_H | |||
| # define HEADER_SYMHACKS_H | |||
| # include <openssl/e_os2.h> | |||
| /* Case insensitive linking causes problems.... */ | |||
| # if defined(OPENSSL_SYS_VMS) | |||
| # undef ERR_load_CRYPTO_strings | |||
| # define ERR_load_CRYPTO_strings ERR_load_CRYPTOlib_strings | |||
| # undef OCSP_crlID_new | |||
| # define OCSP_crlID_new OCSP_crlID2_new | |||
| # undef d2i_ECPARAMETERS | |||
| # define d2i_ECPARAMETERS d2i_UC_ECPARAMETERS | |||
| # undef i2d_ECPARAMETERS | |||
| # define i2d_ECPARAMETERS i2d_UC_ECPARAMETERS | |||
| # undef d2i_ECPKPARAMETERS | |||
| # define d2i_ECPKPARAMETERS d2i_UC_ECPKPARAMETERS | |||
| # undef i2d_ECPKPARAMETERS | |||
| # define i2d_ECPKPARAMETERS i2d_UC_ECPKPARAMETERS | |||
| /* This one clashes with CMS_data_create */ | |||
| # undef cms_Data_create | |||
| # define cms_Data_create priv_cms_Data_create | |||
| # endif | |||
| #endif /* ! defined HEADER_VMS_IDHACKS_H */ | |||