abc/GmSSL
1
0
Fork 0
mirror of https://github.com/guanzhi/GmSSL.git synced 2026-09-21 21:03:40 +08:00
Code Issues Packages Projects Releases Wiki Activity

remove warnings

Browse Source
This commit is contained in:
Zhi Guan
2020-06-19 15:56:33 +08:00
parent ec29454f1d
commit 5a000d0998
42 changed files with 6607 additions and 5928 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
apps/progs.h
View File

@@ -197,7 +197,7 @@ static FUNCTION functions[] = {
#endif
{ FT_general, "paiutl", paiutl_main, paiutl_options },
{ FT_general, "passwd", passwd_main, passwd_options },
#ifndef OPENSSL_NO_DES
#ifndef OPENSSL_NO_PKCS12
{ FT_general, "pkcs12", pkcs12_main, pkcs12_options },
#endif
#ifndef OPENSSL_NO_PKCS7

2
apps/progs.pl
View File

@@ -77,7 +77,7 @@ my %cmd_disabler = (
gendh => "dh",
dhparam => "dh",
ecparam => "ec",
pkcs12 => "des",
pkcs12 => "pkcs12",
);
foreach my $cmd (@ARGV) {
my $str=" { FT_general, \"$cmd\", ${cmd}_main, ${cmd}_options },\n";

25
crypto/ec/ec_err.c
View File

@@ -25,9 +25,6 @@ static ERR_STRING_DATA EC_str_functs[] = {
{ERR_FUNC(EC_F_D2I_ECPKPARAMETERS), "d2i_ECPKParameters"},
{ERR_FUNC(EC_F_D2I_ECPRIVATEKEY), "d2i_ECPrivateKey"},
{ERR_FUNC(EC_F_DO_EC_KEY_PRINT), "do_EC_KEY_print"},
{ERR_FUNC(EC_F_ECAHE_CIPHERTEXT_SIZE), "ECAHE_ciphertext_size"},
{ERR_FUNC(EC_F_ECAHE_DECRYPT), "ECAHE_decrypt"},
{ERR_FUNC(EC_F_ECAHE_ENCRYPT), "ECAHE_encrypt"},
{ERR_FUNC(EC_F_ECDH_CMS_DECRYPT), "ecdh_cms_decrypt"},
{ERR_FUNC(EC_F_ECDH_CMS_SET_SHARED_INFO), "ecdh_cms_set_shared_info"},
{ERR_FUNC(EC_F_ECDH_COMPUTE_KEY), "ECDH_compute_key"},
@@ -141,8 +138,6 @@ static ERR_STRING_DATA EC_str_functs[] = {
{ERR_FUNC(EC_F_EC_GROUP_CHECK_DISCRIMINANT),
"EC_GROUP_check_discriminant"},
{ERR_FUNC(EC_F_EC_GROUP_COPY), "EC_GROUP_copy"},
{ERR_FUNC(EC_F_EC_GROUP_GENERATE_TYPE1CURVE),
"EC_GROUP_generate_type1curve"},
{ERR_FUNC(EC_F_EC_GROUP_GET_CURVE_GF2M), "EC_GROUP_get_curve_GF2m"},
{ERR_FUNC(EC_F_EC_GROUP_GET_CURVE_GFP), "EC_GROUP_get_curve_GFp"},
{ERR_FUNC(EC_F_EC_GROUP_GET_DEGREE), "EC_GROUP_get_degree"},
@@ -153,11 +148,6 @@ static ERR_STRING_DATA EC_str_functs[] = {
"EC_GROUP_get_pentanomial_basis"},
{ERR_FUNC(EC_F_EC_GROUP_GET_TRINOMIAL_BASIS),
"EC_GROUP_get_trinomial_basis"},
{ERR_FUNC(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA),
"EC_GROUP_get_type1curve_eta"},
{ERR_FUNC(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA),
"EC_GROUP_get_type1curve_zeta"},
{ERR_FUNC(EC_F_EC_GROUP_IS_TYPE1CURVE), "EC_GROUP_is_type1curve"},
{ERR_FUNC(EC_F_EC_GROUP_NEW), "EC_GROUP_new"},
{ERR_FUNC(EC_F_EC_GROUP_NEW_BY_CURVE_NAME), "EC_GROUP_new_by_curve_name"},
{ERR_FUNC(EC_F_EC_GROUP_NEW_FROM_DATA), "ec_group_new_from_data"},
@@ -165,7 +155,6 @@ static ERR_STRING_DATA EC_str_functs[] = {
"EC_GROUP_new_from_ecparameters"},
{ERR_FUNC(EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS),
"EC_GROUP_new_from_ecpkparameters"},
{ERR_FUNC(EC_F_EC_GROUP_NEW_TYPE1CURVE), "EC_GROUP_new_type1curve"},
{ERR_FUNC(EC_F_EC_GROUP_SET_CURVE_GF2M), "EC_GROUP_set_curve_GF2m"},
{ERR_FUNC(EC_F_EC_GROUP_SET_CURVE_GFP), "EC_GROUP_set_curve_GFp"},
{ERR_FUNC(EC_F_EC_GROUP_SET_GENERATOR), "EC_GROUP_set_generator"},
@@ -186,7 +175,6 @@ static ERR_STRING_DATA EC_str_functs[] = {
{ERR_FUNC(EC_F_EC_POINTS_MAKE_AFFINE), "EC_POINTs_make_affine"},
{ERR_FUNC(EC_F_EC_POINT_ADD), "EC_POINT_add"},
{ERR_FUNC(EC_F_EC_POINT_CMP), "EC_POINT_cmp"},
{ERR_FUNC(EC_F_EC_POINT_CMP_FPPOINT), "EC_POINT_cmp_fppoint"},
{ERR_FUNC(EC_F_EC_POINT_COPY), "EC_POINT_copy"},
{ERR_FUNC(EC_F_EC_POINT_DBL), "EC_POINT_dbl"},
{ERR_FUNC(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M),
@@ -195,7 +183,6 @@ static ERR_STRING_DATA EC_str_functs[] = {
"EC_POINT_get_affine_coordinates_GFp"},
{ERR_FUNC(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP),
"EC_POINT_get_Jprojective_coordinates_GFp"},
{ERR_FUNC(EC_F_EC_POINT_HASH2POINT), "EC_POINT_hash2point"},
{ERR_FUNC(EC_F_EC_POINT_INVERT), "EC_POINT_invert"},
{ERR_FUNC(EC_F_EC_POINT_IS_AT_INFINITY), "EC_POINT_is_at_infinity"},
{ERR_FUNC(EC_F_EC_POINT_IS_ON_CURVE), "EC_POINT_is_on_curve"},
@@ -215,7 +202,6 @@ static ERR_STRING_DATA EC_str_functs[] = {
"EC_POINT_set_Jprojective_coordinates_GFp"},
{ERR_FUNC(EC_F_EC_POINT_SET_TO_INFINITY), "EC_POINT_set_to_infinity"},
{ERR_FUNC(EC_F_EC_PRE_COMP_NEW), "ec_pre_comp_new"},
{ERR_FUNC(EC_F_EC_TYPE1CURVE_TATE), "EC_type1curve_tate"},
{ERR_FUNC(EC_F_EC_WNAF_MUL), "ec_wNAF_mul"},
{ERR_FUNC(EC_F_EC_WNAF_PRECOMPUTE_MULT), "ec_wNAF_precompute_mult"},
{ERR_FUNC(EC_F_I2D_ECIESPARAMETERS), "i2d_ECIESParameters"},
@@ -243,17 +229,13 @@ static ERR_STRING_DATA EC_str_functs[] = {
{ERR_FUNC(EC_F_SM2P256_PRE_COMP_NEW), "sm2p256_pre_comp_new"},
{ERR_FUNC(EC_F_SM2_COMPUTE_ID_DIGEST), "SM2_compute_id_digest"},
{ERR_FUNC(EC_F_SM2_COMPUTE_MESSAGE_DIGEST), "SM2_compute_message_digest"},
{ERR_FUNC(EC_F_SM2_COMPUTE_SHARE_KEY), "SM2_compute_share_key"},
{ERR_FUNC(EC_F_SM2_DO_ENCRYPT), "SM2_do_encrypt"},
{ERR_FUNC(EC_F_SM2_GET_PUBLIC_KEY_DATA), "SM2_get_public_key_data"},
{ERR_FUNC(EC_F_SM2_KAP_COMPUTE_KEY), "SM2_KAP_compute_key"},
{ERR_FUNC(EC_F_SM2_KAP_CTX_INIT), "SM2_KAP_CTX_init"},
{ERR_FUNC(EC_F_SM2_KAP_FINAL_CHECK), "SM2_KAP_final_check"},
{ERR_FUNC(EC_F_SM2_KAP_PREPARE), "SM2_KAP_prepare"},
{ERR_FUNC(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK),
"type1curve_eval_line_textbook"},
{ERR_FUNC(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK),
"type1curve_eval_miller_textbook"},
{ERR_FUNC(EC_F_TYPE1CURVE_PHI), "type1curve_phi"},
{0, NULL}
};
@@ -291,8 +273,6 @@ static ERR_STRING_DATA EC_str_reasons[] = {
{ERR_REASON(EC_R_GEN_MAC_FAILED), "gen mac failed"},
{ERR_REASON(EC_R_GET_PUBLIC_KEY_DATA_FAILURE),
"get public key data failure"},
{ERR_REASON(EC_R_GET_TYPE1CURVE_ZETA_FAILURE),
"get type1curve zeta failure"},
{ERR_REASON(EC_R_GF2M_NOT_SUPPORTED), "gf2m not supported"},
{ERR_REASON(EC_R_GROUP2PKPARAMETERS_FAILURE),
"group2pkparameters failure"},
@@ -335,9 +315,6 @@ static ERR_STRING_DATA EC_str_reasons[] = {
"invalid sm2 kap checksum value"},
{ERR_REASON(EC_R_INVALID_SPLIT_PARAMETER), "invalid split parameter"},
{ERR_REASON(EC_R_INVALID_TRINOMIAL_BASIS), "invalid trinomial basis"},
{ERR_REASON(EC_R_INVALID_TYPE1CURVE), "invalid type1curve"},
{ERR_REASON(EC_R_INVALID_TYPE1_CURVE), "invalid type1 curve"},
{ERR_REASON(EC_R_INVLID_TYPE1CURVE), "invlid type1curve"},
{ERR_REASON(EC_R_KDF_PARAMETER_ERROR), "kdf parameter error"},
{ERR_REASON(EC_R_KEYS_NOT_SET), "keys not set"},
{ERR_REASON(EC_R_MISSING_PARAMETERS), "missing parameters"},

37
crypto/evp/names2.c
View File

@@ -14,11 +14,6 @@
#include <openssl/x509.h>
#include "internal/evp_int.h"
const EVP_CIPHER *EVP_get_default_cipher(void)
{
return NULL;
}
/*
* use MD5 as default:
* X509_REQ_to_X509 x509_r2x.c
@@ -40,35 +35,3 @@ const EVP_MD *EVP_get_default_digest(void)
return NULL;
#endif
}
static void cipher_name_len(const EVP_CIPHER *cipher, const char *from,
const char *to, void *x)
{
*((int *)x) += strlen(EVP_CIPHER_name(cipher));
}
static void cipher_name(const EVP_CIPHER *cipher, const char *from,
const char *to, void *x)
{
strcat((char *)x, EVP_CIPHER_name(cipher));
}
char *EVP_get_ciphernames(int aliases)
{
char *ret = NULL;
int len = 0;
EVP_CIPHER_do_all_sorted(cipher_name_len, &len);
ret = OPENSSL_zalloc(len);
if (!ret) {
return NULL;
}
EVP_CIPHER_do_all_sorted(cipher_name, ret);
return ret;
}
char *EVP_get_digestnames(int aliases)
{
return "sm3:sha1:sha256";
}

56
crypto/gmapi/gmapi_sdf_ec.c
View File

@@ -401,7 +401,7 @@ int SM2CiphertextValue_get_ECCCipher(const SM2CiphertextValue *cv,
* structure and prepared enough buffer to hold variable length
* ciphertext
*/
if (ref->L < ASN1_STRING_length(cv->ciphertext)) {
if (ref->L < (unsigned int)ASN1_STRING_length(cv->ciphertext)) {
GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_GET_ECCCIPHER,
GMAPI_R_BUFFER_TOO_SMALL);
return 0;
@@ -625,18 +625,6 @@ end:
return ret;
}
/*
ECCCipher *d2i_ECCCipher_bio(BIO *bp, ECCCipher **a)
{
return NULL;
}
ECCCipher *d2i_ECCCipher_fp(FILE *fp, ECCCipher **a)
{
return NULL;
}
*/
int i2d_ECCCipher(ECCCipher *a, unsigned char **pp)
{
int ret;
@@ -652,24 +640,18 @@ int i2d_ECCCipher(ECCCipher *a, unsigned char **pp)
return ret;
}
/*
int i2d_ECCCipher_bio(BIO *bp, ECCCipher *a)
{
return 0;
}
int i2d_ECCCipher_fp(FILE *fp, ECCCipher *a)
{
return 0;
}
*/
ECCSignature *d2i_ECCSignature(ECCSignature **a, const unsigned char **pp, long length)
{
ECCSignature *ret = NULL;
ECCSignature *sdf_sig = NULL;
ECDSA_SIG *sig = NULL;
/* FIXME: `a` not set */
(void)a;
if (!(sig = d2i_ECDSA_SIG(NULL, pp, length))) {
GMAPIerr(GMAPI_F_D2I_ECCSIGNATURE, ERR_R_EC_LIB);
goto end;
@@ -694,18 +676,6 @@ end:
return ret;
}
/*
ECCSignature *d2i_ECCSignature_bio(BIO *bp, ECCSignature **a)
{
return NULL;
}
ECCSignature *d2i_ECCSignature_fp(FILE *fp, ECCSignature **a)
{
return NULL;
}
*/
int i2d_ECCSignature(ECCSignature *a, unsigned char **pp)
{
int ret;
@@ -721,18 +691,6 @@ int i2d_ECCSignature(ECCSignature *a, unsigned char **pp)
return ret;
}
/*
int i2d_ECCSignature_bio(BIO *bp, ECCSignature *a)
{
return 0;
}
int i2d_ECCSignature_fp(FILE *fp, ECCSignature *a)
{
return 0;
}
*/
# ifndef OPENSSL_NO_ECIES
ECIES_CIPHERTEXT_VALUE *ECIES_CIPHERTEXT_VALUE_new_from_ECCCipher(
const ECCCipher *ref)

15
crypto/gmapi/gmapi_skf_ec.c
View File

@@ -309,7 +309,7 @@ int SM2CiphertextValue_get_ECCCIPHERBLOB(const SM2CiphertextValue *cv,
return 0;
}
if (blob->CipherLen < ASN1_STRING_length(cv->ciphertext)) {
if (blob->CipherLen < (unsigned int)ASN1_STRING_length(cv->ciphertext)) {
GMAPIerr(GMAPI_F_SM2CIPHERTEXTVALUE_GET_ECCCIPHERBLOB,
GMAPI_R_BUFFER_TOO_SMALL);
return 0;
@@ -378,7 +378,8 @@ int ECDSA_SIG_set_ECCSIGNATUREBLOB(ECDSA_SIG *sig, const ECCSIGNATUREBLOB *blob)
int ECDSA_SIG_get_ECCSIGNATUREBLOB(const ECDSA_SIG *sig, ECCSIGNATUREBLOB *blob)
{
if ((BN_num_bytes(sig->r) > sizeof(blob->r)) || (BN_num_bytes(sig->s) > sizeof(blob->s))) {
if (((size_t)BN_num_bytes(sig->r) > sizeof(blob->r))
|| ((size_t)BN_num_bytes(sig->s) > sizeof(blob->s))) {
GMAPIerr(GMAPI_F_ECDSA_SIG_GET_ECCSIGNATUREBLOB, GMAPI_R_INVALID_BIGNUM_LENGTH);
return 0;
}
@@ -545,13 +546,13 @@ int ECIES_CIPHERTEXT_VALUE_get_ECCCIPHERBLOB(const ECIES_CIPHERTEXT_VALUE *cv, E
goto end;
}
if (BN_num_bytes(x) > sizeof(blob->XCoordinate)) {
if ((size_t)BN_num_bytes(x) > sizeof(blob->XCoordinate)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, GMAPI_R_INVALID_SKF_EC_CIPHERTEXT);
goto end;
}
BN_bn2bin(x, blob->XCoordinate + sizeof(blob->XCoordinate) - BN_num_bytes(x));
if (BN_num_bytes(y) > sizeof(blob->YCoordinate)) {
if ((size_t)BN_num_bytes(y) > sizeof(blob->YCoordinate)) {
GMAPIerr(GMAPI_F_ECIES_CIPHERTEXT_VALUE_GET_ECCCIPHERBLOB, GMAPI_R_INVALID_SKF_EC_CIPHERTEXT);
goto end;
}
@@ -585,6 +586,9 @@ ECCCIPHERBLOB *d2i_ECCCIPHERBLOB(ECCCIPHERBLOB **a, const unsigned char **pp, lo
ECCCIPHERBLOB *blob = NULL;
SM2CiphertextValue *cv = NULL;
/* FIXME: set `a` */
(void)a;
if (!(cv = d2i_SM2CiphertextValue(NULL, pp, length))) {
GMAPIerr(GMAPI_F_D2I_ECCCIPHERBLOB, ERR_R_SM2_LIB);
goto end;
@@ -632,6 +636,9 @@ ECCSIGNATUREBLOB *d2i_ECCSIGNATUREBLOB(ECCSIGNATUREBLOB **a, const unsigned char
ECCSIGNATUREBLOB *blob = NULL;
ECDSA_SIG *sig = NULL;
/* FIXME: set `a` */
(void)a;
if (!(sig = d2i_ECDSA_SIG(NULL, pp, length))) {
GMAPIerr(GMAPI_F_D2I_ECCSIGNATUREBLOB, ERR_R_EC_LIB);
goto end;

16
crypto/sdf/sdf_err.c
View File

@@ -1,6 +1,6 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
* 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
@@ -42,8 +42,6 @@ static ERR_STRING_DATA SDF_str_functs[] = {
{ERR_FUNC(SDF_F_SDF_EXPORTSIGNPUBLICKEY_RSA),
"SDF_ExportSignPublicKey_RSA"},
{ERR_FUNC(SDF_F_SDF_EXTERNALENCRYPT_ECC), "SDF_ExternalEncrypt_ECC"},
{ERR_FUNC(SDF_F_SDF_EXTERNALPRIVATEKEYOPERATION_RSA),
"SDF_EXTERNALPRIVATEKEYOPERATION_RSA"},
{ERR_FUNC(SDF_F_SDF_EXTERNALPUBLICKEYOPERATION_RSA),
"SDF_ExternalPublicKeyOperation_RSA"},
{ERR_FUNC(SDF_F_SDF_EXTERNALVERIFY_ECC), "SDF_ExternalVerify_ECC"},
@@ -106,29 +104,23 @@ static ERR_STRING_DATA SDF_str_reasons[] = {
{ERR_REASON(SDF_R_FILE_ALREADY_EXIST), "file already exist"},
{ERR_REASON(SDF_R_FILE_NOT_EXIST), "file not exist"},
{ERR_REASON(SDF_R_HARDWARE_ERROR), "hardware error"},
{ERR_REASON(SDF_R_INVALID_CIPHER_ALGOR), "invalid cipher algor"},
{ERR_REASON(SDF_R_INVALID_DIGEST_ALGOR), "invalid digest algor"},
{ERR_REASON(SDF_R_INVALID_FILE_OFFSET), "invalid file offset"},
{ERR_REASON(SDF_R_INVALID_FILE_SIZE), "invalid file size"},
{ERR_REASON(SDF_R_INVALID_INPUT_ARGUMENT), "invalid input argument"},
{ERR_REASON(SDF_R_INVALID_KEY), "invalid key"},
{ERR_REASON(SDF_R_INVALID_KEY_LENGTH), "invalid key length"},
{ERR_REASON(SDF_R_INVALID_KEY_TYPE), "invalid key type"},
{ERR_REASON(SDF_R_INVALID_OUTPUT_ARGUMENT), "invalid output argument"},
{ERR_REASON(SDF_R_INVALID_SANSEC_ECCCIPHER_LENGTH),
"invalid sansec ecccipher length"},
{ERR_REASON(SDF_R_INVALID_SDF_LIBRARY), "invalid sdf library"},
{ERR_REASON(SDF_R_INVALID_SESSION_HANDLE), "invalid session handle"},
{ERR_REASON(SDF_R_INVALID_SM2_CIPHERTEXT_LENGTH),
"invalid sm2 ciphertext length"},
{ERR_REASON(SDF_R_KEY_NOT_EXIST), "key not exist"},
{ERR_REASON(SDF_R_LOAD_LIBRARY_FAILURE), "load library failure"},
{ERR_REASON(SDF_R_MAC_ERROR), "mac error"},
{ERR_REASON(SDF_R_METHOD_OPERATION_FAILURE), "method operation failure"},
{ERR_REASON(SDF_R_MULTI_STEP_OPERATION_ERROR),
"multi step operation error"},
{ERR_REASON(SDF_R_NOT_IMPLEMENTED), "not implemented"},
{ERR_REASON(SDF_R_NOT_INITIALIZED), "not initialized"},
{ERR_REASON(SDF_R_NOT_SUPPORTED), "not supported"},
{ERR_REASON(SDF_R_NOT_SUPPORTED_CIPHER_ALGOR),
"not supported cipher algor"},
{ERR_REASON(SDF_R_NOT_SUPPORTED_DIGEST_ALGOR),
@@ -139,7 +131,6 @@ static ERR_STRING_DATA SDF_str_reasons[] = {
"no private key access right"},
{ERR_REASON(SDF_R_OPEN_DEVICE_FAILURE), "open device failure"},
{ERR_REASON(SDF_R_OPEN_SESSION_FAILURE), "open session failure"},
{ERR_REASON(SDF_R_OPERATION_FAILED), "operation failed"},
{ERR_REASON(SDF_R_OPERATION_NOT_SUPPORTED), "operation not supported"},
{ERR_REASON(SDF_R_PRIVATE_KEY_OPERATION_FAILURE),
"private key operation failure"},
@@ -247,9 +238,6 @@ static ERR_STRING_DATA SDF_str_reasons[] = {
{ERR_REASON(SDF_R_SANSEC_SOCKET_TIMEOUT), "sansec socket timeout"},
{ERR_REASON(SDF_R_SANSEC_SYNC_ERROR), "sansec sync error"},
{ERR_REASON(SDF_R_SANSEC_SYNC_LOGIN_ERROR), "sansec sync login error"},
{ERR_REASON(SDF_R_SDF_METHOD_RETURN_FAILURE),
"sdf method return failure"},
{ERR_REASON(SDF_R_SDF_OPERATION_FAILED), "sdf operation failed"},
{ERR_REASON(SDF_R_SIGNING_FAILURE), "signing failure"},
{ERR_REASON(SDF_R_SUCCESS), "success"},
{ERR_REASON(SDF_R_SYMMETRIC_OPERATION_FAILURE),

7
crypto/sdf/sdf_ext.c
View File

@@ -235,7 +235,12 @@ int SDF_ImportKey(
unsigned int uiKeyLength,
void **phKeyHandle)
{
return 0;
(void)hSessionHandle;
(void)pucKey;
(void)uiKeyLength;
(void)phKeyHandle;
SDFerr(SDF_F_SDF_IMPORTKEY, SDF_R_NOT_IMPLEMENTED);
return SDR_NOTSUPPORT;
}
int SDF_NewECCCipher(ECCCipher **cipher, size_t ulDataLen)

2
crypto/sdf/sdf_lib.c
View File

@@ -124,7 +124,7 @@ static SDF_ERR_REASON sdf_errors[] = {
static unsigned long sdf_get_error_reason(int err)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sdf_errors); i++) {
if (err == sdf_errors[i].err) {
return sdf_errors[i].reason;

20
crypto/sdf/sdf_sansec.c
View File

@@ -100,7 +100,7 @@ static SDF_ALGOR_PAIR sansec_ciphers[] = {
static unsigned int sansec_cipher_vendor2std(unsigned int vendor_id)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sansec_ciphers); i++) {
if (vendor_id == sansec_ciphers[i].vendor_id) {
return sansec_ciphers[i].std_id;
@@ -111,7 +111,7 @@ static unsigned int sansec_cipher_vendor2std(unsigned int vendor_id)
static unsigned int sansec_cipher_std2vendor(unsigned int std_id)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sansec_ciphers); i++) {
if (std_id == sansec_ciphers[i].std_id) {
return sansec_ciphers[i].vendor_id;
@@ -123,7 +123,7 @@ static unsigned int sansec_cipher_std2vendor(unsigned int std_id)
static unsigned int sansec_cipher_cap(unsigned int vendor_cap)
{
unsigned int std_cap = 0;
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sansec_ciphers); i++) {
if (vendor_cap & sansec_ciphers[i].vendor_id) {
@@ -146,7 +146,7 @@ static SDF_ALGOR_PAIR sansec_digests[] = {
static unsigned int sansec_digest_vendor2std(unsigned int vendor_id)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sansec_digests); i++) {
if (vendor_id == sansec_digests[i].vendor_id) {
return sansec_digests[i].std_id;
@@ -157,7 +157,7 @@ static unsigned int sansec_digest_vendor2std(unsigned int vendor_id)
static unsigned int sansec_digest_std2vendor(unsigned int std_id)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sansec_digests); i++) {
if (std_id == sansec_digests[i].std_id) {
return sansec_digests[i].vendor_id;
@@ -169,7 +169,7 @@ static unsigned int sansec_digest_std2vendor(unsigned int std_id)
static unsigned int sansec_digest_cap(unsigned int vendor_cap)
{
unsigned int std_cap = 0;
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sansec_digests); i++) {
if (vendor_cap & sansec_digests[i].vendor_id) {
@@ -192,7 +192,7 @@ static SDF_ALGOR_PAIR sansec_pkeys[] = {
static unsigned int sansec_pkey_vendor2std(unsigned int vendor_id)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sansec_pkeys); i++) {
if (vendor_id == sansec_pkeys[i].vendor_id) {
return sansec_pkeys[i].std_id;
@@ -203,7 +203,7 @@ static unsigned int sansec_pkey_vendor2std(unsigned int vendor_id)
static unsigned int sansec_pkey_std2vendor(unsigned int std_id)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sansec_pkeys); i++) {
if (std_id == sansec_pkeys[i].std_id) {
return sansec_pkeys[i].vendor_id;
@@ -215,7 +215,7 @@ static unsigned int sansec_pkey_std2vendor(unsigned int std_id)
static unsigned int sansec_pkey_cap(unsigned int vendor_cap)
{
unsigned int std_cap = 0;
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(sansec_pkeys); i++) {
if (vendor_cap & sansec_pkeys[i].vendor_id) {
@@ -341,7 +341,7 @@ static SDF_ERR_REASON sansec_errors[] = {
static unsigned long sansec_get_error_reason(int err)
{
int i = 0;
size_t i = 0;
for (i = 0; i < OSSL_NELEM(sansec_errors); i++) {
if (err == sansec_errors[i].err) {
return sansec_errors[i].reason;

7
crypto/skf/skf_prn.c
View File

@@ -356,7 +356,12 @@ ULONG SKF_PrintECCSignature(BIO *out, ECCSIGNATUREBLOB *blob)
ULONG DEVAPI SKF_GetAlgorName(ULONG ulAlgID, LPSTR *szName)
{
return SAR_OK;
char *name;
if ((name = skf_algor_name(ulAlgID)) != NULL) {
*szName = (LPSTR)&name;
return SAR_OK;
}
return SAR_FAIL;
}
ULONG DEVAPI SKF_PrintErrorString(BIO *out, ULONG ulError)

14
crypto/skf/skf_wisec.c
View File

@@ -81,7 +81,7 @@ static SKF_ALGOR_PAIR wisec_ciphers[] = {
static ULONG wisec_get_cipher_algor(ULONG vendor_id)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(wisec_ciphers); i++) {
if (vendor_id == wisec_ciphers[i].vendor_id) {
return wisec_ciphers[i].std_id;
@@ -93,7 +93,7 @@ static ULONG wisec_get_cipher_algor(ULONG vendor_id)
static ULONG wisec_get_cipher_cap(ULONG vendor_cap)
{
ULONG std_cap = 0;
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(wisec_ciphers); i++) {
if (vendor_cap & wisec_ciphers[i].vendor_id) {
std_cap |= wisec_ciphers[i].std_id;
@@ -110,7 +110,7 @@ static SKF_ALGOR_PAIR wisec_digests[] = {
static ULONG wisec_get_digest_algor(ULONG vendor_id)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(wisec_digests); i++) {
if (vendor_id == wisec_digests[i].vendor_id) {
return wisec_digests[i].std_id;
@@ -122,7 +122,7 @@ static ULONG wisec_get_digest_algor(ULONG vendor_id)
static ULONG wisec_get_digest_cap(ULONG vendor_cap)
{
ULONG std_cap = 0;
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(wisec_digests); i++) {
if (vendor_cap & wisec_digests[i].vendor_id) {
std_cap |= wisec_digests[i].std_id;
@@ -143,7 +143,7 @@ static SKF_ALGOR_PAIR wisec_pkeys[] = {
static ULONG wisec_get_pkey_algor(ULONG vendor_id)
{
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(wisec_pkeys); i++) {
if (vendor_id == wisec_pkeys[i].vendor_id) {
return wisec_pkeys[i].std_id;
@@ -155,7 +155,7 @@ static ULONG wisec_get_pkey_algor(ULONG vendor_id)
static ULONG wisec_get_pkey_cap(ULONG vendor_cap)
{
ULONG std_cap = 0;
int i;
size_t i;
for (i = 0; i < OSSL_NELEM(wisec_pkeys); i++) {
if (vendor_cap & wisec_pkeys[i].vendor_id) {
std_cap |= wisec_pkeys[i].std_id;
@@ -178,7 +178,7 @@ static SKF_ERR_REASON wisec_errors[] = {
static unsigned long wisec_get_error_reason(ULONG err)
{
int i = 0;
size_t i = 0;
for (i = 0; i < OSSL_NELEM(wisec_errors); i++) {
if (err == wisec_errors[i].err) {
return wisec_errors[i].reason;

2
crypto/sm2/sm2_enc.c
View File

@@ -248,7 +248,7 @@ int SM2_encrypt(int type, const unsigned char *in, size_t inlen,
if (!out) {
*outlen = clen;
return 1;
} else if (*outlen < clen) {
} else if (*outlen < (size_t)clen) {
SM2err(SM2_F_SM2_ENCRYPT, SM2_R_BUFFER_TOO_SMALL);
return 0;
}

18
crypto/sm2/sm2_exch.c
View File

@@ -563,7 +563,7 @@ int SM2_KAP_final_check(SM2_KAP_CTX *ctx, const unsigned char *checksum,
size_t checksumlen)
{
if (ctx->do_checksum) {
if (checksumlen != EVP_MD_size(ctx->checksum_md)) {
if (checksumlen != (size_t)EVP_MD_size(ctx->checksum_md)) {
ECerr(EC_F_SM2_KAP_FINAL_CHECK, EC_R_INVALID_SM2_KAP_CHECKSUM_LENGTH);
return 0;
}
@@ -581,6 +581,18 @@ int SM2_compute_share_key(unsigned char *out, size_t *outlen,
const EC_POINT *peer_pk, const unsigned char *peer_z, size_t peer_zlen,
const unsigned char *z, size_t zlen, EC_KEY *sk, int initiator)
{
memset(out, 1, *outlen);
return 1;
(void)out;
(void)outlen;
(void)peer_ephem;
(void)ephem;
(void)peer_pk;
(void)peer_z;
(void)peer_zlen;
(void)z;
(void)zlen;
(void)sk;
(void)initiator;
ECerr(EC_F_SM2_COMPUTE_SHARE_KEY, EC_R_NOT_IMPLEMENTED);
return 0;
}

2
crypto/sm2/sm2_id.c
View File

@@ -231,7 +231,7 @@ int SM2_compute_id_digest(const EVP_MD *md, const char *id, size_t idlen,
*outlen = EVP_MD_size(md);
return 1;
}
if (*outlen < EVP_MD_size(md)) {
if (*outlen < (size_t)EVP_MD_size(md)) {
ECerr(EC_F_SM2_COMPUTE_ID_DIGEST, EC_R_BUFFER_TOO_SMALL);
return 0;
}

23
crypto/sm2/sm2_lcl.h
View File

@@ -96,26 +96,3 @@ struct sm2_kap_ctx_st {
};
int SM2_ciphertext_size(const EC_KEY *ec_key, size_t inlen);
struct SM2_COSIGNER1_SHARE_st {
BIGNUM *a;
BIGNUM *b;
};
struct SM2_COSIGNER2_SHARE_st {
BIGNUM *a;
BIGNUM *b;
};
struct SM2_COSIGNER1_PROOF_st {
BIGNUM *a;
BIGNUM *b;
};
struct SM2_COSIGNER2_PROOF_st {
BIGNUM *a;
BIGNUM *b;
};

14
crypto/sm2/sm2_sign.c
View File

@@ -67,6 +67,12 @@ static void sm2_sign_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
BN_clear_free(bn);
CRYPTO_set_ex_data(ad, sm2_sign_idx, NULL);
}
(void)parent;
(void)ptr;
(void)idx;
(void)argl;
(void)argp;
}
static int sm2_sign_setup(EC_KEY *ec_key, BN_CTX *ctx_in, BIGNUM **kp, BIGNUM **xp)
@@ -542,6 +548,10 @@ int SM2_sign_ex(int type, const unsigned char *dgst, int dgstlen,
{
ECDSA_SIG *s;
if (type != NID_undef) {
return 0;
}
RAND_seed(dgst, dgstlen);
if (!(s = SM2_do_sign_ex(dgst, dgstlen, k, x, ec_key))) {
@@ -570,6 +580,10 @@ int SM2_verify(int type, const unsigned char *dgst, int dgstlen,
int derlen = -1;
int ret = -1;
if (type != NID_undef) {
return ret;
}
if (!(s = ECDSA_SIG_new())) {
return ret;
}

356
crypto/sm3/sm3_mb.c Executable file
View File

@@ -0,0 +1,356 @@
/* ====================================================================
* Copyright (c) 2014 - 2017 The GmSSL Project. 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. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the GmSSL Project.
* (http://gmssl.org/)"
*
* 4. The name "GmSSL Project" must not be used to endorse or promote
* products derived from this software without prior written
* permission. For written permission, please contact
* guanzhi1980@gmail.com.
*
* 5. Products derived from this software may not be called "GmSSL"
* nor may "GmSSL" appear in their names without prior written
* permission of the GmSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the GmSSL Project
* (http://gmssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED 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 THE GmSSL PROJECT OR
* ITS 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.
* ====================================================================
*/
#include <string.h>
#include <openssl/sm3.h>
#include "internal/rotate.h"
#include "internal/byteorder.h"
#include "modes_lcl.h"
#include <immintrin.h>
typedef struct {
uint32_t A[8];
uint32_t B[8];
uint32_t C[8];
uint32_t D[8];
uint32_t E[8];
uint32_t F[8];
uint32_t G[8];
uint32_t H[8];
} SM3_AVX2_CTX;
void sm3_mb_init(sm3_mb_ctx_t *ctx)
{
int i;
memset(ctx, 0, sizeof(*ctx));
for (i = 0; i < 8; i++) {
ctx->A[i] = 0x7380166F;
ctx->B[i] = 0x4914B2B9;
ctx->C[i] = 0x172442D7;
ctx->D[i] = 0xDA8A0600;
ctx->E[i] = 0xA96F30BC;
ctx->F[i] = 0x163138AA;
ctx->G[i] = 0xE38DEE4D;
ctx->H[i] = 0xB0FB0E4E;
}
}
void sm3_update(sm3_ctx_t *ctx, const unsigned char *data, size_t data_len)
{
size_t blocks = data_len / SM3_BLOCK_SIZE;
if (ctx->num) {
unsigned int left = SM3_BLOCK_SIZE - ctx->num;
if (data_len < left) {
memcpy(ctx->block + ctx->num, data, data_len);
ctx->num += data_len;
return;
} else {
memcpy(ctx->block + ctx->num, data, left);
sm3_compress(ctx->digest, ctx->block);
ctx->nblocks++;
data += left;
data_len -= left;
}
}
sm3_compress_blocks(ctx->digest, data, blocks);
ctx->nblocks += blocks;
data += SM3_BLOCK_SIZE * blocks;
data_len -= SM3_BLOCK_SIZE * blocks;
ctx->num = data_len;
if (data_len) {
memcpy(ctx->block, data, data_len);
}
}
void sm3_final(sm3_ctx_t *ctx, unsigned char *digest)
{
int i;
ctx->block[ctx->num] = 0x80;
if (ctx->num + 9 <= SM3_BLOCK_SIZE) {
memset(ctx->block + ctx->num + 1, 0, SM3_BLOCK_SIZE - ctx->num - 9);
} else {
memset(ctx->block + ctx->num + 1, 0, SM3_BLOCK_SIZE - ctx->num - 1);
sm3_compress(ctx->digest, ctx->block);
memset(ctx->block, 0, SM3_BLOCK_SIZE - 8);
}
PUTU32(ctx->block + 56, ctx->nblocks >> 23);
PUTU32(ctx->block + 60, (ctx->nblocks << 9) + (ctx->num << 3));
sm3_compress(ctx->digest, ctx->block);
for (i = 0; i < 8; i++) {
PUTU32(digest + i*4, ctx->digest[i]);
}
}
#define VPUT(addr, X) _mm256_store_si256((__m256i *)(addr), _mm256_load_si256((__m256i *)(addr), X))
# define _mm256_rotl_epi32(X, i) \
_mm256_xor_si256( \
_mm256_slli_epi32(a, i), \
_mm256_srli_epi32(a, 32 - i))
/* P0(X) = X ^ (X <<< 9) ^ (X <<< 17) */
#define P0(X) \
_mm256_xor_si256( \
_mm256_xor_si256(X, \
_mm256_rotl_epi32(X, 9)), \
_mm256_rotl_epi32(X, 17))
/* P1(X) = X ^ (X <<< 15) ^ (X <<< 23) */
#define P1(X) \
_mm256_xor_si256( \
_mm256_xor_si256(X, \
_mm256_rotl_epi32(X, 15)), \
_mm256_rotl_epi32(X, 23))
/* FF0(X, Y, Z) = X ^ Y ^ Z */
#define FF00(X,Y,Z) \
_mm256_xor_si256(X, _mm256_xor_si256(Y, Z))
/* FF16(X, Y, Z) = (X and Y) or (X and Z) or (Y and Z) */
#define FF16(X,Y,Z) \
_mm256_or_si256( \
_mm256_and_si256(X, Y), \
_mm256_or_si256( \
_mm256_and_si256(X, Z), \
_mm256_and_si256(Y, Z)))
/* GG00(X, Y, Z) = X ^ Y ^ Z */
#define G00(X,Y,Z) F00(X,Y,Z)
/* #define GG16(x,y,z) ((((y)^(z)) & (x)) ^ (z)) */
#define GG16(X,Y,Z) \
_mm256_xor_si256(Z, \
_mm256_and_si256(X, \
_mm256_xor_si256(Y, Z)))
#define R(A, B, C, D, E, F, G, H, xx) \
SS1 = ROL32((ROL32(A, 12) + E + K[j]), 7); \
A12 = VROL(A, 12); \
SS1 = VADD(A12, E); \
SS1 = VADD(SS1, K(j)); \
SS1 = VROL(SS1, 7); \
SS2 = VXOR(SS1, A12); \
TT1 = FF##xx(A, B, C);
TT1 = VADD(TT1, D);
TT1 = VADD(TT1, SS2);
TT1 = VXOR(W(j), W(j+4));
TT2 =
SS2 = SS1 ^ ROL32(A, 12); \
TT1 = FF##xx(A, B, C) + D + SS2 + (W[j] ^ W[j + 4]); \
TT2 = GG##xx(E, F, G) + H + SS1 + W[j]; \
B = ROL32(B, 9); \
H = TT1; \
F = ROL32(F, 19); \
D = P0(TT2); \
j++
#define R8(A, B, C, D, E, F, G, H, xx) \
R1(A, B, C, D, E, F, G, H, xx); \
R1(H, A, B, C, D, E, F, G, xx); \
R1(G, H, A, B, C, D, E, F, xx); \
R1(F, G, H, A, B, C, D, E, xx); \
R1(E, F, G, H, A, B, C, D, xx); \
R1(D, E, F, G, H, A, B, C, xx); \
R1(C, D, E, F, G, H, A, B, xx); \
R1(B, C, D, E, F, G, H, A, xx)
#define T00 0x79cc4519U
#define T16 0x7a879d8aU
#define K0 0x79cc4519U
#define K1 0xf3988a32U
#define K2 0xe7311465U
#define K3 0xce6228cbU
#define K4 0x9cc45197U
#define K5 0x3988a32fU
#define K6 0x7311465eU
#define K7 0xe6228cbcU
#define K8 0xcc451979U
#define K9 0x988a32f3U
#define K10 0x311465e7U
#define K11 0x6228cbceU
#define K12 0xc451979cU
#define K13 0x88a32f39U
#define K14 0x11465e73U
#define K15 0x228cbce6U
#define K16 0x9d8a7a87U
#define K17 0x3b14f50fU
#define K18 0x7629ea1eU
#define K19 0xec53d43cU
#define K20 0xd8a7a879U
#define K21 0xb14f50f3U
#define K22 0x629ea1e7U
#define K23 0xc53d43ceU
#define K24 0x8a7a879dU
#define K25 0x14f50f3bU
#define K26 0x29ea1e76U
#define K27 0x53d43cecU
#define K28 0xa7a879d8U
#define K29 0x4f50f3b1U
#define K30 0x9ea1e762U
#define K31 0x3d43cec5U
#define K32 0x7a879d8aU
#define K33 0xf50f3b14U
#define K34 0xea1e7629U
#define K35 0xd43cec53U
#define K36 0xa879d8a7U
#define K37 0x50f3b14fU
#define K38 0xa1e7629eU
#define K39 0x43cec53dU
#define K40 0x879d8a7aU
#define K41 0x0f3b14f5U
#define K42 0x1e7629eaU
#define K43 0x3cec53d4U
#define K44 0x79d8a7a8U
#define K45 0xf3b14f50U
#define K46 0xe7629ea1U
#define K47 0xcec53d43U
#define K48 0x9d8a7a87U
#define K49 0x3b14f50fU
#define K50 0x7629ea1eU
#define K51 0xec53d43cU
#define K52 0xd8a7a879U
#define K53 0xb14f50f3U
#define K54 0x629ea1e7U
#define K55 0xc53d43ceU
#define K56 0x8a7a879dU
#define K57 0x14f50f3bU
#define K58 0x29ea1e76U
#define K59 0x53d43cecU
#define K60 0xa7a879d8U
#define K61 0x4f50f3b1U
#define K62 0x9ea1e762U
#define K63 0x3d43cec5U
static void sm3_avx2_compress_blocks(uint32_t digest[8][8],
const unsigned char *data, size_t offset[8], size_t blocks)
{
VREG A, B, C, D, E, F, G, H;
VREG SS1, SS2, TT1, TT2;
uint32_t W[68][8];
int j;
while (blocks--) {
A = _mm256_load_si256((__m256i *)ctx->A);
B = _mm256_load_si256((__m256i *)ctx->B);
C = _mm256_load_si256((__m256i *)ctx->C);
D = _mm256_load_si256((__m256i *)ctx->D);
E = _mm256_load_si256((__m256i *)ctx->E);
F = _mm256_load_si256((__m256i *)ctx->F);
G = _mm256_load_si256((__m256i *)ctx->G);
H = _mm256_load_si256((__m256i *)ctx->H);
for (j = 0; j < 16; j++) {
W = _mm256_i32gather_epi32((int *)data, I, 4);
W = _mm255_shuffle_epi8(W, vindex_swap);
_mm256_store_si256((__m256i *)(w + j * 8), W);
}
for (; j < 68; j++) {
PUTV32(W[j],
P1(GETV32(W[j - 16]) ^ GETV32(W[j - 9]) ^ ROL32(GETV32(W[j - 3]), 15))
^ ROL32(GETV32(W[j - 13]), 7) ^ W[j - 6];
}
j = 0;
VPUT(ctx->A, A);
VPUT(ctx->B, B);
VPUT(ctx->C, C);
VPUT(ctx->D, D);
VPUT(ctx->E, E);
VPUT(ctx->F, F);
VPUT(ctx->G, G);
VPUT(ctx->H, H);
data += 64;
}
}
void sm3_compress(uint32_t digest[8], const unsigned char block[64])
{
return sm3_compress_blocks(digest, block, 1);
}
void sm3(const unsigned char *msg, size_t msglen,
unsigned char dgst[SM3_DIGEST_LENGTH])
{
sm3_ctx_t ctx;
sm3_init(&ctx);
sm3_update(&ctx, msg, msglen);
sm3_final(&ctx, dgst);
memset(&ctx, 0, sizeof(sm3_ctx_t));
}

221
crypto/sm3/sm3_simd.c Normal file
View File

@@ -0,0 +1,221 @@
#include <stdio.h>
#include <string.h>
#include <x86intrin.h>
#include <immintrin.h>
# define GETU32(p) \
((unsigned int)(p)[0] << 24 | \
(unsigned int)(p)[1] << 16 | \
(unsigned int)(p)[2] << 8 | \
(unsigned int)(p)[3])
# define ROL32(X,n) \
(((X) << (n)) | (((X) & 0xffffffff) >> (32-(n))))
# define P1(X) \
((X) ^ ROL32((X), 15) ^ ROL32((X), 23))
# define _mm_rotl_epi32(X, i) _mm_xor_si128( \
_mm_slli_epi32((X), i), _mm_srli_epi32((X), 32 - i))
# define P1_128(X) \
T = _mm_rotl_epi32((X), (23-15)); \
T = _mm_xor_si128(T, (X)); \
T = _mm_rotl_epi32(T, 15); \
X = _mm_xor_si128((X), T)
/*
# define GETU128(p) \
_mm_setr_epi32( \
*((unsigned int *)(((unsigned char *)(p)) + 0)), \
*((unsigned int *)(((unsigned char *)(p)) + 4)), \
*((unsigned int *)(((unsigned char *)(p)) + 8)), \
*((unsigned int *)(((unsigned char *)(p)) + 12)))
*/
# define GETU128(p) \
_mm_loadu_si128((__m128i *)(p))
/*
* _mm_lddqu_si128 SSE3 <pmmintrin.h> faster when data crosses a cache line boundary
* _mm_load_si128 SSE2 <emmintrin.h>
* _mm_loadu_si128 SSE2 <emmintrin.h> no aligned mem
* _mm_loadu_si32 SSE2 <immintrin.h> load u32 to lower 32-bit of xmm
* _mm_loadl_epi64 SSE2 <emmintrin.h> load u64 to lower 64-bit of xmm
* _mm_loadu_si64 SSE <immintrin.h> load unaligned u64 to lower 64-bit of xmm
*/
static void print_words(unsigned int W[68])
{
int i;
for (i = 0; i < 68; i++) {
printf("%08x ", W[i]);
if (i % 4 == 3)
printf("\n");
}
printf("\n");
}
static void expand(unsigned int W[68], const unsigned char data[64])
{
int j;
unsigned int X;
unsigned int T;
for (j = 0; j < 16; j++)
W[j] = GETU32(data + j*4);
for (; j < 68; j++) {
W[j] = P1(W[j - 16] ^ W[j - 9] ^ ROL32(W[j - 3], 15))
^ ROL32(W[j - 13], 7) ^ W[j - 6];
}
}
static void print_mm(const char *s, __m128i X) {
unsigned int buf[4];
int i;
_mm_store_si128((__m128i *)buf, X);
printf("%s = ", s);
for (i = 0; i < 4; i++) {
printf("%08x ", buf[i]);
}
printf("\n");
}
static __m128i V;
static __m128i M;
static __m128i M2;
static void expand_simd(unsigned int W[68], const unsigned char data[64])
{
__m128i X, T, R;
int j;
const uint32_t *p = (uint32_t *)data;
for (j = 0; j < 16; j += sizeof(X)/sizeof(W[0])) {
X = _mm_loadu_si128((__m128i *)(data + j * 4));
X = _mm_shuffle_epi8(X, V);
_mm_storeu_si128((__m128i *)(W + j), X);
}
for (j = 16; j < 68; j += 4) {
/* X = (W[j - 3], W[j - 2], W[j - 1], 0) */
X = _mm_loadu_si128((__m128i *)(W + j - 3));
X = _mm_andnot_si128(M, X);
X = _mm_rotl_epi32(X, 15);
T = _mm_loadu_si128((__m128i *)(W + j - 9));
X = _mm_xor_si128(X, T);
T = _mm_loadu_si128((__m128i *)(W + j - 16));
X = _mm_xor_si128(X, T);
/* P1() */
T = _mm_rotl_epi32(X, (23 - 15));
T = _mm_xor_si128(T, X);
T = _mm_rotl_epi32(T, 15);
X = _mm_xor_si128(X, T);
T = _mm_loadu_si128((__m128i *)(W + j - 13));
T = _mm_rotl_epi32(T, 7);
X = _mm_xor_si128(X, T);
T = _mm_loadu_si128((__m128i *)(W + j - 6));
X = _mm_xor_si128(X, T);
/* W[j + 3] ^= P1(ROL32(W[j + 1], 15)) */
R = _mm_shuffle_epi32(X, 0);
R = _mm_and_si128(R, M);
T = _mm_rotl_epi32(R, 15);
T = _mm_xor_si128(T, R);
T = _mm_rotl_epi32(T, 9);
R = _mm_xor_si128(R, T);
R = _mm_rotl_epi32(R, 6);
X = _mm_xor_si128(X, R);
_mm_storeu_si128((__m128i *)(W + j), X);
}
}
void test()
{
unsigned char block[64] __attribute__((aligned(0x10))) = {0};
unsigned int W1[68] __attribute__((aligned(0x10))) = {0};
unsigned int W2[68] __attribute__((aligned(0x10))) = {0};
int i;
for (i = 0; i < 64; i++)
block[i] = i;
printf("W1 = %08x\n", &W1[0]);
printf("W2 = %08x\n", &W2[0]);
expand(W1, block);
expand_simd(W2, block);
for (i = 0; i < 68; i++) {
printf("%08x ", W1[i]);
if (i % 4 == 3) printf("\n");
}
printf("\n");
for (i = 0; i < 68; i++) {
printf("%08x ", W2[i]);
if (i % 4 == 3) printf("\n");
}
printf("\n");
for (i = 0; i < 68; i++) {
if (W1[i] != W2[i]) {
printf("failed on %d\n" , i);
printf("%08x\n", W1[i]);
printf("%08x\n", W2[i]);
}
}
}
int main(int argc, char **argv)
{
unsigned char block[64] __attribute__((aligned(0x10))) = {0};
unsigned int W[68] __attribute__((aligned(0x10))) = {0};
int i;
V = _mm_setr_epi8(3,2,1,0,7,6,5,4,11,10,9,8,15,14,13,12);
M = _mm_setr_epi32(0, 0, 0, 0xffffffff);
for (i = 0; i < 64; i++)
block[i] = i;
/*
for (i = 0; i < 1000000; i++) {
expand(W, block);
}
*/
/*
for (i = 0; i < 1000000; i++) {
expand_simd(W, block);
}
*/
test();
return 0;
}

28
crypto/sm9/sm9_ameth.c
View File

@@ -99,6 +99,10 @@ static int sm9_master_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
static int sm9_master_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
{
/* FIXME: implement this! */
(void)a;
(void)b;
/*
if (OBJ_cmp(a->pkey.sm9_master->pairing, b->pkey.sm9_master->pairing) != 0
|| OBJ_cmp(a->pkey.sm9_master->scheme, b->pkey.sm9_master->scheme) != 0
@@ -186,12 +190,14 @@ static int do_sm9_master_key_print(BIO *bp, const SM9_MASTER_KEY *x, int off, in
static int sm9_master_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
ASN1_PCTX *ctx)
{
(void)ctx; /* FIXME: how to use ASN1_PCTX? */
return do_sm9_master_key_print(bp, pkey->pkey.sm9_master, indent, 0);
}
static int sm9_master_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
ASN1_PCTX *ctx)
{
(void)ctx; /* FIXME: how to use ASN1_PCTX? */
return do_sm9_master_key_print(bp, pkey->pkey.sm9_master, indent, 1);
}
@@ -232,16 +238,25 @@ static int sm9_master_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
static int sm9_pkey_size(const EVP_PKEY *pkey)
{
/* FIXME: wrap a SM9_xxx() */
(void)pkey;
return 32 * 12;
}
static int sm9_pkey_bits(const EVP_PKEY *pkey)
{
/* FIXME: wrap a SM9_xxx() */
(void)pkey;
return 256 * 12;
}
static int sm9_pkey_security_bits(const EVP_PKEY *pkey)
{
/* FIXME: wrap a SM9_xxx() */
(void)pkey;
return 256/2;
}
@@ -252,6 +267,11 @@ static void sm9_master_pkey_free(EVP_PKEY *pkey)
static int sm9_master_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
{
(void)pkey;
(void)op;
(void)arg1;
(void)arg2;
return -2;
}
@@ -434,12 +454,14 @@ static int do_sm9_key_print(BIO *bp, const SM9PrivateKey *x, int off, int priv)
static int sm9_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
ASN1_PCTX *ctx)
{
(void)ctx; /* FIXME: how to use ASN1_PCTX? */
return do_sm9_key_print(bp, pkey->pkey.sm9, indent, 0);
}
static int sm9_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
ASN1_PCTX *ctx)
{
(void)ctx; /* FIXME: how to use ASN1_PCTX? */
return do_sm9_key_print(bp, pkey->pkey.sm9, indent, 1);
}
@@ -485,6 +507,12 @@ static void sm9_pkey_free(EVP_PKEY *pkey)
static int sm9_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
{
/* FIXME */
(void)pkey;
(void)op;
(void)arg1;
(void)arg2;
return -2;
}

15
crypto/sm9/sm9_asn1.c
View File

@@ -59,6 +59,10 @@
static int sm9_master_key_cb(int operation, ASN1_VALUE **pval,
const ASN1_ITEM *it, void *exarg)
{
/* FIXME: usage of it and exarg? */
(void)it;
(void)exarg;
if (operation == ASN1_OP_NEW_PRE) {
*pval = (ASN1_VALUE *)SM9_MASTER_KEY_new();
if (*pval)
@@ -93,6 +97,10 @@ IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(SM9_MASTER_KEY,SM9PublicParameters,S
static int sm9_key_cb(int operation, ASN1_VALUE **pval,
const ASN1_ITEM *it, void *exarg)
{
/* FIXME: usage of it and exarg? */
(void)it;
(void)exarg;
if (operation == ASN1_OP_NEW_PRE) {
*pval = (ASN1_VALUE *)SM9_KEY_new();
if (*pval)
@@ -144,6 +152,10 @@ IMPLEMENT_ASN1_DUP_FUNCTION(SM9Signature)
int SM9PublicKey_gmtls_encode(SM9PublicKey *pk, unsigned char key[1024])
{
/* FIMXE: implement this */
(void)pk;
(void)key;
return 0;
}
@@ -177,9 +189,6 @@ SM9PrivateKey *d2i_SM9PrivateKey_bio(BIO *bp, SM9PrivateKey **a)
return ASN1_item_d2i_bio(ASN1_ITEM_rptr(SM9PrivateKey), bp, a);
}
int i2d_SM9Signature_bio(BIO *bp, SM9Signature *a)
{
return ASN1_item_i2d_bio(ASN1_ITEM_rptr(SM9Signature), bp, a);

6
crypto/sm9/sm9_bn.c Normal file
View File

@@ -0,0 +1,6 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

7
crypto/sm9/sm9_enc.c
View File

@@ -196,7 +196,7 @@ int SM9_wrap_key(int type, /* NID_sm9kdf_with_sm3 */
return 0;
}
if (keylen > EVP_MD_size(kdf_md) * 255) {
if (keylen > (size_t)EVP_MD_size(kdf_md) * 255) {
SM9err(SM9_F_SM9_WRAP_KEY, SM9_R_INVALID_KEM_KEY_LENGTH);
return 0;
}
@@ -343,7 +343,8 @@ int SM9_encrypt(int type,
size_t C1_len;
unsigned char mac[EVP_MAX_MD_SIZE];
unsigned int maclen = sizeof(mac);
int len, i;
int len;
size_t i;
/* parse type */
switch (type) {
@@ -465,7 +466,7 @@ int SM9_decrypt(int type,
*outlen = C2_len;
ret = 1;
goto end;
} else if (*outlen < C2_len) {
} else if (*outlen < (size_t)C2_len) {
SM9err(SM9_F_SM9_DECRYPT, SM9_R_BUFFER_TOO_SMALL);
goto end;
}

147
crypto/sm9/sm9_lcl.h
View File

@@ -162,35 +162,164 @@ const BIGNUM *SM9_get0_generator2_y0(void);
const BIGNUM *SM9_get0_generator2_y1(void);
typedef BIGNUM *fp2_t[2];
int fp2_init(fp2_t a, BN_CTX *ctx);
void fp2_cleanup(fp2_t a);
void fp2_clear_cleanup(fp2_t a);
int fp2_is_zero(const fp2_t a);
int fp2_is_zero(const fp2_t a);
int fp2_print(const fp2_t a);
int fp2_is_one(const fp2_t a);
void fp2_set_zero(fp2_t r);
int fp2_set_one(fp2_t r);
int fp2_copy(fp2_t r, const fp2_t a);
int fp2_set(fp2_t r, const BIGNUM *a0, const BIGNUM *a1);
int fp2_set_hex(fp2_t r, const char *str[2]);
int fp2_set_u(fp2_t r);
int fp2_set_5u(fp2_t r);
int fp2_set_bn(fp2_t r, const BIGNUM *a);
int fp2_set_word(fp2_t r, unsigned long a);
int fp2_equ(const fp2_t a, const fp2_t b);
int fp2_equ_hex(const fp2_t a, const char *str[2], BN_CTX *ctx);
int fp2_add_word(fp2_t r, const fp2_t a, unsigned long b, const BIGNUM *p, BN_CTX *ctx);
int fp2_add(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx);
int fp2_dbl(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx);
int fp2_tri(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx);
int fp2_sub(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx);
int fp2_neg(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx);
int fp2_mul(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx);
int fp2_mul_u(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx);
int fp2_mul_num(fp2_t r, const fp2_t a, const BIGNUM *n, const BIGNUM *p, BN_CTX *ctx);
int fp2_sqr(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx);
int fp2_sqr_u(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx);
int fp2_inv(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx);
int fp2_div(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx);
int fp2_to_bin(const fp2_t a, unsigned char to[64]);
int fp2_from_bin(fp2_t a, const unsigned char from[64]);
int fp2_test(const BIGNUM *p, BN_CTX *ctx);
typedef fp2_t fp4_t[2];
int fp4_init(fp4_t a, BN_CTX *ctx);
void fp4_cleanup(fp4_t a);
void fp4_clear_cleanup(fp4_t a);
int fp4_print(const fp4_t a);
int fp4_is_zero(const fp4_t a);
int fp4_is_one(const fp4_t a);
void fp4_set_zero(fp4_t r);
int fp4_set_one(fp4_t r);
int fp4_set_bn(fp4_t r, const BIGNUM *a);
int fp4_set_word(fp4_t r, unsigned long a);
int fp4_set_fp2(fp4_t r, const fp2_t a);
int fp4_set(fp4_t r, const fp2_t a0, const fp2_t a1);
int fp4_set_hex(fp4_t r, const char *str[4]);
int fp4_copy(fp4_t r, const fp4_t a);
int fp4_set_u(fp4_t r);
int fp4_set_v(fp4_t r);
int fp4_equ(const fp4_t a, const fp4_t b);
int fp4_equ_hex(const fp4_t a, const char *str[4], BN_CTX *ctx);
int fp4_to_bin(const fp4_t a, unsigned char to[128]);
int fp4_from_bin(fp4_t a, const unsigned char from[128]);
int fp4_add(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx);
int fp4_dbl(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx);
int fp4_sub(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx);
int fp4_neg(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx);
int fp4_mul(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx);
int fp4_mul_v(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx);
int fp4_sqr(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx);
int fp4_sqr_v(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx);
int fp4_inv(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx);
int fp4_test(const BIGNUM *p, BN_CTX *ctx);
typedef fp4_t fp12_t[3];
int fp12_init(fp12_t a, BN_CTX *ctx);
void fp12_cleanup(fp12_t a);
void fp12_clear_cleanup(fp12_t a);
int fp12_print(const fp12_t a);
int fp12_is_zero(const fp12_t a);
int fp12_is_one(const fp12_t a);
void fp12_set_zero(fp12_t r);
int fp12_set_one(fp12_t r);
int fp12_copy(fp12_t r, const fp12_t a);
int fp12_set(fp12_t r, const fp4_t a0, const fp4_t a1, const fp4_t a2);
int fp12_set_hex(fp12_t r, const char *str[12]);
int fp12_set_fp4(fp12_t r, const fp4_t a);
int fp12_set_fp2(fp12_t r, const fp2_t a);
int fp12_set_bn(fp12_t r, const BIGNUM *a);
int fp12_set_word(fp12_t r, unsigned long a);
int fp12_set_u(fp12_t r);
int fp12_set_v(fp12_t r);
int fp12_set_w(fp12_t r);
int fp12_set_w_sqr(fp12_t r);
int fp12_equ(const fp12_t a, const fp12_t b);
int fp12_equ_hex(const fp12_t a, const char *str[12], BN_CTX *ctx);
int fp12_to_bin(const fp12_t a, unsigned char to[384]);
int fp12_from_bin(fp4_t a, const unsigned char from[384]);
int fp12_add(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx);
int fp12_dbl(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx);
int fp12_tri(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx);
int fp12_sub(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx);
int fp12_neg(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx);
int fp12_mul(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx);
int fp12_sqr(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx);
int fp12_inv(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx);
int fp12_div(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx);
int fp12_pow(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx);
int fp12_fast_expo_p1(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx);
int fp12_fast_expo_p2(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx);
int fp12_test(const BIGNUM *p, BN_CTX *ctx);
typedef struct point_t {
fp2_t X;
fp2_t Y;
fp2_t Z;
} point_t;
int fp12_init(fp12_t a, BN_CTX *ctx);
int fp12_mul(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx);
int fp12_pow(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx);
int fp12_to_bin(const fp12_t a, unsigned char to[384]);
int fp12_print(const fp12_t a);
void fp12_cleanup(fp12_t a);
int point_init(point_t *P, BN_CTX *ctx);
int point_copy(point_t *R, const point_t *P);
void point_cleanup(point_t *P);
void point_print(const point_t *P);
int point_copy(point_t *R, const point_t *P);
int point_equ(const point_t *P, const point_t *Q);
int point_equ_hex(const point_t *P, const char *str[4], BN_CTX *ctx);
int point_is_at_infinity(const point_t *P);
int point_set_to_infinity(point_t *P);
int point_set_affine_coordinates(point_t *P, const fp2_t x, const fp2_t y);
int point_set_affine_coordinates_hex(point_t *P, const char *str[4]);
int point_set_affine_coordinates_bignums(point_t *P,
const BIGNUM *x0, const BIGNUM *x1, const BIGNUM *y0, const BIGNUM *y1);
int point_get_affine_coordinates(const point_t *P, fp2_t x, fp2_t y);
int point_get_ext_affine_coordinates(const point_t *P, fp12_t x, fp12_t y, const BIGNUM *p, BN_CTX *ctx);
int point_set_ext_affine_coordinates(point_t *P, const fp12_t x, const fp12_t y, const BIGNUM *p, BN_CTX *ctx);
int point_is_on_curve(point_t *P, const BIGNUM *p, BN_CTX *ctx);
int point_to_octets(const point_t *P, unsigned char to[129], BN_CTX *ctx);
int point_from_octets(point_t *P, const unsigned char from[129], const BIGNUM *p, BN_CTX *ctx);
int point_add(point_t *R, const point_t *A, const point_t *B, const BIGNUM *p, BN_CTX *ctx);
int point_dbl(point_t *R, const point_t *P, const BIGNUM *p, BN_CTX *ctx);
int point_neg(point_t *R, const point_t *P, const BIGNUM *p, BN_CTX *ctx);
int point_sub(point_t *R, const point_t *P, const point_t *Q, const BIGNUM *p, BN_CTX *ctx);
int point_mul(point_t *R, const BIGNUM *k, const point_t *P, const BIGNUM *p, BN_CTX *ctx);
int point_mul_generator(point_t *R, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx);
void point_cleanup(point_t *P);
int eval_tangent(fp12_t r, const point_t *T, const BIGNUM *xP, const BIGNUM *yP,
const BIGNUM *p, BN_CTX *ctx);
int eval_line(fp12_t r, const point_t *T, const point_t *Q,
const BIGNUM *xP, const BIGNUM *yP,
const BIGNUM *p, BN_CTX *ctx);
int frobenius(point_t *R, const point_t *P, const BIGNUM *p, BN_CTX *ctx);
int final_expo(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx);
int fast_final_expo(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx);
int rate(fp12_t f, const point_t *Q, const BIGNUM *xP, const BIGNUM *yP,
const BIGNUM *a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx);
int rate_test(void);
int rate_pairing(fp12_t r, const point_t *Q, const EC_POINT *P, BN_CTX *ctx);
int params_test(void);
int sm9_check_pairing(int nid);
int sm9_check_scheme(int nid);
int sm9_check_hash1(int nid);

26
crypto/sm9/sm9_lib.c
View File

@@ -139,12 +139,22 @@ void SM9_KEY_free(SM9_KEY *key)
int SM9PrivateKey_get_gmtls_public_key(SM9PublicParameters *mpk,
SM9PrivateKey *sk, unsigned char pub_key[1024])
{
/* FIXME */
(void)mpk;
(void)sk;
(void)pub_key;
return 0;
}
int SM9PublicKey_get_gmtls_encoded(SM9PublicParameters *mpk,
SM9PublicKey *pk, unsigned char encoded[1024])
{
/* FIXME */
(void)mpk;
(void)pk;
(void)encoded;
return 0;
}
@@ -186,26 +196,41 @@ int SM9_KEY_up_ref(SM9_KEY *sk)
int sm9_check_pairing(int nid)
{
/* FIXME */
(void)nid;
return 1;
}
int sm9_check_scheme(int nid)
{
/* FIXME */
(void)nid;
return 1;
}
int sm9_check_hash1(int nid)
{
/* FIXME */
(void)nid;
return 1;
}
int sm9_check_encrypt_scheme(int nid)
{
/* FIXME */
(void)nid;
return 1;
}
int sm9_check_sign_scheme(int nid)
{
/* FIXME */
(void)nid;
return 1;
}
@@ -314,5 +339,4 @@ int SM9_hash2(const EVP_MD *md, BIGNUM **r,
}
#endif

10
crypto/sm9/sm9_pmeth.c
View File

@@ -183,6 +183,11 @@ static int pkey_sm9_master_encrypt(EVP_PKEY_CTX *ctx,
static int pkey_sm9_master_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
{
/* FIXME */
(void)ctx;
(void)key;
(void)keylen;
/*
SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
SM9_MASTER_KEY *sm9_master = EVP_PKEY_get0_SM9_MASTER(
@@ -387,6 +392,11 @@ static int pkey_sm9_decrypt(EVP_PKEY_CTX *ctx,
static int pkey_sm9_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
{
/* FIXME */
(void)ctx;
(void)key;
(void)keylen;
return -2;
}

249
crypto/sm9/sm9_rate.c
View File

@@ -56,7 +56,9 @@
#include "sm9_lcl.h"
static int fp2_init(fp2_t a, BN_CTX *ctx)
#define NOSM9_FAST
int fp2_init(fp2_t a, BN_CTX *ctx)
{
a[0] = NULL;
a[1] = NULL;
@@ -72,7 +74,7 @@ static int fp2_init(fp2_t a, BN_CTX *ctx)
return 1;
}
static void fp2_cleanup(fp2_t a)
void fp2_cleanup(fp2_t a)
{
BN_free(a[0]);
BN_free(a[1]);
@@ -80,7 +82,7 @@ static void fp2_cleanup(fp2_t a)
a[1] = NULL;
}
static void fp2_clear_cleanup(fp2_t a)
void fp2_clear_cleanup(fp2_t a)
{
BN_clear_free(a[0]);
BN_clear_free(a[1]);
@@ -88,96 +90,93 @@ static void fp2_clear_cleanup(fp2_t a)
a[1] = NULL;
}
static int fp2_is_zero(const fp2_t a)
int fp2_is_zero(const fp2_t a)
{
return BN_is_zero(a[0])
&& BN_is_zero(a[1]);
}
static int fp2_print(const fp2_t a)
int fp2_print(const fp2_t a)
{
printf("%s\n", BN_bn2hex(a[0]));
printf("%s\n", BN_bn2hex(a[1]));
return 1;
}
static int fp2_is_one(const fp2_t a)
int fp2_is_one(const fp2_t a)
{
return BN_is_one(a[0])
&& BN_is_zero(a[1]);
}
static void fp2_set_zero(fp2_t r)
void fp2_set_zero(fp2_t r)
{
BN_zero(r[0]);
BN_zero(r[1]);
}
static int fp2_set_one(fp2_t r)
int fp2_set_one(fp2_t r)
{
BN_zero(r[1]);
return BN_one(r[0]);
}
static int fp2_copy(fp2_t r, const fp2_t a)
int fp2_copy(fp2_t r, const fp2_t a)
{
return BN_copy(r[0], a[0])
&& BN_copy(r[1], a[1]);
}
static int fp2_set(fp2_t r, const BIGNUM *a0, const BIGNUM *a1)
int fp2_set(fp2_t r, const BIGNUM *a0, const BIGNUM *a1)
{
return BN_copy(r[0], a0)
&& BN_copy(r[1], a1);
}
static int fp2_set_hex(fp2_t r, const char *str[2])
int fp2_set_hex(fp2_t r, const char *str[2])
{
return BN_hex2bn(&r[0], str[0])
&& BN_hex2bn(&r[1], str[1]);
}
static int fp2_set_u(fp2_t r)
int fp2_set_u(fp2_t r)
{
BN_zero(r[0]);
return BN_one(r[1]);
}
static int fp2_set_5u(fp2_t r)
int fp2_set_5u(fp2_t r)
{
BN_zero(r[0]);
return BN_set_word(r[1], 5);
}
static int fp2_set_bn(fp2_t r, const BIGNUM *a)
int fp2_set_bn(fp2_t r, const BIGNUM *a)
{
BN_zero(r[1]);
return BN_copy(r[0], a) != NULL;
}
static int fp2_set_word(fp2_t r, unsigned long a)
int fp2_set_word(fp2_t r, unsigned long a)
{
BN_zero(r[1]);
return BN_set_word(r[0], a);
}
static int fp2_equ(const fp2_t a, const fp2_t b)
int fp2_equ(const fp2_t a, const fp2_t b)
{
return !BN_cmp(a[0], b[0]) && !BN_cmp(a[1], b[1]);
}
#if SM9_TEST
static int fp2_equ_hex(const fp2_t a, const char *str[2], BN_CTX *ctx)
int fp2_equ_hex(const fp2_t a, const char *str[2], BN_CTX *ctx)
{
fp2_t t;
fp2_init(t, ctx);
fp2_set_hex(t, str);
return fp2_equ(a, t);
}
#endif
#if SM9_TEST
static int fp2_add_word(fp2_t r, const fp2_t a, unsigned long b, const BIGNUM *p, BN_CTX *ctx)
int fp2_add_word(fp2_t r, const fp2_t a, unsigned long b, const BIGNUM *p, BN_CTX *ctx)
{
BIGNUM *w = NULL;
if (!(w = BN_CTX_get(ctx))
@@ -190,21 +189,20 @@ static int fp2_add_word(fp2_t r, const fp2_t a, unsigned long b, const BIGNUM *p
BN_free(w);
return 1;
}
#endif
static int fp2_add(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
int fp2_add(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
{
return BN_mod_add(r[0], a[0], b[0], p, ctx)
&& BN_mod_add(r[1], a[1], b[1], p, ctx);
}
static int fp2_dbl(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
int fp2_dbl(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
{
return BN_mod_add(r[0], a[0], a[0], p, ctx)
&& BN_mod_add(r[1], a[1], a[1], p, ctx);
}
static int fp2_tri(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
int fp2_tri(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
{
fp2_t t;
if (!fp2_init(t, ctx)
@@ -217,19 +215,19 @@ static int fp2_tri(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
static int fp2_sub(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
int fp2_sub(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
{
return BN_mod_sub(r[0], a[0], b[0], p, ctx)
&& BN_mod_sub(r[1], a[1], b[1], p, ctx);
}
static int fp2_neg(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
int fp2_neg(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
{
return BN_mod_sub(r[0], p, a[0], p, ctx)
&& BN_mod_sub(r[1], p, a[1], p, ctx);
}
static int fp2_mul(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
int fp2_mul(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
{
BIGNUM *t = NULL;
BIGNUM *r0 = NULL;
@@ -262,7 +260,7 @@ static int fp2_mul(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CT
return 1;
}
static int fp2_mul_u(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
int fp2_mul_u(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
{
BIGNUM *r0 = NULL;
BIGNUM *r1 = NULL;
@@ -297,7 +295,7 @@ static int fp2_mul_u(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_
return 1;
}
static int fp2_mul_num(fp2_t r, const fp2_t a, const BIGNUM *n, const BIGNUM *p, BN_CTX *ctx)
int fp2_mul_num(fp2_t r, const fp2_t a, const BIGNUM *n, const BIGNUM *p, BN_CTX *ctx)
{
BIGNUM *r0 = NULL;
BIGNUM *r1 = NULL;
@@ -318,7 +316,7 @@ static int fp2_mul_num(fp2_t r, const fp2_t a, const BIGNUM *n, const BIGNUM *p,
return 1;
}
static int fp2_sqr(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
int fp2_sqr(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
{
BIGNUM *r0 = NULL;
BIGNUM *r1 = NULL;
@@ -348,7 +346,7 @@ static int fp2_sqr(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
static int fp2_sqr_u(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
int fp2_sqr_u(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
{
BIGNUM *r0 = NULL;
BIGNUM *r1 = NULL;
@@ -381,7 +379,7 @@ static int fp2_sqr_u(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
static int fp2_inv(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
int fp2_inv(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
{
if (BN_is_zero(a[0])) {
/* r0 = 0 */
@@ -430,15 +428,13 @@ static int fp2_inv(fp2_t r, const fp2_t a, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
#if SM9_TEST
static int fp2_div(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
int fp2_div(fp2_t r, const fp2_t a, const fp2_t b, const BIGNUM *p, BN_CTX *ctx)
{
return fp2_inv(r, b, p, ctx)
&& fp2_mul(r, a, r, p, ctx);
}
#endif
static int fp2_to_bin(const fp2_t a, unsigned char to[64])
int fp2_to_bin(const fp2_t a, unsigned char to[64])
{
memset(to, 0, 64);
BN_bn2bin(a[1], to + 32 - BN_num_bytes(a[1]));
@@ -446,14 +442,13 @@ static int fp2_to_bin(const fp2_t a, unsigned char to[64])
return 1;
}
static int fp2_from_bin(fp2_t a, const unsigned char from[64])
int fp2_from_bin(fp2_t a, const unsigned char from[64])
{
return BN_bin2bn(from, 32, a[1])
&& BN_bin2bn(from + 32, 32, a[0]);
}
#if SM9_TEST
static int fp2_test(const BIGNUM *p, BN_CTX *ctx)
int fp2_test(const BIGNUM *p, BN_CTX *ctx)
{
const char *_a[] = {
"5f25ce2083fc970a6b9fdcd819fb1966d300af2afd58d480c59e02b320852183",
@@ -568,9 +563,8 @@ static int fp2_test(const BIGNUM *p, BN_CTX *ctx)
return 1;
}
#endif
static int fp4_init(fp4_t a, BN_CTX *ctx)
int fp4_init(fp4_t a, BN_CTX *ctx)
{
int r;
r = fp2_init(a[0], ctx);
@@ -582,21 +576,19 @@ static int fp4_init(fp4_t a, BN_CTX *ctx)
return r;
}
static void fp4_cleanup(fp4_t a)
void fp4_cleanup(fp4_t a)
{
fp2_cleanup(a[0]);
fp2_cleanup(a[1]);
}
#if SM9_TEST
static void fp4_clear_cleanup(fp4_t a)
void fp4_clear_cleanup(fp4_t a)
{
fp2_clear_cleanup(a[0]);
fp2_clear_cleanup(a[1]);
}
#endif
static int fp4_print(const fp4_t a)
int fp4_print(const fp4_t a)
{
fp2_print(a[0]);
fp2_print(a[1]);
@@ -604,131 +596,129 @@ static int fp4_print(const fp4_t a)
return 1;
}
static int fp4_is_zero(const fp4_t a)
int fp4_is_zero(const fp4_t a)
{
return fp2_is_zero(a[0])
&& fp2_is_zero(a[1]);
}
static int fp4_is_one(const fp4_t a)
int fp4_is_one(const fp4_t a)
{
return fp2_is_one(a[0])
&& fp2_is_zero(a[1]);
}
static void fp4_set_zero(fp4_t r)
void fp4_set_zero(fp4_t r)
{
fp2_set_zero(r[0]);
fp2_set_zero(r[1]);
}
static int fp4_set_one(fp4_t r)
int fp4_set_one(fp4_t r)
{
fp2_set_zero(r[1]);
return fp2_set_one(r[0]);
}
static int fp4_set_bn(fp4_t r, const BIGNUM *a)
int fp4_set_bn(fp4_t r, const BIGNUM *a)
{
fp2_set_zero(r[1]);
return fp2_set_bn(r[0], a);
}
static int fp4_set_word(fp4_t r, unsigned long a)
int fp4_set_word(fp4_t r, unsigned long a)
{
fp2_set_zero(r[1]);
return fp2_set_word(r[0], a);
}
static int fp4_set_fp2(fp4_t r, const fp2_t a)
int fp4_set_fp2(fp4_t r, const fp2_t a)
{
fp2_set_zero(r[1]);
return fp2_copy(r[0], a);
}
static int fp4_set(fp4_t r, const fp2_t a0, const fp2_t a1)
int fp4_set(fp4_t r, const fp2_t a0, const fp2_t a1)
{
return fp2_copy(r[0], a0)
&& fp2_copy(r[1], a1);
}
static int fp4_set_hex(fp4_t r, const char *str[4])
int fp4_set_hex(fp4_t r, const char *str[4])
{
return fp2_set_hex(r[0], str)
&& fp2_set_hex(r[1], str+2);
}
static int fp4_copy(fp4_t r, const fp4_t a)
int fp4_copy(fp4_t r, const fp4_t a)
{
return fp2_copy(r[0], a[0])
&& fp2_copy(r[1], a[1]);
}
static int fp4_set_u(fp4_t r)
int fp4_set_u(fp4_t r)
{
fp2_set_zero(r[1]);
return fp2_set_u(r[0]);
}
static int fp4_set_v(fp4_t r)
int fp4_set_v(fp4_t r)
{
fp2_set_zero(r[0]);
return fp2_set_one(r[1]);
}
static int fp4_equ(const fp4_t a, const fp4_t b)
int fp4_equ(const fp4_t a, const fp4_t b)
{
return fp2_equ(a[0], b[0])
&& fp2_equ(a[1], b[1]);
}
#if SM9_TEST
static int fp4_equ_hex(const fp4_t a, const char *str[4], BN_CTX *ctx)
int fp4_equ_hex(const fp4_t a, const char *str[4], BN_CTX *ctx)
{
fp4_t t;
fp4_init(t, ctx);
fp4_set_hex(t, str);
return fp4_equ(a, t);
}
#endif
static int fp4_to_bin(const fp4_t a, unsigned char to[128])
int fp4_to_bin(const fp4_t a, unsigned char to[128])
{
return fp2_to_bin(a[1], to)
&& fp2_to_bin(a[0], to + 64);
}
static int fp4_from_bin(fp4_t a, const unsigned char from[128])
int fp4_from_bin(fp4_t a, const unsigned char from[128])
{
return fp2_from_bin(a[1], from)
&& fp2_from_bin(a[0], from + 64);
}
static int fp4_add(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx)
int fp4_add(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx)
{
return fp2_add(r[0], a[0], b[0], p, ctx)
&& fp2_add(r[1], a[1], b[1], p, ctx);
}
static int fp4_dbl(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
int fp4_dbl(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
{
return fp2_dbl(r[0], a[0], p, ctx)
&& fp2_dbl(r[1], a[1], p, ctx);
}
static int fp4_sub(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx)
int fp4_sub(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx)
{
return fp2_sub(r[0], a[0], b[0], p, ctx)
&& fp2_sub(r[1], a[1], b[1], p, ctx);
}
static int fp4_neg(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
int fp4_neg(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
{
return fp2_neg(r[0], a[0], p, ctx)
&&fp2_neg(r[1], a[1], p, ctx);
}
static int fp4_mul(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx)
int fp4_mul(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx)
{
fp2_t r0, r1, t;
@@ -759,7 +749,7 @@ static int fp4_mul(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CT
return 1;
}
static int fp4_mul_v(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx)
int fp4_mul_v(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_CTX *ctx)
{
fp2_t r0, r1, t;
fp2_init(r0, ctx);
@@ -788,7 +778,7 @@ static int fp4_mul_v(fp4_t r, const fp4_t a, const fp4_t b, const BIGNUM *p, BN_
return 1;
}
static int fp4_sqr(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
int fp4_sqr(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
{
fp2_t r0, r1, t;
fp2_init(r0, ctx);
@@ -814,7 +804,7 @@ static int fp4_sqr(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
static int fp4_sqr_v(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
int fp4_sqr_v(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
{
fp2_t r0, r1, t;
fp2_init(r0, ctx);
@@ -841,7 +831,7 @@ static int fp4_sqr_v(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
static int fp4_inv(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
int fp4_inv(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
{
fp2_t r0, r1, k;
fp2_init(r0, ctx);
@@ -875,8 +865,7 @@ static int fp4_inv(fp4_t r, const fp4_t a, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
#if SM9_TEST
static int fp4_test(const BIGNUM *p, BN_CTX *ctx)
int fp4_test(const BIGNUM *p, BN_CTX *ctx)
{
const char *_a[] = {
"bec057c34cec656c05f236d9399cd00c64319632885d200f964e4591dd7ca77",
@@ -1012,7 +1001,6 @@ static int fp4_test(const BIGNUM *p, BN_CTX *ctx)
return 0;
}
#endif
int fp12_init(fp12_t a, BN_CTX *ctx)
{
@@ -1035,14 +1023,12 @@ void fp12_cleanup(fp12_t a)
fp4_cleanup(a[2]);
}
#if SM9_TEST
static void fp12_clear_cleanup(fp12_t a)
void fp12_clear_cleanup(fp12_t a)
{
fp4_clear_cleanup(a[0]);
fp4_clear_cleanup(a[1]);
fp4_clear_cleanup(a[2]);
}
#endif
int fp12_print(const fp12_t a)
{
@@ -1052,137 +1038,125 @@ int fp12_print(const fp12_t a)
return 1;
}
#if SM9_TEST
static int fp12_is_zero(const fp12_t a)
int fp12_is_zero(const fp12_t a)
{
return fp4_is_zero(a[0])
&& fp4_is_zero(a[1])
&& fp4_is_zero(a[2]);
}
static int fp12_is_one(const fp12_t a)
int fp12_is_one(const fp12_t a)
{
return fp4_is_one(a[0])
&& fp4_is_zero(a[1])
&& fp4_is_zero(a[2]);
}
static void fp12_set_zero(fp12_t r)
void fp12_set_zero(fp12_t r)
{
fp4_set_zero(r[0]);
fp4_set_zero(r[1]);
fp4_set_zero(r[2]);
}
#endif
static int fp12_set_one(fp12_t r)
int fp12_set_one(fp12_t r)
{
fp4_set_zero(r[1]);
fp4_set_zero(r[2]);
return fp4_set_one(r[0]);
}
static int fp12_copy(fp12_t r, const fp12_t a)
int fp12_copy(fp12_t r, const fp12_t a)
{
return fp4_copy(r[0], a[0])
&& fp4_copy(r[1], a[1])
&& fp4_copy(r[2], a[2]);
}
#if SM9_TEST
static int fp12_set(fp12_t r, const fp4_t a0, const fp4_t a1, const fp4_t a2)
int fp12_set(fp12_t r, const fp4_t a0, const fp4_t a1, const fp4_t a2)
{
return fp4_copy(r[0], a0)
&& fp4_copy(r[1], a1)
&& fp4_copy(r[2], a2);
}
#endif
static int fp12_set_hex(fp12_t r, const char *str[12])
int fp12_set_hex(fp12_t r, const char *str[12])
{
return fp4_set_hex(r[0], str)
&& fp4_set_hex(r[1], str + 4)
&& fp4_set_hex(r[2], str + 8);
}
#if SM9_TEST
static int fp12_set_fp4(fp12_t r, const fp4_t a)
int fp12_set_fp4(fp12_t r, const fp4_t a)
{
fp4_set_zero(r[1]);
fp4_set_zero(r[2]);
return fp4_copy(r[0], a);
}
#endif
static int fp12_set_fp2(fp12_t r, const fp2_t a)
int fp12_set_fp2(fp12_t r, const fp2_t a)
{
fp4_set_zero(r[1]);
fp4_set_zero(r[2]);
return fp4_set_fp2(r[0], a);
}
static int fp12_set_bn(fp12_t r, const BIGNUM *a)
int fp12_set_bn(fp12_t r, const BIGNUM *a)
{
fp4_set_zero(r[1]);
fp4_set_zero(r[2]);
return fp4_set_bn(r[0], a);
}
#if SM9_TEST
static int fp12_set_word(fp12_t r, unsigned long a)
int fp12_set_word(fp12_t r, unsigned long a)
{
fp4_set_zero(r[1]);
fp4_set_zero(r[2]);
return fp4_set_word(r[0], a);
}
static int fp12_set_u(fp12_t r)
int fp12_set_u(fp12_t r)
{
fp4_set_zero(r[1]);
fp4_set_zero(r[2]);
return fp4_set_u(r[0]);
}
#endif
static int fp12_set_v(fp12_t r)
int fp12_set_v(fp12_t r)
{
fp4_set_zero(r[1]);
fp4_set_zero(r[2]);
return fp4_set_v(r[0]);
}
#if SM9_TEST
static int fp12_set_w(fp12_t r)
int fp12_set_w(fp12_t r)
{
fp4_set_zero(r[0]);
fp4_set_zero(r[2]);
return fp4_set_one(r[1]);
}
#endif
static int fp12_set_w_sqr(fp12_t r)
int fp12_set_w_sqr(fp12_t r)
{
fp4_set_zero(r[0]);
fp4_set_zero(r[1]);
return fp4_set_one(r[2]);
}
static int fp12_equ(const fp12_t a, const fp12_t b)
int fp12_equ(const fp12_t a, const fp12_t b)
{
return fp4_equ(a[0], b[0])
&& fp4_equ(a[1], b[1])
&& fp4_equ(a[2], b[2]);
}
#if SM9_TEST
static int fp12_equ_hex(const fp12_t a, const char *str[12], BN_CTX *ctx)
int fp12_equ_hex(const fp12_t a, const char *str[12], BN_CTX *ctx)
{
fp12_t t;
fp12_init(t, ctx);
fp12_set_hex(t, str);
return fp12_equ(a, t);
}
#endif
int fp12_to_bin(const fp12_t a, unsigned char to[384])
{
@@ -1191,28 +1165,28 @@ int fp12_to_bin(const fp12_t a, unsigned char to[384])
&& fp4_to_bin(a[0], to + 256);
}
static int fp12_from_bin(fp4_t a, const unsigned char from[384])
int fp12_from_bin(fp4_t a, const unsigned char from[384])
{
return fp4_from_bin(&a[2], from)
&& fp4_from_bin(&a[1], from + 128)
&& fp4_from_bin(&a[0], from + 256);
}
static int fp12_add(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx)
int fp12_add(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx)
{
return fp4_add(r[0], a[0], b[0], p, ctx)
&& fp4_add(r[1], a[1], b[1], p, ctx)
&& fp4_add(r[2], a[2], b[2], p, ctx);
}
static int fp12_dbl(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
int fp12_dbl(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
{
return fp4_dbl(r[0], a[0], p, ctx)
&& fp4_dbl(r[1], a[1], p, ctx)
&& fp4_dbl(r[2], a[2], p, ctx);
}
static int fp12_tri(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
int fp12_tri(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
{
fp12_t t;
fp12_init(t, ctx);
@@ -1226,14 +1200,14 @@ static int fp12_tri(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
static int fp12_sub(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx)
int fp12_sub(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx)
{
return fp4_sub(r[0], a[0], b[0], p, ctx)
&& fp4_sub(r[1], a[1], b[1], p, ctx)
&& fp4_sub(r[2], a[2], b[2], p, ctx);
}
static int fp12_neg(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
int fp12_neg(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
{
return fp4_neg(r[0], a[0], p, ctx)
&& fp4_neg(r[1], a[1], p, ctx)
@@ -1286,7 +1260,7 @@ int fp12_mul(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *
return 1;
}
static int fp12_sqr(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
int fp12_sqr(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
{
fp4_t r0, r1, r2, t;
fp4_init(r0, ctx);
@@ -1328,7 +1302,7 @@ static int fp12_sqr(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
static int fp12_inv(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
int fp12_inv(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
{
if (fp4_is_zero(a[2])) {
fp4_t k;
@@ -1338,7 +1312,7 @@ static int fp12_inv(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
}
fp4_t r0, r1, r2;
fp4_init(r0, ctx);
fp4_init(r0, ctx); // FIXME: r0, r1, r2 never used
fp4_init(r1, ctx);
fp4_init(r2, ctx);
@@ -1433,7 +1407,7 @@ static int fp12_inv(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
}
//TODO: check this!
static int fp12_div(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx)
int fp12_div(fp12_t r, const fp12_t a, const fp12_t b, const BIGNUM *p, BN_CTX *ctx)
{
return fp12_inv(r, b, p, ctx)
&& fp12_mul(r, a, r, p, ctx);
@@ -1475,7 +1449,7 @@ int fp12_pow(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p, BN_CTX
return 1;
}
static int fp12_fast_expo_p1(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
int fp12_fast_expo_p1(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
{
return fp2_copy(r[0][0], a[0][0])
&& fp2_neg (r[0][1], a[0][1], p, ctx)
@@ -1485,7 +1459,7 @@ static int fp12_fast_expo_p1(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *
&& fp2_neg (r[2][1], a[2][1], p, ctx);
}
static int fp12_fast_expo_p2(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
int fp12_fast_expo_p2(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *ctx)
{
const BIGNUM *pw20;
const BIGNUM *pw21;
@@ -1508,8 +1482,7 @@ static int fp12_fast_expo_p2(fp12_t r, const fp12_t a, const BIGNUM *p, BN_CTX *
return 1;
}
#if SM9_TEST
static int fp12_test(const BIGNUM *p, BN_CTX *ctx)
int fp12_test(const BIGNUM *p, BN_CTX *ctx)
{
const char *_a[] = {
"3a4b2fdf33cfe01aab98d17aefc8d38b0508061c3117685839bd0dfdeb5783a8",
@@ -1792,7 +1765,6 @@ static int fp12_test(const BIGNUM *p, BN_CTX *ctx)
return 0;
}
#endif
int point_init(point_t *P, BN_CTX *ctx)
{
@@ -1873,7 +1845,7 @@ int point_set_affine_coordinates_hex(point_t *P, const char *str[4])
return 1;
}
static int point_equ_hex(const point_t *P, const char *str[4], BN_CTX *ctx)
int point_equ_hex(const point_t *P, const char *str[4], BN_CTX *ctx)
{
point_t T;
point_init(&T, ctx);
@@ -2226,8 +2198,7 @@ int point_mul_generator(point_t *R, const BIGNUM *k, const BIGNUM *p, BN_CTX *ct
return point_mul(R, k, &G, p, ctx);
}
#if SM9_TEST
static int point_test(const BIGNUM *p, BN_CTX *ctx)
int point_test(const BIGNUM *p, BN_CTX *ctx)
{
const char *_G[] = {
"3722755292130b08d2aab97fd34ec120ee265948d19c17abf9b7213baf82d65b",
@@ -2327,9 +2298,8 @@ static int point_test(const BIGNUM *p, BN_CTX *ctx)
//fp12_cleanup(y);
return 1;
}
#endif
static int eval_tangent(fp12_t r, const point_t *T, const BIGNUM *xP, const BIGNUM *yP,
int eval_tangent(fp12_t r, const point_t *T, const BIGNUM *xP, const BIGNUM *yP,
const BIGNUM *p, BN_CTX *ctx)
{
int ret;
@@ -2376,7 +2346,7 @@ end:
return ret;
}
static int eval_line(fp12_t r, const point_t *T, const point_t *Q,
int eval_line(fp12_t r, const point_t *T, const point_t *Q,
const BIGNUM *xP, const BIGNUM *yP,
const BIGNUM *p, BN_CTX *ctx)
{
@@ -2426,7 +2396,7 @@ end:
return ret;
}
static int frobenius(point_t *R, const point_t *P, const BIGNUM *p, BN_CTX *ctx)
int frobenius(point_t *R, const point_t *P, const BIGNUM *p, BN_CTX *ctx)
{
fp12_t x, y;
@@ -2447,7 +2417,7 @@ static int frobenius(point_t *R, const point_t *P, const BIGNUM *p, BN_CTX *ctx)
return 1;
}
static int frobenius_twice(point_t *R, const point_t *P, const BIGNUM *p, BN_CTX *ctx)
int frobenius_twice(point_t *R, const point_t *P, const BIGNUM *p, BN_CTX *ctx)
{
frobenius(R, P, p, ctx);
frobenius(R, R, p, ctx);
@@ -2455,7 +2425,7 @@ static int frobenius_twice(point_t *R, const point_t *P, const BIGNUM *p, BN_CTX
}
static int final_expo(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx)
int final_expo(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx)
{
int i, n;
fp12_t t;
@@ -2484,7 +2454,7 @@ static int final_expo(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p
}
static int fast_final_expo(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx)
int fast_final_expo(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx)
{
int i, n;
fp12_t t;
@@ -2544,7 +2514,7 @@ static int fast_final_expo(fp12_t r, const fp12_t a, const BIGNUM *k, const BIGN
return 1;
}
static int rate(fp12_t f, const point_t *Q, const BIGNUM *xP, const BIGNUM *yP,
int rate(fp12_t f, const point_t *Q, const BIGNUM *xP, const BIGNUM *yP,
const BIGNUM *a, const BIGNUM *k, const BIGNUM *p, BN_CTX *ctx)
{
int ret = 0;
@@ -2638,7 +2608,7 @@ static int rate(fp12_t f, const point_t *Q, const BIGNUM *xP, const BIGNUM *yP,
return ret;
}
static int params_test(void)
int params_test(void)
{
const BIGNUM *p = SM9_get0_prime();
const BIGNUM *a = SM9_get0_loop_count();
@@ -2701,8 +2671,7 @@ int rate_pairing(fp12_t r, const point_t *Q, const EC_POINT *P, BN_CTX *ctx)
return ret;
}
#if SM9_TEST
static int rate_test(void)
int rate_test(void)
{
const char *Ppubs_str[] = {
"29DBA116152D1F786CE843ED24A3B573414D2177386A92DD8F14D65696EA5E32",
@@ -2742,16 +2711,14 @@ static int rate_test(void)
rate_pairing(g, &Ppubs, P1, ctx);
ok = fp12_equ_hex(g, g_str, ctx);
printf("rate %d: %s\n", __LINE__, ok ? "ok" : "error");
fp12_cleanup(g);
point_cleanup(&Ppubs);
EC_GROUP_free(group);
BN_CTX_free(ctx);
return 1;
return ok;
}
#endif
/* for SM9 sign, the (xP, yP) is the fixed generator of E(Fp)
*/

1
crypto/sms4/sms4_ede.c
View File

@@ -78,6 +78,7 @@ void sms4_ede_encrypt(const unsigned char in[16], unsigned char out[16],
void sms4_ede_ecb_encrypt(const unsigned char *in, unsigned char *out,
const sms4_ede_key_t *key, int enc)
{
(void)enc;
sms4_ede_encrypt(in, out, key);
}

491
include/openssl/ec.h
View File

@@ -1386,188 +1386,175 @@ int ERR_load_EC_strings(void);
# define EC_F_D2I_ECPKPARAMETERS 103
# define EC_F_D2I_ECPRIVATEKEY 104
# define EC_F_DO_EC_KEY_PRINT 105
# define EC_F_ECAHE_CIPHERTEXT_SIZE 106
# define EC_F_ECAHE_DECRYPT 107
# define EC_F_ECAHE_ENCRYPT 108
# define EC_F_ECDH_CMS_DECRYPT 109
# define EC_F_ECDH_CMS_SET_SHARED_INFO 110
# define EC_F_ECDH_COMPUTE_KEY 111
# define EC_F_ECDH_SIMPLE_COMPUTE_KEY 112
# define EC_F_ECDSA_DO_SIGN_EX 113
# define EC_F_ECDSA_DO_VERIFY 114
# define EC_F_ECDSA_SIGN_EX 115
# define EC_F_ECDSA_SIGN_SETUP 116
# define EC_F_ECDSA_SIG_NEW 117
# define EC_F_ECDSA_VERIFY 118
# define EC_F_ECIES_DECRYPT 119
# define EC_F_ECIES_DO_DECRYPT 120
# define EC_F_ECIES_DO_ENCRYPT 121
# define EC_F_ECIES_ENCRYPT 122
# define EC_F_ECIES_PARAMS_GET_ENC 123
# define EC_F_ECIES_PARAMS_GET_KDF 124
# define EC_F_ECIES_PARAMS_GET_MAC 125
# define EC_F_ECIES_PARAMS_INIT_WITH_RECOMMENDED 126
# define EC_F_ECIES_PARAMS_INIT_WITH_TYPE 127
# define EC_F_ECKEY_PARAM2TYPE 128
# define EC_F_ECKEY_PARAM_DECODE 129
# define EC_F_ECKEY_PRIV_DECODE 130
# define EC_F_ECKEY_PRIV_ENCODE 131
# define EC_F_ECKEY_PUB_DECODE 132
# define EC_F_ECKEY_PUB_ENCODE 133
# define EC_F_ECKEY_TYPE2PARAM 134
# define EC_F_ECPARAMETERS_PRINT_FP 135
# define EC_F_ECPKPARAMETERS_PRINT 136
# define EC_F_ECPKPARAMETERS_PRINT_FP 137
# define EC_F_ECP_NISTZ256_GET_AFFINE 138
# define EC_F_ECP_NISTZ256_MULT_PRECOMPUTE 139
# define EC_F_ECP_NISTZ256_POINTS_MUL 140
# define EC_F_ECP_NISTZ256_PRE_COMP_NEW 141
# define EC_F_ECP_NISTZ256_WINDOWED_MUL 142
# define EC_F_ECP_SM2Z256_GET_AFFINE 143
# define EC_F_ECP_SM2Z256_MULT_PRECOMPUTE 144
# define EC_F_ECP_SM2Z256_POINTS_MUL 145
# define EC_F_ECP_SM2Z256_PRE_COMP_NEW 146
# define EC_F_ECP_SM2Z256_WINDOWED_MUL 147
# define EC_F_ECX_KEY_OP 148
# define EC_F_ECX_PRIV_ENCODE 149
# define EC_F_ECX_PUB_ENCODE 150
# define EC_F_EC_ASN1_GROUP2CURVE 151
# define EC_F_EC_ASN1_GROUP2FIELDID 152
# define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY 153
# define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT 154
# define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE 155
# define EC_F_EC_GF2M_SIMPLE_OCT2POINT 156
# define EC_F_EC_GF2M_SIMPLE_POINT2OCT 157
# define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 158
# define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 159
# define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES 160
# define EC_F_EC_GFP_MONT_FIELD_DECODE 161
# define EC_F_EC_GFP_MONT_FIELD_ENCODE 162
# define EC_F_EC_GFP_MONT_FIELD_MUL 163
# define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE 164
# define EC_F_EC_GFP_MONT_FIELD_SQR 165
# define EC_F_EC_GFP_MONT_GROUP_SET_CURVE 166
# define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE 167
# define EC_F_EC_GFP_NISTP224_POINTS_MUL 168
# define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 169
# define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE 170
# define EC_F_EC_GFP_NISTP256_POINTS_MUL 171
# define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 172
# define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE 173
# define EC_F_EC_GFP_NISTP521_POINTS_MUL 174
# define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 175
# define EC_F_EC_GFP_NIST_FIELD_MUL 176
# define EC_F_EC_GFP_NIST_FIELD_SQR 177
# define EC_F_EC_GFP_NIST_GROUP_SET_CURVE 178
# define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT 179
# define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE 180
# define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE 181
# define EC_F_EC_GFP_SIMPLE_OCT2POINT 182
# define EC_F_EC_GFP_SIMPLE_POINT2OCT 183
# define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE 184
# define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 185
# define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 186
# define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 187
# define EC_F_EC_GFP_SM2P256_GROUP_SET_CURVE 188
# define EC_F_EC_GFP_SM2P256_POINTS_MUL 189
# define EC_F_EC_GFP_SM2P256_POINT_GET_AFFINE_COORDINATES 190
# define EC_F_EC_GROUP_CHECK 191
# define EC_F_EC_GROUP_CHECK_DISCRIMINANT 192
# define EC_F_EC_GROUP_COPY 193
# define EC_F_EC_GROUP_GENERATE_TYPE1CURVE 194
# define EC_F_EC_GROUP_GET_CURVE_GF2M 195
# define EC_F_EC_GROUP_GET_CURVE_GFP 196
# define EC_F_EC_GROUP_GET_DEGREE 197
# define EC_F_EC_GROUP_GET_ECPARAMETERS 198
# define EC_F_EC_GROUP_GET_ECPKPARAMETERS 199
# define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS 200
# define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS 201
# define EC_F_EC_GROUP_GET_TYPE1CURVE_ETA 202
# define EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA 203
# define EC_F_EC_GROUP_IS_TYPE1CURVE 204
# define EC_F_EC_GROUP_NEW 205
# define EC_F_EC_GROUP_NEW_BY_CURVE_NAME 206
# define EC_F_EC_GROUP_NEW_FROM_DATA 207
# define EC_F_EC_GROUP_NEW_FROM_ECPARAMETERS 208
# define EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS 209
# define EC_F_EC_GROUP_NEW_TYPE1CURVE 210
# define EC_F_EC_GROUP_SET_CURVE_GF2M 211
# define EC_F_EC_GROUP_SET_CURVE_GFP 212
# define EC_F_EC_GROUP_SET_GENERATOR 213
# define EC_F_EC_KEY_CHECK_KEY 214
# define EC_F_EC_KEY_COPY 215
# define EC_F_EC_KEY_GENERATE_KEY 216
# define EC_F_EC_KEY_MERGE 217
# define EC_F_EC_KEY_NEW_METHOD 218
# define EC_F_EC_KEY_OCT2PRIV 219
# define EC_F_EC_KEY_PRINT_FP 220
# define EC_F_EC_KEY_PRIV2OCT 221
# define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES 222
# define EC_F_EC_KEY_SIMPLE_CHECK_KEY 223
# define EC_F_EC_KEY_SIMPLE_OCT2PRIV 224
# define EC_F_EC_KEY_SIMPLE_PRIV2OCT 225
# define EC_F_EC_KEY_SPLIT 226
# define EC_F_EC_POINTS_MAKE_AFFINE 227
# define EC_F_EC_POINT_ADD 228
# define EC_F_EC_POINT_CMP 229
# define EC_F_EC_POINT_CMP_FPPOINT 230
# define EC_F_EC_POINT_COPY 231
# define EC_F_EC_POINT_DBL 232
# define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M 233
# define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP 234
# define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP 235
# define EC_F_EC_POINT_HASH2POINT 236
# define EC_F_EC_POINT_INVERT 237
# define EC_F_EC_POINT_IS_AT_INFINITY 238
# define EC_F_EC_POINT_IS_ON_CURVE 239
# define EC_F_EC_POINT_MAKE_AFFINE 240
# define EC_F_EC_POINT_NEW 241
# define EC_F_EC_POINT_OCT2POINT 242
# define EC_F_EC_POINT_POINT2OCT 243
# define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M 244
# define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP 245
# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M 246
# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP 247
# define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP 248
# define EC_F_EC_POINT_SET_TO_INFINITY 249
# define EC_F_EC_PRE_COMP_NEW 250
# define EC_F_EC_TYPE1CURVE_TATE 251
# define EC_F_EC_WNAF_MUL 252
# define EC_F_EC_WNAF_PRECOMPUTE_MULT 253
# define EC_F_I2D_ECIESPARAMETERS 254
# define EC_F_I2D_ECPARAMETERS 255
# define EC_F_I2D_ECPKPARAMETERS 256
# define EC_F_I2D_ECPRIVATEKEY 257
# define EC_F_I2O_ECPUBLICKEY 258
# define EC_F_NISTP224_PRE_COMP_NEW 259
# define EC_F_NISTP256_PRE_COMP_NEW 260
# define EC_F_NISTP521_PRE_COMP_NEW 261
# define EC_F_O2I_ECPUBLICKEY 262
# define EC_F_OLD_EC_PRIV_DECODE 263
# define EC_F_OSSL_ECDH_COMPUTE_KEY 264
# define EC_F_OSSL_ECDSA_SIGN_SIG 265
# define EC_F_OSSL_ECDSA_VERIFY_SIG 266
# define EC_F_PKEY_ECX_DERIVE 267
# define EC_F_PKEY_EC_CTRL 268
# define EC_F_PKEY_EC_CTRL_STR 269
# define EC_F_PKEY_EC_DECRYPT 270
# define EC_F_PKEY_EC_DERIVE 271
# define EC_F_PKEY_EC_ENCRYPT 272
# define EC_F_PKEY_EC_KEYGEN 273
# define EC_F_PKEY_EC_PARAMGEN 274
# define EC_F_PKEY_EC_SIGN 275
# define EC_F_SM2P256_PRE_COMP_NEW 276
# define EC_F_SM2_COMPUTE_ID_DIGEST 277
# define EC_F_SM2_COMPUTE_MESSAGE_DIGEST 278
# define EC_F_SM2_DO_ENCRYPT 279
# define EC_F_SM2_GET_PUBLIC_KEY_DATA 280
# define EC_F_SM2_KAP_COMPUTE_KEY 281
# define EC_F_SM2_KAP_CTX_INIT 282
# define EC_F_SM2_KAP_FINAL_CHECK 283
# define EC_F_SM2_KAP_PREPARE 284
# define EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK 285
# define EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK 286
# define EC_F_TYPE1CURVE_PHI 287
# define EC_F_ECDH_CMS_DECRYPT 106
# define EC_F_ECDH_CMS_SET_SHARED_INFO 107
# define EC_F_ECDH_COMPUTE_KEY 108
# define EC_F_ECDH_SIMPLE_COMPUTE_KEY 109
# define EC_F_ECDSA_DO_SIGN_EX 110
# define EC_F_ECDSA_DO_VERIFY 111
# define EC_F_ECDSA_SIGN_EX 112
# define EC_F_ECDSA_SIGN_SETUP 113
# define EC_F_ECDSA_SIG_NEW 114
# define EC_F_ECDSA_VERIFY 115
# define EC_F_ECIES_DECRYPT 116
# define EC_F_ECIES_DO_DECRYPT 117
# define EC_F_ECIES_DO_ENCRYPT 118
# define EC_F_ECIES_ENCRYPT 119
# define EC_F_ECIES_PARAMS_GET_ENC 120
# define EC_F_ECIES_PARAMS_GET_KDF 121
# define EC_F_ECIES_PARAMS_GET_MAC 122
# define EC_F_ECIES_PARAMS_INIT_WITH_RECOMMENDED 123
# define EC_F_ECIES_PARAMS_INIT_WITH_TYPE 124
# define EC_F_ECKEY_PARAM2TYPE 125
# define EC_F_ECKEY_PARAM_DECODE 126
# define EC_F_ECKEY_PRIV_DECODE 127
# define EC_F_ECKEY_PRIV_ENCODE 128
# define EC_F_ECKEY_PUB_DECODE 129
# define EC_F_ECKEY_PUB_ENCODE 130
# define EC_F_ECKEY_TYPE2PARAM 131
# define EC_F_ECPARAMETERS_PRINT_FP 132
# define EC_F_ECPKPARAMETERS_PRINT 133
# define EC_F_ECPKPARAMETERS_PRINT_FP 134
# define EC_F_ECP_NISTZ256_GET_AFFINE 135
# define EC_F_ECP_NISTZ256_MULT_PRECOMPUTE 136
# define EC_F_ECP_NISTZ256_POINTS_MUL 137
# define EC_F_ECP_NISTZ256_PRE_COMP_NEW 138
# define EC_F_ECP_NISTZ256_WINDOWED_MUL 139
# define EC_F_ECP_SM2Z256_GET_AFFINE 140
# define EC_F_ECP_SM2Z256_MULT_PRECOMPUTE 141
# define EC_F_ECP_SM2Z256_POINTS_MUL 142
# define EC_F_ECP_SM2Z256_PRE_COMP_NEW 143
# define EC_F_ECP_SM2Z256_WINDOWED_MUL 144
# define EC_F_ECX_KEY_OP 145
# define EC_F_ECX_PRIV_ENCODE 146
# define EC_F_ECX_PUB_ENCODE 147
# define EC_F_EC_ASN1_GROUP2CURVE 148
# define EC_F_EC_ASN1_GROUP2FIELDID 149
# define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY 150
# define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT 151
# define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE 152
# define EC_F_EC_GF2M_SIMPLE_OCT2POINT 153
# define EC_F_EC_GF2M_SIMPLE_POINT2OCT 154
# define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 155
# define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 156
# define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES 157
# define EC_F_EC_GFP_MONT_FIELD_DECODE 158
# define EC_F_EC_GFP_MONT_FIELD_ENCODE 159
# define EC_F_EC_GFP_MONT_FIELD_MUL 160
# define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE 161
# define EC_F_EC_GFP_MONT_FIELD_SQR 162
# define EC_F_EC_GFP_MONT_GROUP_SET_CURVE 163
# define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE 164
# define EC_F_EC_GFP_NISTP224_POINTS_MUL 165
# define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 166
# define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE 167
# define EC_F_EC_GFP_NISTP256_POINTS_MUL 168
# define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 169
# define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE 170
# define EC_F_EC_GFP_NISTP521_POINTS_MUL 171
# define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 172
# define EC_F_EC_GFP_NIST_FIELD_MUL 173
# define EC_F_EC_GFP_NIST_FIELD_SQR 174
# define EC_F_EC_GFP_NIST_GROUP_SET_CURVE 175
# define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT 176
# define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE 177
# define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE 178
# define EC_F_EC_GFP_SIMPLE_OCT2POINT 179
# define EC_F_EC_GFP_SIMPLE_POINT2OCT 180
# define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE 181
# define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 182
# define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 183
# define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 184
# define EC_F_EC_GFP_SM2P256_GROUP_SET_CURVE 185
# define EC_F_EC_GFP_SM2P256_POINTS_MUL 186
# define EC_F_EC_GFP_SM2P256_POINT_GET_AFFINE_COORDINATES 187
# define EC_F_EC_GROUP_CHECK 188
# define EC_F_EC_GROUP_CHECK_DISCRIMINANT 189
# define EC_F_EC_GROUP_COPY 190
# define EC_F_EC_GROUP_GET_CURVE_GF2M 191
# define EC_F_EC_GROUP_GET_CURVE_GFP 192
# define EC_F_EC_GROUP_GET_DEGREE 193
# define EC_F_EC_GROUP_GET_ECPARAMETERS 194
# define EC_F_EC_GROUP_GET_ECPKPARAMETERS 195
# define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS 196
# define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS 197
# define EC_F_EC_GROUP_NEW 198
# define EC_F_EC_GROUP_NEW_BY_CURVE_NAME 199
# define EC_F_EC_GROUP_NEW_FROM_DATA 200
# define EC_F_EC_GROUP_NEW_FROM_ECPARAMETERS 201
# define EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS 202
# define EC_F_EC_GROUP_SET_CURVE_GF2M 203
# define EC_F_EC_GROUP_SET_CURVE_GFP 204
# define EC_F_EC_GROUP_SET_GENERATOR 205
# define EC_F_EC_KEY_CHECK_KEY 206
# define EC_F_EC_KEY_COPY 207
# define EC_F_EC_KEY_GENERATE_KEY 208
# define EC_F_EC_KEY_MERGE 209
# define EC_F_EC_KEY_NEW_METHOD 210
# define EC_F_EC_KEY_OCT2PRIV 211
# define EC_F_EC_KEY_PRINT_FP 212
# define EC_F_EC_KEY_PRIV2OCT 213
# define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES 214
# define EC_F_EC_KEY_SIMPLE_CHECK_KEY 215
# define EC_F_EC_KEY_SIMPLE_OCT2PRIV 216
# define EC_F_EC_KEY_SIMPLE_PRIV2OCT 217
# define EC_F_EC_KEY_SPLIT 218
# define EC_F_EC_POINTS_MAKE_AFFINE 219
# define EC_F_EC_POINT_ADD 220
# define EC_F_EC_POINT_CMP 221
# define EC_F_EC_POINT_COPY 222
# define EC_F_EC_POINT_DBL 223
# define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M 224
# define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP 225
# define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP 226
# define EC_F_EC_POINT_INVERT 227
# define EC_F_EC_POINT_IS_AT_INFINITY 228
# define EC_F_EC_POINT_IS_ON_CURVE 229
# define EC_F_EC_POINT_MAKE_AFFINE 230
# define EC_F_EC_POINT_NEW 231
# define EC_F_EC_POINT_OCT2POINT 232
# define EC_F_EC_POINT_POINT2OCT 233
# define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M 234
# define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP 235
# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M 236
# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP 237
# define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP 238
# define EC_F_EC_POINT_SET_TO_INFINITY 239
# define EC_F_EC_PRE_COMP_NEW 240
# define EC_F_EC_WNAF_MUL 241
# define EC_F_EC_WNAF_PRECOMPUTE_MULT 242
# define EC_F_I2D_ECIESPARAMETERS 243
# define EC_F_I2D_ECPARAMETERS 244
# define EC_F_I2D_ECPKPARAMETERS 245
# define EC_F_I2D_ECPRIVATEKEY 246
# define EC_F_I2O_ECPUBLICKEY 247
# define EC_F_NISTP224_PRE_COMP_NEW 248
# define EC_F_NISTP256_PRE_COMP_NEW 249
# define EC_F_NISTP521_PRE_COMP_NEW 250
# define EC_F_O2I_ECPUBLICKEY 251
# define EC_F_OLD_EC_PRIV_DECODE 252
# define EC_F_OSSL_ECDH_COMPUTE_KEY 253
# define EC_F_OSSL_ECDSA_SIGN_SIG 254
# define EC_F_OSSL_ECDSA_VERIFY_SIG 255
# define EC_F_PKEY_ECX_DERIVE 256
# define EC_F_PKEY_EC_CTRL 257
# define EC_F_PKEY_EC_CTRL_STR 258
# define EC_F_PKEY_EC_DECRYPT 259
# define EC_F_PKEY_EC_DERIVE 260
# define EC_F_PKEY_EC_ENCRYPT 261
# define EC_F_PKEY_EC_KEYGEN 262
# define EC_F_PKEY_EC_PARAMGEN 263
# define EC_F_PKEY_EC_SIGN 264
# define EC_F_SM2P256_PRE_COMP_NEW 265
# define EC_F_SM2_COMPUTE_ID_DIGEST 266
# define EC_F_SM2_COMPUTE_MESSAGE_DIGEST 267
# define EC_F_SM2_COMPUTE_SHARE_KEY 268
# define EC_F_SM2_DO_ENCRYPT 269
# define EC_F_SM2_GET_PUBLIC_KEY_DATA 270
# define EC_F_SM2_KAP_COMPUTE_KEY 271
# define EC_F_SM2_KAP_CTX_INIT 272
# define EC_F_SM2_KAP_FINAL_CHECK 273
# define EC_F_SM2_KAP_PREPARE 274
/* Reason codes. */
# define EC_R_ASN1_ERROR 100
@@ -1597,78 +1584,74 @@ int ERR_load_EC_strings(void);
# define EC_R_FIELD_TOO_LARGE 124
# define EC_R_GEN_MAC_FAILED 125
# define EC_R_GET_PUBLIC_KEY_DATA_FAILURE 126
# define EC_R_GET_TYPE1CURVE_ZETA_FAILURE 127
# define EC_R_GF2M_NOT_SUPPORTED 128
# define EC_R_GROUP2PKPARAMETERS_FAILURE 129
# define EC_R_HMAC_FAILURE 130
# define EC_R_I2D_ECPKPARAMETERS_FAILURE 131
# define EC_R_INCOMPATIBLE_OBJECTS 132
# define EC_R_INVALID_ARGUMENT 133
# define EC_R_INVALID_COMPRESSED_POINT 134
# define EC_R_INVALID_COMPRESSION_BIT 135
# define EC_R_INVALID_CURVE 136
# define EC_R_INVALID_DIGEST 137
# define EC_R_INVALID_DIGEST_ALGOR 138
# define EC_R_INVALID_DIGEST_TYPE 139
# define EC_R_INVALID_ECIES_CIPHERTEXT 140
# define EC_R_INVALID_ECIES_PARAMETERS 141
# define EC_R_INVALID_ECIES_PARAMS 142
# define EC_R_INVALID_EC_ENCRYPT_PARAM 143
# define EC_R_INVALID_EC_SCHEME 144
# define EC_R_INVALID_ENCODING 145
# define EC_R_INVALID_ENC_PARAM 146
# define EC_R_INVALID_ENC_TYPE 147
# define EC_R_INVALID_FIELD 148
# define EC_R_INVALID_FORM 149
# define EC_R_INVALID_GROUP_ORDER 150
# define EC_R_INVALID_ID_LENGTH 151
# define EC_R_INVALID_INPUT_LENGTH 152
# define EC_R_INVALID_KDF_MD 153
# define EC_R_INVALID_KEY 154
# define EC_R_INVALID_MD 155
# define EC_R_INVALID_OUTPUT_LENGTH 156
# define EC_R_INVALID_PEER_KEY 157
# define EC_R_INVALID_PENTANOMIAL_BASIS 158
# define EC_R_INVALID_PRIVATE_KEY 159
# define EC_R_INVALID_SIGNER_ID 160
# define EC_R_INVALID_SM2_ID 161
# define EC_R_INVALID_SM2_KAP_CHECKSUM_LENGTH 162
# define EC_R_INVALID_SM2_KAP_CHECKSUM_VALUE 163
# define EC_R_INVALID_SPLIT_PARAMETER 164
# define EC_R_INVALID_TRINOMIAL_BASIS 165
# define EC_R_INVALID_TYPE1CURVE 166
# define EC_R_INVALID_TYPE1_CURVE 167
# define EC_R_INVLID_TYPE1CURVE 168
# define EC_R_KDF_PARAMETER_ERROR 169
# define EC_R_KEYS_NOT_SET 170
# define EC_R_MISSING_PARAMETERS 171
# define EC_R_MISSING_PRIVATE_KEY 172
# define EC_R_NEED_NEW_SETUP_VALUES 173
# define EC_R_NOT_A_NIST_PRIME 174
# define EC_R_NOT_IMPLEMENTED 175
# define EC_R_NOT_INITIALIZED 176
# define EC_R_NO_PARAMETERS_SET 177
# define EC_R_NO_PRIVATE_VALUE 178
# define EC_R_OPERATION_NOT_SUPPORTED 179
# define EC_R_PASSED_NULL_PARAMETER 180
# define EC_R_PEER_KEY_ERROR 181
# define EC_R_PKPARAMETERS2GROUP_FAILURE 182
# define EC_R_POINT_ARITHMETIC_FAILURE 183
# define EC_R_POINT_AT_INFINITY 184
# define EC_R_POINT_IS_NOT_ON_CURVE 185
# define EC_R_RANDOM_NUMBER_GENERATION_FAILED 186
# define EC_R_SHARED_INFO_ERROR 187
# define EC_R_SLOT_FULL 188
# define EC_R_SM2_DECRYPT_FAILED 189
# define EC_R_SM2_ENCRYPT_FAILED 190
# define EC_R_SM2_KAP_NOT_INITED 191
# define EC_R_UNDEFINED_GENERATOR 192
# define EC_R_UNDEFINED_ORDER 193
# define EC_R_UNKNOWN_GROUP 194
# define EC_R_UNKNOWN_ORDER 195
# define EC_R_UNSUPPORTED_FIELD 196
# define EC_R_WRONG_CURVE_PARAMETERS 197
# define EC_R_WRONG_ORDER 198
# define EC_R_GF2M_NOT_SUPPORTED 127
# define EC_R_GROUP2PKPARAMETERS_FAILURE 128
# define EC_R_HMAC_FAILURE 129
# define EC_R_I2D_ECPKPARAMETERS_FAILURE 130
# define EC_R_INCOMPATIBLE_OBJECTS 131
# define EC_R_INVALID_ARGUMENT 132
# define EC_R_INVALID_COMPRESSED_POINT 133
# define EC_R_INVALID_COMPRESSION_BIT 134
# define EC_R_INVALID_CURVE 135
# define EC_R_INVALID_DIGEST 136
# define EC_R_INVALID_DIGEST_ALGOR 137
# define EC_R_INVALID_DIGEST_TYPE 138
# define EC_R_INVALID_ECIES_CIPHERTEXT 139
# define EC_R_INVALID_ECIES_PARAMETERS 140
# define EC_R_INVALID_ECIES_PARAMS 141
# define EC_R_INVALID_EC_ENCRYPT_PARAM 142
# define EC_R_INVALID_EC_SCHEME 143
# define EC_R_INVALID_ENCODING 144
# define EC_R_INVALID_ENC_PARAM 145
# define EC_R_INVALID_ENC_TYPE 146
# define EC_R_INVALID_FIELD 147
# define EC_R_INVALID_FORM 148
# define EC_R_INVALID_GROUP_ORDER 149
# define EC_R_INVALID_ID_LENGTH 150
# define EC_R_INVALID_INPUT_LENGTH 151
# define EC_R_INVALID_KDF_MD 152
# define EC_R_INVALID_KEY 153
# define EC_R_INVALID_MD 154
# define EC_R_INVALID_OUTPUT_LENGTH 155
# define EC_R_INVALID_PEER_KEY 156
# define EC_R_INVALID_PENTANOMIAL_BASIS 157
# define EC_R_INVALID_PRIVATE_KEY 158
# define EC_R_INVALID_SIGNER_ID 159
# define EC_R_INVALID_SM2_ID 160
# define EC_R_INVALID_SM2_KAP_CHECKSUM_LENGTH 161
# define EC_R_INVALID_SM2_KAP_CHECKSUM_VALUE 162
# define EC_R_INVALID_SPLIT_PARAMETER 163
# define EC_R_INVALID_TRINOMIAL_BASIS 164
# define EC_R_KDF_PARAMETER_ERROR 165
# define EC_R_KEYS_NOT_SET 166
# define EC_R_MISSING_PARAMETERS 167
# define EC_R_MISSING_PRIVATE_KEY 168
# define EC_R_NEED_NEW_SETUP_VALUES 169
# define EC_R_NOT_A_NIST_PRIME 170
# define EC_R_NOT_IMPLEMENTED 171
# define EC_R_NOT_INITIALIZED 172
# define EC_R_NO_PARAMETERS_SET 173
# define EC_R_NO_PRIVATE_VALUE 174
# define EC_R_OPERATION_NOT_SUPPORTED 175
# define EC_R_PASSED_NULL_PARAMETER 176
# define EC_R_PEER_KEY_ERROR 177
# define EC_R_PKPARAMETERS2GROUP_FAILURE 178
# define EC_R_POINT_ARITHMETIC_FAILURE 179
# define EC_R_POINT_AT_INFINITY 180
# define EC_R_POINT_IS_NOT_ON_CURVE 181
# define EC_R_RANDOM_NUMBER_GENERATION_FAILED 182
# define EC_R_SHARED_INFO_ERROR 183
# define EC_R_SLOT_FULL 184
# define EC_R_SM2_DECRYPT_FAILED 185
# define EC_R_SM2_ENCRYPT_FAILED 186
# define EC_R_SM2_KAP_NOT_INITED 187
# define EC_R_UNDEFINED_GENERATOR 188
# define EC_R_UNDEFINED_ORDER 189
# define EC_R_UNKNOWN_GROUP 190
# define EC_R_UNKNOWN_ORDER 191
# define EC_R_UNSUPPORTED_FIELD 192
# define EC_R_WRONG_CURVE_PARAMETERS 193
# define EC_R_WRONG_ORDER 194
# ifdef __cplusplus
}

2
include/openssl/evp.h
View File

@@ -972,7 +972,7 @@ const EVP_CIPHER *EVP_zuc256(void);
int EVP_add_cipher(const EVP_CIPHER *cipher);
int EVP_add_digest(const EVP_MD *digest);
const EVP_CIPHER *EVP_get_default_cipher(void);
/* original OpenSSL use MD5 or SHA1 as default hash algor */
const EVP_MD *EVP_get_default_digest(void);
const EVP_CIPHER *EVP_get_cipherbyname(const char *name);

324
include/openssl/gmsdf.h
View File

@@ -96,175 +96,165 @@ int ERR_load_SDF_strings(void);
/* Error codes for the SDF functions. */
/* Function codes. */
# define SDF_F_SANSEC_DECODE_ECCCIPHER 149
# define SDF_F_SANSEC_ENCODE_ECCCIPHER 150
# define SDF_F_SDF_CALCULATEMAC 100
# define SDF_F_SDF_CLOSEDEVICE 101
# define SDF_F_SDF_CLOSESESSION 102
# define SDF_F_SDF_CREATEFILE 103
# define SDF_F_SDF_DECRYPT 104
# define SDF_F_SDF_DELETEFILE 105
# define SDF_F_SDF_DESTROYKEY 106
# define SDF_F_SDF_ENCRYPT 107
# define SDF_F_SDF_EXCHANGEDIGITENVELOPEBASEONECC 108
# define SDF_F_SDF_EXCHANGEDIGITENVELOPEBASEONRSA 109
# define SDF_F_SDF_EXPORTENCPUBLICKEY_ECC 110
# define SDF_F_SDF_EXPORTENCPUBLICKEY_RSA 111
# define SDF_F_SDF_EXPORTSIGNPUBLICKEY_ECC 112
# define SDF_F_SDF_EXPORTSIGNPUBLICKEY_RSA 113
# define SDF_F_SDF_EXTERNALENCRYPT_ECC 114
# define SDF_F_SDF_EXTERNALPRIVATEKEYOPERATION_RSA 115
# define SDF_F_SDF_EXTERNALPUBLICKEYOPERATION_RSA 116
# define SDF_F_SDF_EXTERNALVERIFY_ECC 117
# define SDF_F_SDF_GENERATEAGREEMENTDATAANDKEYWITHECC 118
# define SDF_F_SDF_GENERATEAGREEMENTDATAWITHECC 119
# define SDF_F_SDF_GENERATEKEYPAIR_ECC 120
# define SDF_F_SDF_GENERATEKEYPAIR_RSA 121
# define SDF_F_SDF_GENERATEKEYWITHECC 122
# define SDF_F_SDF_GENERATEKEYWITHEPK_ECC 123
# define SDF_F_SDF_GENERATEKEYWITHEPK_RSA 124
# define SDF_F_SDF_GENERATEKEYWITHIPK_ECC 125
# define SDF_F_SDF_GENERATEKEYWITHIPK_RSA 126
# define SDF_F_SDF_GENERATEKEYWITHKEK 127
# define SDF_F_SDF_GENERATERANDOM 128
# define SDF_F_SDF_GETDEVICEINFO 129
# define SDF_F_SDF_GETPRIVATEKEYACCESSRIGHT 130
# define SDF_F_SDF_HASHFINAL 131
# define SDF_F_SDF_HASHINIT 132
# define SDF_F_SDF_HASHUPDATE 133
# define SDF_F_SDF_IMPORTKEY 134
# define SDF_F_SDF_IMPORTKEYWITHISK_ECC 135
# define SDF_F_SDF_IMPORTKEYWITHISK_RSA 136
# define SDF_F_SDF_IMPORTKEYWITHKEK 137
# define SDF_F_SDF_INTERNALDECRYPT_ECC 151
# define SDF_F_SDF_INTERNALENCRYPT_ECC 152
# define SDF_F_SDF_INTERNALPRIVATEKEYOPERATION_RSA 138
# define SDF_F_SDF_INTERNALPUBLICKEYOPERATION_RSA 147
# define SDF_F_SDF_INTERNALSIGN_ECC 139
# define SDF_F_SDF_INTERNALVERIFY_ECC 140
# define SDF_F_SDF_LOADLIBRARY 148
# define SDF_F_SDF_METHOD_LOAD_LIBRARY 141
# define SDF_F_SDF_NEWECCCIPHER 153
# define SDF_F_SDF_OPENDEVICE 142
# define SDF_F_SDF_OPENSESSION 143
# define SDF_F_SDF_READFILE 144
# define SDF_F_SDF_RELEASEPRIVATEKEYACCESSRIGHT 145
# define SDF_F_SDF_WRITEFILE 146
# define SDF_F_SANSEC_DECODE_ECCCIPHER 100
# define SDF_F_SANSEC_ENCODE_ECCCIPHER 101
# define SDF_F_SDF_CALCULATEMAC 102
# define SDF_F_SDF_CLOSEDEVICE 103
# define SDF_F_SDF_CLOSESESSION 104
# define SDF_F_SDF_CREATEFILE 105
# define SDF_F_SDF_DECRYPT 106
# define SDF_F_SDF_DELETEFILE 107
# define SDF_F_SDF_DESTROYKEY 108
# define SDF_F_SDF_ENCRYPT 109
# define SDF_F_SDF_EXCHANGEDIGITENVELOPEBASEONECC 110
# define SDF_F_SDF_EXCHANGEDIGITENVELOPEBASEONRSA 111
# define SDF_F_SDF_EXPORTENCPUBLICKEY_ECC 112
# define SDF_F_SDF_EXPORTENCPUBLICKEY_RSA 113
# define SDF_F_SDF_EXPORTSIGNPUBLICKEY_ECC 114
# define SDF_F_SDF_EXPORTSIGNPUBLICKEY_RSA 115
# define SDF_F_SDF_EXTERNALENCRYPT_ECC 116
# define SDF_F_SDF_EXTERNALPUBLICKEYOPERATION_RSA 117
# define SDF_F_SDF_EXTERNALVERIFY_ECC 118
# define SDF_F_SDF_GENERATEAGREEMENTDATAANDKEYWITHECC 119
# define SDF_F_SDF_GENERATEAGREEMENTDATAWITHECC 120
# define SDF_F_SDF_GENERATEKEYPAIR_ECC 121
# define SDF_F_SDF_GENERATEKEYPAIR_RSA 122
# define SDF_F_SDF_GENERATEKEYWITHECC 123
# define SDF_F_SDF_GENERATEKEYWITHEPK_ECC 124
# define SDF_F_SDF_GENERATEKEYWITHEPK_RSA 125
# define SDF_F_SDF_GENERATEKEYWITHIPK_ECC 126
# define SDF_F_SDF_GENERATEKEYWITHIPK_RSA 127
# define SDF_F_SDF_GENERATEKEYWITHKEK 128
# define SDF_F_SDF_GENERATERANDOM 129
# define SDF_F_SDF_GETDEVICEINFO 130
# define SDF_F_SDF_GETPRIVATEKEYACCESSRIGHT 131
# define SDF_F_SDF_HASHFINAL 132
# define SDF_F_SDF_HASHINIT 133
# define SDF_F_SDF_HASHUPDATE 134
# define SDF_F_SDF_IMPORTKEY 135
# define SDF_F_SDF_IMPORTKEYWITHISK_ECC 136
# define SDF_F_SDF_IMPORTKEYWITHISK_RSA 137
# define SDF_F_SDF_IMPORTKEYWITHKEK 138
# define SDF_F_SDF_INTERNALDECRYPT_ECC 139
# define SDF_F_SDF_INTERNALENCRYPT_ECC 140
# define SDF_F_SDF_INTERNALPRIVATEKEYOPERATION_RSA 141
# define SDF_F_SDF_INTERNALPUBLICKEYOPERATION_RSA 142
# define SDF_F_SDF_INTERNALSIGN_ECC 143
# define SDF_F_SDF_INTERNALVERIFY_ECC 144
# define SDF_F_SDF_LOADLIBRARY 145
# define SDF_F_SDF_METHOD_LOAD_LIBRARY 146
# define SDF_F_SDF_NEWECCCIPHER 147
# define SDF_F_SDF_OPENDEVICE 148
# define SDF_F_SDF_OPENSESSION 149
# define SDF_F_SDF_READFILE 150
# define SDF_F_SDF_RELEASEPRIVATEKEYACCESSRIGHT 151
# define SDF_F_SDF_WRITEFILE 152
/* Reason codes. */
# define SDF_R_ALGORITHM_MODE_NOT_SUPPORTED 111
# define SDF_R_ALGORITHM_NOT_SUPPORTED 112
# define SDF_R_BUFFER_TOO_SMALL 113
# define SDF_R_COMMUNICATION_FAILURE 114
# define SDF_R_DSO_LOAD_FAILURE 110
# define SDF_R_ENCRYPT_DATA_ERROR 115
# define SDF_R_ERROR 116
# define SDF_R_FILE_ALREADY_EXIST 117
# define SDF_R_FILE_NOT_EXIST 118
# define SDF_R_HARDWARE_ERROR 119
# define SDF_R_INVALID_CIPHER_ALGOR 143
# define SDF_R_INVALID_DIGEST_ALGOR 144
# define SDF_R_INVALID_FILE_OFFSET 120
# define SDF_R_INVALID_FILE_SIZE 121
# define SDF_R_INVALID_INPUT_ARGUMENT 122
# define SDF_R_INVALID_KEY 123
# define SDF_R_INVALID_KEY_LENGTH 100
# define SDF_R_INVALID_KEY_TYPE 124
# define SDF_R_INVALID_OUTPUT_ARGUMENT 125
# define SDF_R_INVALID_SANSEC_ECCCIPHER_LENGTH 207
# define SDF_R_INVALID_SDF_LIBRARY 101
# define SDF_R_INVALID_SESSION_HANDLE 102
# define SDF_R_INVALID_SM2_CIPHERTEXT_LENGTH 212
# define SDF_R_KEY_NOT_EXIST 126
# define SDF_R_LOAD_LIBRARY_FAILURE 107
# define SDF_R_MAC_ERROR 127
# define SDF_R_METHOD_OPERATION_FAILURE 108
# define SDF_R_MULTI_STEP_OPERATION_ERROR 128
# define SDF_R_NOT_INITIALIZED 109
# define SDF_R_NOT_SUPPORTED 103
# define SDF_R_NOT_SUPPORTED_CIPHER_ALGOR 208
# define SDF_R_NOT_SUPPORTED_DIGEST_ALGOR 209
# define SDF_R_NOT_SUPPORTED_ECC_ALGOR 210
# define SDF_R_NOT_SUPPORTED_PKEY_ALGOR 211
# define SDF_R_NO_PRIVATE_KEY_ACCESS_RIGHT 129
# define SDF_R_OPEN_DEVICE_FAILURE 130
# define SDF_R_OPEN_SESSION_FAILURE 131
# define SDF_R_OPERATION_FAILED 104
# define SDF_R_OPERATION_NOT_SUPPORTED 132
# define SDF_R_PRIVATE_KEY_OPERATION_FAILURE 133
# define SDF_R_PRKERR 134
# define SDF_R_PUBLIC_KEY_OPERATION_FAILURE 135
# define SDF_R_RANDOM_GENERATION_ERROR 136
# define SDF_R_SANSEC_BASE 145
# define SDF_R_SANSEC_CARD_ALGOR_NOT_SUPPORTED 146
# define SDF_R_SANSEC_CARD_ALG_MODE_NOT_SUPPORTED 147
# define SDF_R_SANSEC_CARD_BASE 148
# define SDF_R_SANSEC_CARD_BUFFER_TOO_SMALL 149
# define SDF_R_SANSEC_CARD_COMMMUCATION_FAILED 150
# define SDF_R_SANSEC_CARD_CRYPTO_NOT_INITED 151
# define SDF_R_SANSEC_CARD_DATA_PADDING_ERROR 152
# define SDF_R_SANSEC_CARD_DATA_SIZE 153
# define SDF_R_SANSEC_CARD_DEVICE_STATUS_ERROR 154
# define SDF_R_SANSEC_CARD_DEVICE_STATUS_ERROR_05 155
# define SDF_R_SANSEC_CARD_FILE_NOT_EXIST 156
# define SDF_R_SANSEC_CARD_FILE_OFFSET_ERROR 157
# define SDF_R_SANSEC_CARD_FILE_SIZE_ERROR 158
# define SDF_R_SANSEC_CARD_HARDWARE_FAILURE 159
# define SDF_R_SANSEC_CARD_KEY_ERROR 160
# define SDF_R_SANSEC_CARD_KEY_NOT_EXIST 161
# define SDF_R_SANSEC_CARD_KEY_TYPE_ERROR 162
# define SDF_R_SANSEC_CARD_LOGIN_ERROR 163
# define SDF_R_SANSEC_CARD_LOGIN_ERROR_05 164
# define SDF_R_SANSEC_CARD_MANAGEMENT_DENYED 165
# define SDF_R_SANSEC_CARD_MANAGEMENT_DENYED_05 166
# define SDF_R_SANSEC_CARD_NOT_SUPPORTED 167
# define SDF_R_SANSEC_CARD_OPEN_DEVICE_FAILED 168
# define SDF_R_SANSEC_CARD_OPEN_SESSION_FAILED 169
# define SDF_R_SANSEC_CARD_OPERATION_DENYED 170
# define SDF_R_SANSEC_CARD_OPERATION_DENYED_05 171
# define SDF_R_SANSEC_CARD_PARAMENT_ERROR 172
# define SDF_R_SANSEC_CARD_PARAMENT_ERROR_05 173
# define SDF_R_SANSEC_CARD_PRIVATE_KEY_ACCESS_DENYED 174
# define SDF_R_SANSEC_CARD_PRIVATE_KEY_OPERATION_ERROR 175
# define SDF_R_SANSEC_CARD_PUBLIC_KEY_OPERATION_ERROR 176
# define SDF_R_SANSEC_CARD_READER_BASE 177
# define SDF_R_SANSEC_CARD_READER_CARD_INSERT 178
# define SDF_R_SANSEC_CARD_READER_CARD_INSERT_TYPE 179
# define SDF_R_SANSEC_CARD_READER_NO_CARD 180
# define SDF_R_SANSEC_CARD_READER_PIN_ERROR 181
# define SDF_R_SANSEC_CARD_SIGN_ERROR 182
# define SDF_R_SANSEC_CARD_STEP_ERROR 183
# define SDF_R_SANSEC_CARD_SYMMETRIC_ALGOR_ERROR 184
# define SDF_R_SANSEC_CARD_UNKNOW_ERROR 185
# define SDF_R_SANSEC_CARD_USERID_ERROR 186
# define SDF_R_SANSEC_CARD_USERID_ERROR_05 187
# define SDF_R_SANSEC_CARD_VERIFY_ERROR 188
# define SDF_R_SANSEC_CONFIG_ERROR 189
# define SDF_R_SANSEC_CONNECT_ERROR 190
# define SDF_R_SANSEC_FILE_ALREADY_EXIST 191
# define SDF_R_SANSEC_INVALID_AUTHENCODE 192
# define SDF_R_SANSEC_INVALID_COMMAND 193
# define SDF_R_SANSEC_INVALID_PARAMETERS 194
# define SDF_R_SANSEC_INVALID_USER 195
# define SDF_R_SANSEC_NO_AVAILABLE_CSM 196
# define SDF_R_SANSEC_NO_AVAILABLE_HSM 197
# define SDF_R_SANSEC_PROTOCOL_VERSION_ERROR 198
# define SDF_R_SANSEC_SEM_TIMEOUT 199
# define SDF_R_SANSEC_SET_SOCKET_OPTION_ERROR 200
# define SDF_R_SANSEC_SOCKET_RECV_0 201
# define SDF_R_SANSEC_SOCKET_RECV_ERROR 202
# define SDF_R_SANSEC_SOCKET_SEND_ERROR 203
# define SDF_R_SANSEC_SOCKET_TIMEOUT 204
# define SDF_R_SANSEC_SYNC_ERROR 205
# define SDF_R_SANSEC_SYNC_LOGIN_ERROR 206
# define SDF_R_SDF_METHOD_RETURN_FAILURE 105
# define SDF_R_SDF_OPERATION_FAILED 106
# define SDF_R_SIGNING_FAILURE 137
# define SDF_R_SUCCESS 138
# define SDF_R_SYMMETRIC_OPERATION_FAILURE 139
# define SDF_R_UNNOWN_ERROR 140
# define SDF_R_VERIFICATION_FAILURE 141
# define SDF_R_WRITE_FILE_FAILURE 142
# define SDF_R_ALGORITHM_MODE_NOT_SUPPORTED 100
# define SDF_R_ALGORITHM_NOT_SUPPORTED 101
# define SDF_R_BUFFER_TOO_SMALL 102
# define SDF_R_COMMUNICATION_FAILURE 103
# define SDF_R_DSO_LOAD_FAILURE 104
# define SDF_R_ENCRYPT_DATA_ERROR 105
# define SDF_R_ERROR 106
# define SDF_R_FILE_ALREADY_EXIST 107
# define SDF_R_FILE_NOT_EXIST 108
# define SDF_R_HARDWARE_ERROR 109
# define SDF_R_INVALID_FILE_OFFSET 110
# define SDF_R_INVALID_FILE_SIZE 111
# define SDF_R_INVALID_INPUT_ARGUMENT 112
# define SDF_R_INVALID_KEY 113
# define SDF_R_INVALID_KEY_TYPE 114
# define SDF_R_INVALID_OUTPUT_ARGUMENT 115
# define SDF_R_INVALID_SANSEC_ECCCIPHER_LENGTH 116
# define SDF_R_INVALID_SM2_CIPHERTEXT_LENGTH 117
# define SDF_R_KEY_NOT_EXIST 118
# define SDF_R_LOAD_LIBRARY_FAILURE 119
# define SDF_R_MAC_ERROR 120
# define SDF_R_MULTI_STEP_OPERATION_ERROR 121
# define SDF_R_NOT_IMPLEMENTED 122
# define SDF_R_NOT_INITIALIZED 123
# define SDF_R_NOT_SUPPORTED_CIPHER_ALGOR 124
# define SDF_R_NOT_SUPPORTED_DIGEST_ALGOR 125
# define SDF_R_NOT_SUPPORTED_ECC_ALGOR 126
# define SDF_R_NOT_SUPPORTED_PKEY_ALGOR 127
# define SDF_R_NO_PRIVATE_KEY_ACCESS_RIGHT 128
# define SDF_R_OPEN_DEVICE_FAILURE 129
# define SDF_R_OPEN_SESSION_FAILURE 130
# define SDF_R_OPERATION_NOT_SUPPORTED 131
# define SDF_R_PRIVATE_KEY_OPERATION_FAILURE 132
# define SDF_R_PRKERR 133
# define SDF_R_PUBLIC_KEY_OPERATION_FAILURE 134
# define SDF_R_RANDOM_GENERATION_ERROR 135
# define SDF_R_SANSEC_BASE 136
# define SDF_R_SANSEC_CARD_ALGOR_NOT_SUPPORTED 137
# define SDF_R_SANSEC_CARD_ALG_MODE_NOT_SUPPORTED 138
# define SDF_R_SANSEC_CARD_BASE 139
# define SDF_R_SANSEC_CARD_BUFFER_TOO_SMALL 140
# define SDF_R_SANSEC_CARD_COMMMUCATION_FAILED 141
# define SDF_R_SANSEC_CARD_CRYPTO_NOT_INITED 142
# define SDF_R_SANSEC_CARD_DATA_PADDING_ERROR 143
# define SDF_R_SANSEC_CARD_DATA_SIZE 144
# define SDF_R_SANSEC_CARD_DEVICE_STATUS_ERROR 145
# define SDF_R_SANSEC_CARD_DEVICE_STATUS_ERROR_05 146
# define SDF_R_SANSEC_CARD_FILE_NOT_EXIST 147
# define SDF_R_SANSEC_CARD_FILE_OFFSET_ERROR 148
# define SDF_R_SANSEC_CARD_FILE_SIZE_ERROR 149
# define SDF_R_SANSEC_CARD_HARDWARE_FAILURE 150
# define SDF_R_SANSEC_CARD_KEY_ERROR 151
# define SDF_R_SANSEC_CARD_KEY_NOT_EXIST 152
# define SDF_R_SANSEC_CARD_KEY_TYPE_ERROR 153
# define SDF_R_SANSEC_CARD_LOGIN_ERROR 154
# define SDF_R_SANSEC_CARD_LOGIN_ERROR_05 155
# define SDF_R_SANSEC_CARD_MANAGEMENT_DENYED 156
# define SDF_R_SANSEC_CARD_MANAGEMENT_DENYED_05 157
# define SDF_R_SANSEC_CARD_NOT_SUPPORTED 158
# define SDF_R_SANSEC_CARD_OPEN_DEVICE_FAILED 159
# define SDF_R_SANSEC_CARD_OPEN_SESSION_FAILED 160
# define SDF_R_SANSEC_CARD_OPERATION_DENYED 161
# define SDF_R_SANSEC_CARD_OPERATION_DENYED_05 162
# define SDF_R_SANSEC_CARD_PARAMENT_ERROR 163
# define SDF_R_SANSEC_CARD_PARAMENT_ERROR_05 164
# define SDF_R_SANSEC_CARD_PRIVATE_KEY_ACCESS_DENYED 165
# define SDF_R_SANSEC_CARD_PRIVATE_KEY_OPERATION_ERROR 166
# define SDF_R_SANSEC_CARD_PUBLIC_KEY_OPERATION_ERROR 167
# define SDF_R_SANSEC_CARD_READER_BASE 168
# define SDF_R_SANSEC_CARD_READER_CARD_INSERT 169
# define SDF_R_SANSEC_CARD_READER_CARD_INSERT_TYPE 170
# define SDF_R_SANSEC_CARD_READER_NO_CARD 171
# define SDF_R_SANSEC_CARD_READER_PIN_ERROR 172
# define SDF_R_SANSEC_CARD_SIGN_ERROR 173
# define SDF_R_SANSEC_CARD_STEP_ERROR 174
# define SDF_R_SANSEC_CARD_SYMMETRIC_ALGOR_ERROR 175
# define SDF_R_SANSEC_CARD_UNKNOW_ERROR 176
# define SDF_R_SANSEC_CARD_USERID_ERROR 177
# define SDF_R_SANSEC_CARD_USERID_ERROR_05 178
# define SDF_R_SANSEC_CARD_VERIFY_ERROR 179
# define SDF_R_SANSEC_CONFIG_ERROR 180
# define SDF_R_SANSEC_CONNECT_ERROR 181
# define SDF_R_SANSEC_FILE_ALREADY_EXIST 182
# define SDF_R_SANSEC_INVALID_AUTHENCODE 183
# define SDF_R_SANSEC_INVALID_COMMAND 184
# define SDF_R_SANSEC_INVALID_PARAMETERS 185
# define SDF_R_SANSEC_INVALID_USER 186
# define SDF_R_SANSEC_NO_AVAILABLE_CSM 187
# define SDF_R_SANSEC_NO_AVAILABLE_HSM 188
# define SDF_R_SANSEC_PROTOCOL_VERSION_ERROR 189
# define SDF_R_SANSEC_SEM_TIMEOUT 190
# define SDF_R_SANSEC_SET_SOCKET_OPTION_ERROR 191
# define SDF_R_SANSEC_SOCKET_RECV_0 192
# define SDF_R_SANSEC_SOCKET_RECV_ERROR 193
# define SDF_R_SANSEC_SOCKET_SEND_ERROR 194
# define SDF_R_SANSEC_SOCKET_TIMEOUT 195
# define SDF_R_SANSEC_SYNC_ERROR 196
# define SDF_R_SANSEC_SYNC_LOGIN_ERROR 197
# define SDF_R_SIGNING_FAILURE 198
# define SDF_R_SUCCESS 199
# define SDF_R_SYMMETRIC_OPERATION_FAILURE 200
# define SDF_R_UNNOWN_ERROR 201
# define SDF_R_VERIFICATION_FAILURE 202
# define SDF_R_WRITE_FILE_FAILURE 203
# ifdef __cplusplus
}

4
include/openssl/opensslv.h
View File

@@ -41,9 +41,9 @@ extern "C" {
*/
# define OPENSSL_VERSION_NUMBER 0x1010004fL
# ifdef OPENSSL_FIPS
# define OPENSSL_VERSION_TEXT "GmSSL 2.5.4 - OpenSSL 1.1.0d-fips 3 Sep 2019"
# define OPENSSL_VERSION_TEXT "GmSSL 2.5.4 - OpenSSL 1.1.0d-fips 19 Jun 2020"
# else
# define OPENSSL_VERSION_TEXT "GmSSL 2.5.4 - OpenSSL 1.1.0d 3 Sep 2019"
# define OPENSSL_VERSION_TEXT "GmSSL 2.5.4 - OpenSSL 1.1.0d 19 Jun 2019"
# endif
/*-

6
include/openssl/sm2.h
View File

@@ -119,10 +119,8 @@ SM2CiphertextValue *d2i_SM2CiphertextValue_fp(FILE *fp, SM2CiphertextValue **a);
int i2d_SM2CiphertextValue_fp(FILE *fp, SM2CiphertextValue *a);
#endif
int i2o_SM2CiphertextValue(const EC_GROUP *group, const SM2CiphertextValue *cv,
unsigned char **pout);
SM2CiphertextValue *o2i_SM2CiphertextValue(const EC_GROUP *group, const EVP_MD *md,
SM2CiphertextValue **cv, const unsigned char **pin, long len);
int SM2_ciphertext_size(const EC_KEY *ec_key, size_t inlen);
SM2CiphertextValue *SM2_do_encrypt(const EVP_MD *md,
const unsigned char *in, size_t inlen, EC_KEY *ec_key);

4
include/openssl/sm9.h
View File

@@ -107,10 +107,6 @@ int SM9PublicKey_get_gmtls_encoded(SM9PublicParameters *mpk,
int SM9_signature_size(const SM9PublicParameters *mpk);
SM9Signature *SM9_do_sign(const unsigned char *dgst, int dgstlen, SM9_KEY *sm9);
int SM9_do_verify(const unsigned char *dgst, int dgstlen,
const SM9Signature *sig, SM9_KEY *sm9);
int SM9_sign(int type,
const unsigned char *data, size_t datalen,
unsigned char *sig, size_t *siglen,

4
java/build.sh Executable file
View File

@@ -0,0 +1,4 @@
cd /path/to/GmSSL/java
gcc -shared -fPIC -Wall -I./jni -I /path/to/gmssl/include -L /path/to/gmssl/lib GmSSL.c -lcrypto -o libgmssljni.so
java -Djava.library.path=/ GmSSL

2
ssl/s3_lib.c
View File

@@ -4221,7 +4221,7 @@ long ssl_get_algorithm2(SSL *s)
return SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF;
} else{
// in the end of finish msg of gmssl handshake, to get the correct hash algo
printf("ssl_get_algorithm2=0x08x\n", ssl_get_algorithm2);
printf("ssl_get_algorithm2=%0x08x\n", ssl_get_algorithm2);
if (alg2 == 0x909){
return SSL_HANDSHAKE_MAC_SM3 | TLS1_PRF_SM3;
}

6
ssl/t1_lib.c
View File

@@ -2982,11 +2982,11 @@ int ssl_parse_serverhello_tlsext(SSL *s, PACKET *pkt)
{
int al = -1;
if (s->version < SSL3_VERSION){
// jump over the ext block
if (s->version < SSL2_VERSION){
/* jump over the ext block */
packet_forward(pkt, pkt->remaining);
return 1;
}
}
if (ssl_scan_serverhello_tlsext(s, pkt, &al) <= 0) {
ssl3_send_alert(s, SSL3_AL_FATAL, al);

80
test/otptest.c
View File

@@ -66,23 +66,71 @@ int main(int argc, char **argv)
int main(int argc, char **argv)
{
OTP_PARAMS params;
unsigned char key[] = {1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8};
unsigned char event[] = "this is a fixed value";
unsigned int otp;
/*
int Tc = 1;
char *K_str[10] = {
"1234567890abcdcf1234567890abcdef",
"1234567890abcdefabcdef1234567890",
"1234567890abcdef0987654321abcdef",
"1234567890abcdefabcdcf0987654321",
"87524138025adcfe2584376195abfedc",
"87524138025adcfeabfcdc2584376195",
"adcfc87524138025abfcdc2584376195",
"58adc3698fe280cb6925010dd236caef",
"58ade365201d80cbdd236cacf6925010",
"65201d80cb58ade3dd236caef6925010",
};
unsigned char key[10][16] = {{0}};
int T[10] = {
1313998979,
1313998995,
1313999014,
1313999047,
1313999067,
1313999098,
1313999131,
1313999155,
1313999174,
1313999189,
};
int C[10] = {
1234,
5621,
5621,
2053,
2058,
2056,
2358,
2547,
6031,
6580,
};
int Q[10] = {
5678,
3698,
3698,
6984,
3024,
2018,
1036,
2058,
2058,
1047,
};
int P[10] = {
814095,
959691,
063014,
302593,
657337,
345821,
629660,
479821,
893826,
607614,
};
*/
params.type = NID_sm3;
params.te = 60;
params.option = NULL;
params.option_size = 0;
params.otp_digits = 6;
if (!OTP_generate(&params, event, sizeof(event), &otp, key, sizeof(key))) {
printf("OTP_generate() failed\n");
return -1;
}
printf("OTP = %06u\n", otp);
return 0;
}
#endif

4
test/sm2test.c
View File

@@ -67,6 +67,10 @@ int main(int argc, char **argv)
# include <openssl/sm2.h>
# include "../crypto/sm2/sm2_lcl.h"
int i2o_SM2CiphertextValue(const EC_GROUP *group, const SM2CiphertextValue *cv,
unsigned char **pout);
SM2CiphertextValue *o2i_SM2CiphertextValue(const EC_GROUP *group, const EVP_MD *md,
SM2CiphertextValue **cv, const unsigned char **pin, long len);
# define VERBOSE 1

2
test/sm9test.c
View File

@@ -416,11 +416,13 @@ int main(int argc, char **argv)
RAND_seed(rnd_seed, sizeof(rnd_seed));
/*
if (!rate_test()) {
printf("sm9 rate pairing test failed\n");
err++;
} else
printf("sm9 rate pairing test passed\n");
*/
if (!sm9test_sign(id, in, sizeof(in)-1, use_test_vector)) {
printf("sm9 sign tests failed\n");

9460
util/libcrypto.num
View File

File diff suppressed because it is too large Load Diff

818
util/libssl.num
View File

@@ -1,411 +1,411 @@
SSL_get_ssl_method 1 1_1_0d EXIST::FUNCTION:
SSL_clear 2 1_1_0d EXIST::FUNCTION:
SSL_set_default_passwd_cb 3 1_1_0d EXIST::FUNCTION:
SSL_COMP_get_name 4 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_bits 5 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_ct_validation_callback 6 1_1_0d EXIST::FUNCTION:CT
SSL_get_current_cipher 7 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_verify_depth 8 1_1_0d EXIST::FUNCTION:
SSL_load_client_CA_file 9 1_1_0d EXIST::FUNCTION:
SSL_add_client_CA 10 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_ex_data 11 1_1_0d EXIST::FUNCTION:
SSL_up_ref 12 1_1_0d EXIST::FUNCTION:
SSL_get_cipher_list 13 1_1_0d EXIST::FUNCTION:
SSL_is_init_finished 14 1_1_0d EXIST::FUNCTION:
SSL_set_default_passwd_cb_userdata 15 1_1_0d EXIST::FUNCTION:
SSL_CTX_add_client_custom_ext 16 1_1_0d EXIST::FUNCTION:
SSL_get_srtp_profiles 17 1_1_0d EXIST::FUNCTION:SRTP
SSL_CTX_set_default_passwd_cb 18 1_1_0d EXIST::FUNCTION:
SSL_set_read_ahead 19 1_1_0d EXIST::FUNCTION:
SSL_in_before 20 1_1_0d EXIST::FUNCTION:
SSL_get_psk_identity_hint 21 1_1_0d EXIST::FUNCTION:PSK
SSL_CTX_sess_set_remove_cb 22 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_auth_nid 23 1_1_0d EXIST::FUNCTION:
SSL_get_selected_srtp_profile 24 1_1_0d EXIST::FUNCTION:SRTP
SSL_test_functions 25 1_1_0d EXIST::FUNCTION:UNIT_TEST
SSL_CTX_sessions 26 1_1_0d EXIST::FUNCTION:
SSL_alert_type_string 27 1_1_0d EXIST::FUNCTION:
SSL_dup_CA_list 28 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_cert_store 29 1_1_0d EXIST::FUNCTION:
SSL_CTX_sess_get_new_cb 30 1_1_0d EXIST::FUNCTION:
SSL_CTX_remove_session 31 1_1_0d EXIST::FUNCTION:
SSL_set1_param 32 1_1_0d EXIST::FUNCTION:
SSL_CTX_ctrl 33 1_1_0d EXIST::FUNCTION:
SSL_CONF_cmd_value_type 34 1_1_0d EXIST::FUNCTION:
SSL_get_psk_identity 35 1_1_0d EXIST::FUNCTION:PSK
SSL_renegotiate_pending 36 1_1_0d EXIST::FUNCTION:
SSL_SESSION_print_fp 37 1_1_0d EXIST::FUNCTION:STDIO
SSL_CIPHER_get_id 38 1_1_0d EXIST::FUNCTION:
SSL_dane_enable 39 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_cipher_nid 40 1_1_0d EXIST::FUNCTION:
SSL_CTX_check_private_key 41 1_1_0d EXIST::FUNCTION:
i2d_SSL_SESSION 42 1_1_0d EXIST::FUNCTION:
SSL_set_psk_client_callback 43 1_1_0d EXIST::FUNCTION:PSK
SSL_SRP_CTX_free 44 1_1_0d EXIST::FUNCTION:SRP
SSL_get_srp_username 45 1_1_0d EXIST::FUNCTION:SRP
SSL_get_client_random 46 1_1_0d EXIST::FUNCTION:
SSL_get_srp_N 47 1_1_0d EXIST::FUNCTION:SRP
SSL_CTX_get_ciphers 48 1_1_0d EXIST::FUNCTION:
SSL_read 49 1_1_0d EXIST::FUNCTION:
SSL_get_peer_finished 50 1_1_0d EXIST::FUNCTION:
SSL_set_session 51 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_standard_name 52 1_1_0d EXIST::FUNCTION:SSL_TRACE
SSL_renegotiate_abbreviated 53 1_1_0d EXIST::FUNCTION:
SSL_get_session 54 1_1_0d EXIST::FUNCTION:
SSL_CTX_sess_get_get_cb 55 1_1_0d EXIST::FUNCTION:
SSL_callback_ctrl 56 1_1_0d EXIST::FUNCTION:
SSL_set0_wbio 57 1_1_0d EXIST::FUNCTION:
SSL_SESSION_print 58 1_1_0d EXIST::FUNCTION:
SSL_CTX_free 59 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_digest_nid 60 1_1_0d EXIST::FUNCTION:
SSL_set_session_ticket_ext 61 1_1_0d EXIST::FUNCTION:
SSL_CTX_load_verify_locations 62 1_1_0d EXIST::FUNCTION:
TLS_method 63 1_1_0d EXIST::FUNCTION:
OPENSSL_init_ssl 64 1_1_0d EXIST::FUNCTION:
SSL_get0_peername 65 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_ctlog_list_file 66 1_1_0d EXIST::FUNCTION:CT
SSL_CTX_set_default_verify_file 67 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_certificate 68 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_default_verify_dir 69 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_default_passwd_cb_userdata 70 1_1_0d EXIST::FUNCTION:
SSL_CTX_config 71 1_1_0d EXIST::FUNCTION:
SSL_set_tmp_dh_callback 72 1_1_0d EXIST::FUNCTION:DH
SSL_CTX_set_cookie_generate_cb 73 1_1_0d EXIST::FUNCTION:
SSL_CTX_has_client_custom_ext 74 1_1_0d EXIST::FUNCTION:
SSL_select_next_proto 75 1_1_0d EXIST::FUNCTION:
SSL_get1_supported_ciphers 76 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get0_cipher 77 1_1_0d EXIST::FUNCTION:
SSL_has_pending 78 1_1_0d EXIST::FUNCTION:
DTLSv1_2_method 79 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_2_METHOD
SSL_CTX_add_client_CA 80 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_purpose 81 1_1_0d EXIST::FUNCTION:
SSL_set_hostflags 82 1_1_0d EXIST::FUNCTION:
SSL_set_wfd 83 1_1_0d EXIST::FUNCTION:SOCK
SSL_get_wbio 84 1_1_0d EXIST::FUNCTION:
PEM_read_bio_SSL_SESSION 85 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_quiet_shutdown 86 1_1_0d EXIST::FUNCTION:
SSL_add_dir_cert_subjects_to_stack 87 1_1_0d EXIST::FUNCTION:
SSL_is_dtls 88 1_1_0d EXIST::FUNCTION:
SSL_get0_peer_scts 89 1_1_0d EXIST::FUNCTION:CT
SSL_CTX_set_default_read_buffer_len 90 1_1_0d EXIST::FUNCTION:
TLS_client_method 91 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_timeout 92 1_1_0d EXIST::FUNCTION:
SSL_get_peer_cert_chain 93 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_client_cert_cb 94 1_1_0d EXIST::FUNCTION:
SSL_dane_clear_flags 95 1_1_0d EXIST::FUNCTION:
SSL_shutdown 96 1_1_0d EXIST::FUNCTION:
GMTLS_client_method 97 1_1_0d EXIST::FUNCTION:GMTLS
SSL_CTX_use_certificate_file 98 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_RSAPrivateKey 99 1_1_0d EXIST::FUNCTION:RSA
SSL_CONF_cmd_argv 100 1_1_0d EXIST::FUNCTION:
SSL_set_session_secret_cb 101 1_1_0d EXIST::FUNCTION:
SSL_get_wfd 102 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_username_callback 103 1_1_0d EXIST::FUNCTION:SRP
SSL_CTX_set_srp_client_pwd_callback 104 1_1_0d EXIST::FUNCTION:SRP
SSL_enable_ct 105 1_1_0d EXIST::FUNCTION:CT
SSL_check_private_key 106 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_ticket_lifetime_hint 107 1_1_0d EXIST::FUNCTION:
SSL_free 108 1_1_0d EXIST::FUNCTION:
BIO_ssl_shutdown 109 1_1_0d EXIST::FUNCTION:
SSL_SESSION_set_ex_data 110 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_cert_cb 111 1_1_0d EXIST::FUNCTION:
BIO_new_ssl_connect 112 1_1_0d EXIST::FUNCTION:
SSL_get_current_expansion 113 1_1_0d EXIST::FUNCTION:
d2i_SSL_SESSION 114 1_1_0d EXIST::FUNCTION:
SSL_set_accept_state 115 1_1_0d EXIST::FUNCTION:
SSL_CTX_set1_param 116 1_1_0d EXIST::FUNCTION:
SSL_ct_is_enabled 117 1_1_0d EXIST::FUNCTION:CT
SSL_get0_dane_tlsa 118 1_1_0d EXIST::FUNCTION:
SSL_set_session_id_context 119 1_1_0d EXIST::FUNCTION:
SSL_set_verify_depth 120 1_1_0d EXIST::FUNCTION:
DTLS_client_method 121 1_1_0d EXIST::FUNCTION:
BIO_new_ssl 122 1_1_0d EXIST::FUNCTION:
SSL_rstate_string_long 123 1_1_0d EXIST::FUNCTION:
SSL_SESSION_up_ref 124 1_1_0d EXIST::FUNCTION:
SSL_srp_server_param_with_username 125 1_1_0d EXIST::FUNCTION:SRP
SSL_CTX_set_timeout 126 1_1_0d EXIST::FUNCTION:
SSL_get_options 127 1_1_0d EXIST::FUNCTION:
SSL_get_srp_g 128 1_1_0d EXIST::FUNCTION:SRP
SSL_set_tlsext_use_srtp 129 1_1_0d EXIST::FUNCTION:SRTP
SSL_CTX_set0_ctlog_store 130 1_1_0d EXIST::FUNCTION:CT
SSL_CTX_get_ssl_method 131 1_1_0d EXIST::FUNCTION:
SSL_get0_verified_chain 132 1_1_0d EXIST::FUNCTION:
SSL_CTX_ct_is_enabled 133 1_1_0d EXIST::FUNCTION:CT
SSL_dane_tlsa_add 134 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_next_proto_select_cb 135 1_1_0d EXIST::FUNCTION:NEXTPROTONEG
SSL_CTX_set_next_protos_advertised_cb 136 1_1_0d EXIST::FUNCTION:NEXTPROTONEG
SSL_set_default_read_buffer_len 137 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_cipher_list 138 1_1_0d EXIST::FUNCTION:
SSL_set_verify 139 1_1_0d EXIST::FUNCTION:
SSL_set_ex_data 140 1_1_0d EXIST::FUNCTION:
SSL_CTX_flush_sessions 141 1_1_0d EXIST::FUNCTION:
SSL_get_default_timeout 142 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_clear_flags 143 1_1_0d EXIST::FUNCTION:
SSL_extension_supported 144 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_PrivateKey_file 145 1_1_0d EXIST::FUNCTION:
PEM_read_SSL_SESSION 146 1_1_0d EXIST::FUNCTION:STDIO
SSL_SESSION_set1_id_context 147 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_protocol_version 148 1_1_0d EXIST::FUNCTION:
SSL_SESSION_set_time 149 1_1_0d EXIST::FUNCTION:
SSL_rstate_string 150 1_1_0d EXIST::FUNCTION:
SSL_set_not_resumable_session_callback 151 1_1_0d EXIST::FUNCTION:
SSL_set_connect_state 152 1_1_0d EXIST::FUNCTION:
SSL_get_rfd 153 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_name 154 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_cert_store 155 1_1_0d EXIST::FUNCTION:
SSL_set_shutdown 156 1_1_0d EXIST::FUNCTION:
SSL_state_string 157 1_1_0d EXIST::FUNCTION:
SSL_config 158 1_1_0d EXIST::FUNCTION:
SSL_set_trust 159 1_1_0d EXIST::FUNCTION:
SSL_set_cert_cb 160 1_1_0d EXIST::FUNCTION:
SSL_waiting_for_async 161 1_1_0d EXIST::FUNCTION:
SSL_CTX_clear_options 162 1_1_0d EXIST::FUNCTION:
SSL_set_bio 163 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_default_passwd_cb_userdata 164 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_default_passwd_cb 165 1_1_0d EXIST::FUNCTION:
SSL_get0_next_proto_negotiated 166 1_1_0d EXIST::FUNCTION:NEXTPROTONEG
SSL_CTX_set_cert_verify_callback 167 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_psk_server_callback 168 1_1_0d EXIST::FUNCTION:PSK
SSL_SESSION_get_compress_id 169 1_1_0d EXIST::FUNCTION:
SSL_use_PrivateKey_ASN1 170 1_1_0d EXIST::FUNCTION:
SSL_get_client_CA_list 171 1_1_0d EXIST::FUNCTION:
GMTLS_server_method 172 1_1_0d EXIST::FUNCTION:GMTLS
SSL_alert_type_string_long 173 1_1_0d EXIST::FUNCTION:
SSL_use_certificate_chain_file 174 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_trust 175 1_1_0d EXIST::FUNCTION:
DTLSv1_method 176 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_METHOD
SSL_get0_dane_authority 177 1_1_0d EXIST::FUNCTION:
TLSv1_server_method 178 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_METHOD
SSL_CTX_get_timeout 1 1_1_0d EXIST::FUNCTION:
SSL_get0_alpn_selected 2 1_1_0d EXIST::FUNCTION:
SSL_get_all_async_fds 3 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_ex_data 4 1_1_0d EXIST::FUNCTION:
SSL_get_info_callback 5 1_1_0d EXIST::FUNCTION:
SSL_add_client_CA 6 1_1_0d EXIST::FUNCTION:
SSLv3_server_method 7 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,SSL3_METHOD
SSL_SESSION_get0_hostname 8 1_1_0d EXIST::FUNCTION:
SSL_get_ex_data 9 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get0_ticket 10 1_1_0d EXIST::FUNCTION:
SSL_write 11 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_info_callback 12 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_cert_cb 13 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_name 14 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_is_aead 15 1_1_0d EXIST::FUNCTION:
SSL_set_cipher_list 16 1_1_0d EXIST::FUNCTION:
DTLS_server_method 17 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_cookie_verify_cb 18 1_1_0d EXIST::FUNCTION:
SSL_set_srp_server_param_pw 19 1_1_0d EXIST::FUNCTION:SRP
SSL_set_session_ticket_ext 20 1_1_0d EXIST::FUNCTION:
SSL_get0_param 21 1_1_0d EXIST::FUNCTION:
SSL_SESSION_set_ex_data 22 1_1_0d EXIST::FUNCTION:
SSL_callback_ctrl 23 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_ssl_method 24 1_1_0d EXIST::FUNCTION:
SSL_dane_enable 25 1_1_0d EXIST::FUNCTION:
SSL_ct_is_enabled 26 1_1_0d EXIST::FUNCTION:CT
SSL_use_certificate_chain_file 27 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_ssl_version 28 1_1_0d EXIST::FUNCTION:
SSL_set0_security_ex_data 29 1_1_0d EXIST::FUNCTION:
SSL_CTX_free 30 1_1_0d EXIST::FUNCTION:
SSL_get_ex_data_X509_STORE_CTX_idx 31 1_1_0d EXIST::FUNCTION:
SSL_CTX_up_ref 32 1_1_0d EXIST::FUNCTION:
SSL_get_verify_callback 33 1_1_0d EXIST::FUNCTION:
SSL_get_SSL_CTX 34 1_1_0d EXIST::FUNCTION:
SSL_CTX_has_client_custom_ext 35 1_1_0d EXIST::FUNCTION:
SSL_get0_dane 36 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_info_callback 37 1_1_0d EXIST::FUNCTION:
SSL_get0_next_proto_negotiated 38 1_1_0d EXIST::FUNCTION:NEXTPROTONEG
SSL_CTX_sess_set_new_cb 39 1_1_0d EXIST::FUNCTION:
SSL_set1_host 40 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_cipher_list 41 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_free 42 1_1_0d EXIST::FUNCTION:
SSL_has_matching_session_id 43 1_1_0d EXIST::FUNCTION:
SSL_get_finished 44 1_1_0d EXIST::FUNCTION:
SSL_dane_tlsa_add 45 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get0_peer 46 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_RSAPrivateKey_ASN1 47 1_1_0d EXIST::FUNCTION:RSA
SSL_CTX_set_default_verify_dir 48 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_quiet_shutdown 49 1_1_0d EXIST::FUNCTION:
SSL_CONF_cmd_value_type 50 1_1_0d EXIST::FUNCTION:
SSL_set_security_callback 51 1_1_0d EXIST::FUNCTION:
SSL_CTX_sess_get_get_cb 52 1_1_0d EXIST::FUNCTION:
GMTLS_client_method 53 1_1_0d EXIST::FUNCTION:GMTLS
SSL_get0_security_ex_data 54 1_1_0d EXIST::FUNCTION:
SSL_CTX_SRP_CTX_free 55 1_1_0d EXIST::FUNCTION:SRP
SSL_get_selected_srtp_profile 56 1_1_0d EXIST::FUNCTION:SRTP
SSL_in_init 57 1_1_0d EXIST::FUNCTION:
SSL_get_ssl_method 58 1_1_0d EXIST::FUNCTION:
TLSv1_method 59 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_METHOD
SSL_get_state 60 1_1_0d EXIST::FUNCTION:
DTLSv1_client_method 61 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_METHOD
SSL_alert_type_string_long 62 1_1_0d EXIST::FUNCTION:
SSL_set_debug 63 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0
SSL_want 64 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_security_level 65 1_1_0d EXIST::FUNCTION:
SSL_COMP_get_name 66 1_1_0d EXIST::FUNCTION:
SSL_get_srtp_profiles 67 1_1_0d EXIST::FUNCTION:SRTP
SSL_CTX_set_options 68 1_1_0d EXIST::FUNCTION:
SSL_set0_wbio 69 1_1_0d EXIST::FUNCTION:
SSL_extension_supported 70 1_1_0d EXIST::FUNCTION:
GMTLS_server_method 71 1_1_0d EXIST::FUNCTION:GMTLS
SSL_export_keying_material 72 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_cipher_nid 73 1_1_0d EXIST::FUNCTION:
SSL_get_default_passwd_cb_userdata 74 1_1_0d EXIST::FUNCTION:
SSL_peek 75 1_1_0d EXIST::FUNCTION:
SSL_get0_dane_authority 76 1_1_0d EXIST::FUNCTION:
SSL_get_shared_ciphers 77 1_1_0d EXIST::FUNCTION:
SSL_do_handshake 78 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_ticket_lifetime_hint 79 1_1_0d EXIST::FUNCTION:
SSL_get_server_random 80 1_1_0d EXIST::FUNCTION:
SSL_state_string_long 81 1_1_0d EXIST::FUNCTION:
SSL_SESSION_has_ticket 82 1_1_0d EXIST::FUNCTION:
SSL_CTX_check_private_key 83 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_ctlog_list_file 84 1_1_0d EXIST::FUNCTION:CT
SSL_CONF_CTX_finish 85 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_ex_data 86 1_1_0d EXIST::FUNCTION:
SSL_get_verify_depth 87 1_1_0d EXIST::FUNCTION:
SSL_set_read_ahead 88 1_1_0d EXIST::FUNCTION:
SSL_get_security_callback 89 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_PrivateKey_file 90 1_1_0d EXIST::FUNCTION:
SSL_get_version 91 1_1_0d EXIST::FUNCTION:
SSL_set0_rbio 92 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_default_ctlog_list_file 93 1_1_0d EXIST::FUNCTION:CT
SSL_set_session_secret_cb 94 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_strength 95 1_1_0d EXIST::FUNCTION:SRP
DTLSv1_method 96 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_METHOD
DTLSv1_2_method 97 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_2_METHOD
PEM_read_bio_SSL_SESSION 98 1_1_0d EXIST::FUNCTION:
SSL_CTX_add_client_CA 99 1_1_0d EXIST::FUNCTION:
SSL_is_gmtls 100 1_1_0d EXIST::FUNCTION:
SSL_add_dir_cert_subjects_to_stack 101 1_1_0d EXIST::FUNCTION:
SSL_get_quiet_shutdown 102 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_client_CA_list 103 1_1_0d EXIST::FUNCTION:
BIO_new_buffer_ssl_connect 104 1_1_0d EXIST::FUNCTION:
SSL_use_RSAPrivateKey_ASN1 105 1_1_0d EXIST::FUNCTION:RSA
SSL_set_verify 106 1_1_0d EXIST::FUNCTION:
SSL_get_security_level 107 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_PrivateKey_ASN1 108 1_1_0d EXIST::FUNCTION:
BIO_new_ssl 109 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_RSAPrivateKey_file 110 1_1_0d EXIST::FUNCTION:RSA
SSL_get_default_timeout 111 1_1_0d EXIST::FUNCTION:
SSL_CTX_dane_enable 112 1_1_0d EXIST::FUNCTION:
SSL_up_ref 113 1_1_0d EXIST::FUNCTION:
SSL_CTX_dane_mtype_set 114 1_1_0d EXIST::FUNCTION:
PEM_read_SSL_SESSION 115 1_1_0d EXIST::FUNCTION:STDIO
SSL_CTX_set_psk_server_callback 116 1_1_0d EXIST::FUNCTION:PSK
SSL_use_certificate 117 1_1_0d EXIST::FUNCTION:
SSL_get_peer_certificate 118 1_1_0d EXIST::FUNCTION:
SSL_set_srp_server_param 119 1_1_0d EXIST::FUNCTION:SRP
SSL_certs_clear 120 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_new 121 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_tmp_dh_callback 122 1_1_0d EXIST::FUNCTION:DH
SSL_accept 123 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_serverinfo_file 124 1_1_0d EXIST::FUNCTION:
SSL_get_error 125 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_set_ssl 126 1_1_0d EXIST::FUNCTION:
SSL_get1_supported_ciphers 127 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_certificate_file 128 1_1_0d EXIST::FUNCTION:
SSL_get_psk_identity 129 1_1_0d EXIST::FUNCTION:PSK
SSL_CTX_get0_param 130 1_1_0d EXIST::FUNCTION:
TLSv1_client_method 131 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_METHOD
SSL_get_rbio 132 1_1_0d EXIST::FUNCTION:
BIO_ssl_copy_session_id 133 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_cookie_generate_cb 134 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_default_passwd_cb 135 1_1_0d EXIST::FUNCTION:
SSL_COMP_get_id 136 1_1_0d EXIST::FUNCTION:
SSL_read 137 1_1_0d EXIST::FUNCTION:
SSL_srp_server_param_with_username 138 1_1_0d EXIST::FUNCTION:SRP
SSL_get_options 139 1_1_0d EXIST::FUNCTION:
SSL_CTX_enable_ct 140 1_1_0d EXIST::FUNCTION:CT
SSL_get_privatekey 141 1_1_0d EXIST::FUNCTION:
SSL_get_session 142 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_verify_mode 143 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_client_cert_cb 144 1_1_0d EXIST::FUNCTION:
SSL_CONF_cmd 145 1_1_0d EXIST::FUNCTION:
SSL_SESSION_print 146 1_1_0d EXIST::FUNCTION:
SSL_version 147 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_client_CA_list 148 1_1_0d EXIST::FUNCTION:
SSL_dane_clear_flags 149 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_client_cert_cb 150 1_1_0d EXIST::FUNCTION:
i2d_SSL_SESSION 151 1_1_0d EXIST::FUNCTION:
SSL_use_RSAPrivateKey 152 1_1_0d EXIST::FUNCTION:RSA
SSL_get_cipher_list 153 1_1_0d EXIST::FUNCTION:
SSL_CTX_add_server_custom_ext 154 1_1_0d EXIST::FUNCTION:
DTLSv1_2_server_method 155 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_2_METHOD
SSL_rstate_string_long 156 1_1_0d EXIST::FUNCTION:
SSL_get_fd 157 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_alpn_protos 158 1_1_0d EXIST::FUNCTION:
TLSv1_2_client_method 159 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_2_METHOD
SSL_set_tlsext_use_srtp 160 1_1_0d EXIST::FUNCTION:SRTP
SSL_test_functions 161 1_1_0d EXIST::FUNCTION:UNIT_TEST
SSL_config 162 1_1_0d EXIST::FUNCTION:
SSL_CTX_SRP_CTX_init 163 1_1_0d EXIST::FUNCTION:SRP
SSL_CIPHER_get_id 164 1_1_0d EXIST::FUNCTION:
SSL_get_srp_N 165 1_1_0d EXIST::FUNCTION:SRP
SSLv3_method 166 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,SSL3_METHOD
SSL_get_rfd 167 1_1_0d EXIST::FUNCTION:
SSL_CTX_dane_set_flags 168 1_1_0d EXIST::FUNCTION:
SSL_set_wfd 169 1_1_0d EXIST::FUNCTION:SOCK
SSL_get_peer_cert_chain 170 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_ciphers 171 1_1_0d EXIST::FUNCTION:
SSL_set_cert_cb 172 1_1_0d EXIST::FUNCTION:
SSL_COMP_get_compression_methods 173 1_1_0d EXIST::FUNCTION:
TLSv1_1_client_method 174 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_1_METHOD
SSL_set_options 175 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_bits 176 1_1_0d EXIST::FUNCTION:
SSL_clear 177 1_1_0d EXIST::FUNCTION:
SSL_set_accept_state 178 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_security_callback 179 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_kx_nid 180 1_1_0d EXIST::FUNCTION:
SSL_get0_param 181 1_1_0d EXIST::FUNCTION:
SSL_CONF_cmd 182 1_1_0d EXIST::FUNCTION:
SSL_accept 183 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_security_callback 184 1_1_0d EXIST::FUNCTION:
SSL_get_sigalgs 185 1_1_0d EXIST::FUNCTION:
SSL_set_options 186 1_1_0d EXIST::FUNCTION:
SSL_get0_dane 187 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_certificate_chain_file 188 1_1_0d EXIST::FUNCTION:
SSL_CTX_sess_set_new_cb 189 1_1_0d EXIST::FUNCTION:
SSL_set_ct_validation_callback 190 1_1_0d EXIST::FUNCTION:CT
SSL_use_PrivateKey 191 1_1_0d EXIST::FUNCTION:
SSL_get_SSL_CTX 192 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_security_level 193 1_1_0d EXIST::FUNCTION:
SSL_write 194 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_set_ssl_ctx 195 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_tlsext_use_srtp 196 1_1_0d EXIST::FUNCTION:SRTP
SSL_get_error 197 1_1_0d EXIST::FUNCTION:
SSL_use_certificate 198 1_1_0d EXIST::FUNCTION:
SSL_get_ex_data_X509_STORE_CTX_idx 199 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_timeout 200 1_1_0d EXIST::FUNCTION:
SSL_get_shared_ciphers 201 1_1_0d EXIST::FUNCTION:
TLSv1_method 202 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_METHOD
SSL_CTX_add_server_custom_ext 203 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_verify_param_callback 204 1_1_0d EXIST::FUNCTION:SRP
SSL_set_cipher_list 205 1_1_0d EXIST::FUNCTION:
SSL_CTX_get0_security_ex_data 206 1_1_0d EXIST::FUNCTION:
SSL_add_ssl_module 207 1_1_0d EXIST::FUNCTION:
SSL_get_client_ciphers 208 1_1_0d EXIST::FUNCTION:
TLSv1_1_client_method 209 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_1_METHOD
SSL_set_srp_server_param_pw 210 1_1_0d EXIST::FUNCTION:SRP
SSL_set_srp_server_param 211 1_1_0d EXIST::FUNCTION:SRP
SSL_SESSION_set1_id 212 1_1_0d EXIST::FUNCTION:
SSL_get_state 213 1_1_0d EXIST::FUNCTION:
SSL_check_chain 214 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_quiet_shutdown 215 1_1_0d EXIST::FUNCTION:
BIO_f_ssl 216 1_1_0d EXIST::FUNCTION:
SSL_COMP_set0_compression_methods 217 1_1_0d EXIST::FUNCTION:
SSL_CTX_sess_set_get_cb 218 1_1_0d EXIST::FUNCTION:
SSL_SESSION_set_timeout 219 1_1_0d EXIST::FUNCTION:
SSL_alert_desc_string_long 220 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_ex_data 221 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_time 222 1_1_0d EXIST::FUNCTION:
SSL_get_privatekey 223 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_cb_arg 224 1_1_0d EXIST::FUNCTION:SRP
SSL_SESSION_print_keylog 225 1_1_0d EXIST::FUNCTION:
SSL_set_purpose 226 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_ex_data 227 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_PrivateKey_ASN1 228 1_1_0d EXIST::FUNCTION:
SSLv3_method 229 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,SSL3_METHOD
TLS_server_method 230 1_1_0d EXIST::FUNCTION:
SSL_connect 231 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_verify_mode 232 1_1_0d EXIST::FUNCTION:
SSL_set_debug 233 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0
SSL_set_msg_callback 234 1_1_0d EXIST::FUNCTION:
SSL_get_default_passwd_cb_userdata 235 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_PrivateKey 236 1_1_0d EXIST::FUNCTION:
SSL_set_session_ticket_ext_cb 237 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_version 238 1_1_0d EXIST::FUNCTION:
SSL_CTX_add_session 239 1_1_0d EXIST::FUNCTION:
SSL_CTX_get0_ctlog_store 240 1_1_0d EXIST::FUNCTION:CT
SSL_CONF_CTX_finish 241 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_session_id_context 242 1_1_0d EXIST::FUNCTION:
SSL_get_srp_userinfo 243 1_1_0d EXIST::FUNCTION:SRP
SSL_CTX_use_serverinfo_file 244 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_security_level 245 1_1_0d EXIST::FUNCTION:
SSL_CTX_get0_privatekey 246 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_generate_session_id 247 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_password 248 1_1_0d EXIST::FUNCTION:SRP
SSL_CTX_set_msg_callback 249 1_1_0d EXIST::FUNCTION:
SSL_get_default_passwd_cb 250 1_1_0d EXIST::FUNCTION:
SSL_get_shutdown 251 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_RSAPrivateKey_ASN1 252 1_1_0d EXIST::FUNCTION:RSA
SSL_renegotiate 253 1_1_0d EXIST::FUNCTION:
SSL_get_verify_depth 254 1_1_0d EXIST::FUNCTION:
DTLS_method 255 1_1_0d EXIST::FUNCTION:
SSL_CTX_get0_certificate 256 1_1_0d EXIST::FUNCTION:
SSL_get_info_callback 257 1_1_0d EXIST::FUNCTION:
SSL_get_verify_callback 258 1_1_0d EXIST::FUNCTION:
SSL_CTX_callback_ctrl 259 1_1_0d EXIST::FUNCTION:
SSL_COMP_get_id 260 1_1_0d EXIST::FUNCTION:
SSL_alert_desc_string 261 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_client_CA_list 262 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_verify_callback 263 1_1_0d EXIST::FUNCTION:
SSL_get_server_random 264 1_1_0d EXIST::FUNCTION:
SSL_get_security_level 265 1_1_0d EXIST::FUNCTION:
SSL_CTX_dane_clear_flags 266 1_1_0d EXIST::FUNCTION:
SSL_set0_rbio 267 1_1_0d EXIST::FUNCTION:
SSL_in_init 268 1_1_0d EXIST::FUNCTION:
SSL_add1_host 269 1_1_0d EXIST::FUNCTION:
SSL_set1_host 270 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_set_flags 271 1_1_0d EXIST::FUNCTION:
SSL_COMP_add_compression_method 272 1_1_0d EXIST::FUNCTION:
SSL_state_string_long 273 1_1_0d EXIST::FUNCTION:
SSL_get0_alpn_selected 274 1_1_0d EXIST::FUNCTION:
SSL_CTX_dane_enable 275 1_1_0d EXIST::FUNCTION:
TLSv1_2_client_method 276 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_2_METHOD
SSL_SESSION_new 277 1_1_0d EXIST::FUNCTION:
SSL_SESSION_free 278 1_1_0d EXIST::FUNCTION:
SSL_dup 279 1_1_0d EXIST::FUNCTION:
TLSv1_1_server_method 280 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_1_METHOD
SSL_CTX_set_default_ctlog_list_file 281 1_1_0d EXIST::FUNCTION:CT
SSL_use_RSAPrivateKey 282 1_1_0d EXIST::FUNCTION:RSA
SSL_new 283 1_1_0d EXIST::FUNCTION:
SSL_set_ssl_method 284 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_set1_prefix 285 1_1_0d EXIST::FUNCTION:
SSL_get_fd 286 1_1_0d EXIST::FUNCTION:
TLSv1_1_method 287 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_1_METHOD
SSL_CTX_set_psk_client_callback 288 1_1_0d EXIST::FUNCTION:PSK
SSL_CIPHER_find 289 1_1_0d EXIST::FUNCTION:
SSL_get_shared_sigalgs 290 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get0_peer 291 1_1_0d EXIST::FUNCTION:
DTLSv1_client_method 292 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_METHOD
SSL_pending 293 1_1_0d EXIST::FUNCTION:
SSL_get_security_callback 294 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_default_verify_paths 295 1_1_0d EXIST::FUNCTION:
SSL_COMP_get0_name 296 1_1_0d EXIST::FUNCTION:
SSL_set_quiet_shutdown 297 1_1_0d EXIST::FUNCTION:
PEM_write_bio_SSL_SESSION 298 1_1_0d EXIST::FUNCTION:
TLSv1_2_server_method 299 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_2_METHOD
SSL_set_rfd 300 1_1_0d EXIST::FUNCTION:SOCK
SSL_CTX_set_cookie_verify_cb 301 1_1_0d EXIST::FUNCTION:
SSL_set0_security_ex_data 302 1_1_0d EXIST::FUNCTION:
SSL_is_server 303 1_1_0d EXIST::FUNCTION:
SSL_CTX_sess_get_remove_cb 304 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_serverinfo 305 1_1_0d EXIST::FUNCTION:
SSL_get_peer_certificate 306 1_1_0d EXIST::FUNCTION:
SSL_get_all_async_fds 307 1_1_0d EXIST::FUNCTION:
SSL_use_RSAPrivateKey_ASN1 308 1_1_0d EXIST::FUNCTION:RSA
SSL_CONF_CTX_set_ssl 309 1_1_0d EXIST::FUNCTION:
SSL_get_read_ahead 310 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_id 311 1_1_0d EXIST::FUNCTION:
SSL_get_ciphers 312 1_1_0d EXIST::FUNCTION:
DTLS_server_method 313 1_1_0d EXIST::FUNCTION:
SSL_set_alpn_protos 314 1_1_0d EXIST::FUNCTION:
SSL_is_gmtls 315 1_1_0d EXIST::FUNCTION:
SSL_get_verify_mode 316 1_1_0d EXIST::FUNCTION:
SSL_client_version 317 1_1_0d EXIST::FUNCTION:
SSL_CTX_SRP_CTX_init 318 1_1_0d EXIST::FUNCTION:SRP
SSL_set_psk_server_callback 319 1_1_0d EXIST::FUNCTION:PSK
SSL_SESSION_has_ticket 320 1_1_0d EXIST::FUNCTION:
DTLSv1_server_method 321 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_METHOD
SSL_set_client_CA_list 322 1_1_0d EXIST::FUNCTION:
SSL_set_verify_result 323 1_1_0d EXIST::FUNCTION:
SSL_CTX_set0_security_ex_data 324 1_1_0d EXIST::FUNCTION:
SSL_set_security_level 325 1_1_0d EXIST::FUNCTION:
SSL_do_handshake 326 1_1_0d EXIST::FUNCTION:
SSL_use_PrivateKey_file 327 1_1_0d EXIST::FUNCTION:
BIO_ssl_copy_session_id 328 1_1_0d EXIST::FUNCTION:
SSL_add_file_cert_subjects_to_stack 329 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get0_ticket 330 1_1_0d EXIST::FUNCTION:
SSL_export_keying_material 331 1_1_0d EXIST::FUNCTION:
SSL_CTX_dane_set_flags 332 1_1_0d EXIST::FUNCTION:
SSL_clear_options 333 1_1_0d EXIST::FUNCTION:
DTLSv1_2_server_method 334 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_2_METHOD
SSL_want 335 1_1_0d EXIST::FUNCTION:
SSL_get_verify_result 336 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_client_cert_engine 337 1_1_0d EXIST::FUNCTION:ENGINE
SSL_get1_session 338 1_1_0d EXIST::FUNCTION:
SSL_set_security_callback 339 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_info_callback 340 1_1_0d EXIST::FUNCTION:
DTLSv1_listen 341 1_1_0d EXIST::FUNCTION:SOCK
SSL_CTX_use_RSAPrivateKey_file 342 1_1_0d EXIST::FUNCTION:RSA
SSL_CTX_set_alpn_protos 343 1_1_0d EXIST::FUNCTION:
SSL_dane_set_flags 344 1_1_0d EXIST::FUNCTION:
SSL_version 345 1_1_0d EXIST::FUNCTION:
SSL_get_current_compression 346 1_1_0d EXIST::FUNCTION:
SSL_use_certificate_file 347 1_1_0d EXIST::FUNCTION:
ERR_load_SSL_strings 348 1_1_0d EXIST::FUNCTION:
SSL_trace 349 1_1_0d EXIST::FUNCTION:SSL_TRACE
BIO_new_buffer_ssl_connect 350 1_1_0d EXIST::FUNCTION:
SSL_get_changed_async_fds 351 1_1_0d EXIST::FUNCTION:
SSL_get_rbio 352 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_free 353 1_1_0d EXIST::FUNCTION:
SSL_CTX_up_ref 354 1_1_0d EXIST::FUNCTION:
SSL_set_info_callback 355 1_1_0d EXIST::FUNCTION:
SSL_certs_clear 356 1_1_0d EXIST::FUNCTION:
SSL_get_finished 357 1_1_0d EXIST::FUNCTION:
SSL_set_SSL_CTX 358 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_new 359 1_1_0d EXIST::FUNCTION:
SSL_use_certificate_ASN1 360 1_1_0d EXIST::FUNCTION:
SSL_CTX_dane_mtype_set 361 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_client_cert_cb 362 1_1_0d EXIST::FUNCTION:
SSL_get_servername_type 363 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_certificate_ASN1 364 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_tmp_dh_callback 365 1_1_0d EXIST::FUNCTION:DH
SSL_CTX_enable_ct 366 1_1_0d EXIST::FUNCTION:CT
SSL_set_generate_session_id 367 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_client_CA_list 368 1_1_0d EXIST::FUNCTION:
SSL_get_version 369 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_info_callback 370 1_1_0d EXIST::FUNCTION:
TLSv1_2_method 371 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_2_METHOD
SSL_has_matching_session_id 372 1_1_0d EXIST::FUNCTION:
DTLSv1_2_client_method 373 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_2_METHOD
SSL_set_fd 374 1_1_0d EXIST::FUNCTION:SOCK
SSL_CTX_set_ssl_version 375 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get0_id_context 376 1_1_0d EXIST::FUNCTION:
SSL_copy_session_id 377 1_1_0d EXIST::FUNCTION:
SSL_get_ex_data 378 1_1_0d EXIST::FUNCTION:
SSL_CTX_get0_param 379 1_1_0d EXIST::FUNCTION:
SSL_SRP_CTX_init 380 1_1_0d EXIST::FUNCTION:SRP
SSL_CTX_set_verify 381 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_verify_depth 382 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_is_aead 383 1_1_0d EXIST::FUNCTION:
PEM_write_SSL_SESSION 384 1_1_0d EXIST::FUNCTION:STDIO
SSL_CTX_set_options 385 1_1_0d EXIST::FUNCTION:
SSL_COMP_get_compression_methods 386 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_not_resumable_session_callback 387 1_1_0d EXIST::FUNCTION:
SSL_CTX_SRP_CTX_free 388 1_1_0d EXIST::FUNCTION:SRP
SSL_CIPHER_description 389 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_psk_identity_hint 390 1_1_0d EXIST::FUNCTION:PSK
SSL_peek 391 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get0_hostname 392 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_master_key 393 1_1_0d EXIST::FUNCTION:
SSL_get_quiet_shutdown 394 1_1_0d EXIST::FUNCTION:
SSL_use_psk_identity_hint 395 1_1_0d EXIST::FUNCTION:PSK
GMTLS_method 396 1_1_0d EXIST::FUNCTION:GMTLS
SSL_get_servername 397 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_alpn_select_cb 398 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_username 399 1_1_0d EXIST::FUNCTION:SRP
SRP_Calc_A_param 400 1_1_0d EXIST::FUNCTION:SRP
SSL_use_RSAPrivateKey_file 401 1_1_0d EXIST::FUNCTION:RSA
SSL_CTX_get_options 402 1_1_0d EXIST::FUNCTION:
SSL_get_certificate 403 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_strength 404 1_1_0d EXIST::FUNCTION:SRP
SSL_CTX_new 405 1_1_0d EXIST::FUNCTION:
SSLv3_server_method 406 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,SSL3_METHOD
SSLv3_client_method 407 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,SSL3_METHOD
SSL_get0_dane_tlsa 180 1_1_0d EXIST::FUNCTION:
SSL_get_wfd 181 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_psk_client_callback 182 1_1_0d EXIST::FUNCTION:PSK
SSL_get0_peername 183 1_1_0d EXIST::FUNCTION:
SSL_new 184 1_1_0d EXIST::FUNCTION:
SSL_enable_ct 185 1_1_0d EXIST::FUNCTION:CT
SSL_CONF_CTX_clear_flags 186 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_password 187 1_1_0d EXIST::FUNCTION:SRP
SSL_CTX_set0_ctlog_store 188 1_1_0d EXIST::FUNCTION:CT
SSL_use_certificate_ASN1 189 1_1_0d EXIST::FUNCTION:
SSL_get_srp_g 190 1_1_0d EXIST::FUNCTION:SRP
SSL_get_shared_sigalgs 191 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_find 192 1_1_0d EXIST::FUNCTION:
SSL_set_security_level 193 1_1_0d EXIST::FUNCTION:
SSL_set_quiet_shutdown 194 1_1_0d EXIST::FUNCTION:
SSL_CTX_add_client_custom_ext 195 1_1_0d EXIST::FUNCTION:
SSL_shutdown 196 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_trust 197 1_1_0d EXIST::FUNCTION:
SSL_use_PrivateKey 198 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get0_id_context 199 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_ct_validation_callback 200 1_1_0d EXIST::FUNCTION:CT
TLS_server_method 201 1_1_0d EXIST::FUNCTION:
TLSv1_1_method 202 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_1_METHOD
SSL_get_servername 203 1_1_0d EXIST::FUNCTION:
SSL_CTX_sess_set_get_cb 204 1_1_0d EXIST::FUNCTION:
TLSv1_server_method 205 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_METHOD
SSL_CTX_set_default_verify_paths 206 1_1_0d EXIST::FUNCTION:
SSL_add1_host 207 1_1_0d EXIST::FUNCTION:
TLS_client_method 208 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_cb_arg 209 1_1_0d EXIST::FUNCTION:SRP
d2i_SSL_SESSION 210 1_1_0d EXIST::FUNCTION:
SSL_add_file_cert_subjects_to_stack 211 1_1_0d EXIST::FUNCTION:
SSL_get_servername_type 212 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_options 213 1_1_0d EXIST::FUNCTION:
SSL_is_init_finished 214 1_1_0d EXIST::FUNCTION:
SSL_CTX_ct_is_enabled 215 1_1_0d EXIST::FUNCTION:CT
SSL_state_string 216 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_verify_callback 217 1_1_0d EXIST::FUNCTION:
SSL_use_certificate_file 218 1_1_0d EXIST::FUNCTION:
SSL_get_peer_finished 219 1_1_0d EXIST::FUNCTION:
SSL_client_version 220 1_1_0d EXIST::FUNCTION:
SSL_SRP_CTX_free 221 1_1_0d EXIST::FUNCTION:SRP
SSL_set_ct_validation_callback 222 1_1_0d EXIST::FUNCTION:CT
DTLS_method 223 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_cert_store 224 1_1_0d EXIST::FUNCTION:
SSL_SRP_CTX_init 225 1_1_0d EXIST::FUNCTION:SRP
SSL_SESSION_set_time 226 1_1_0d EXIST::FUNCTION:
SSL_set_purpose 227 1_1_0d EXIST::FUNCTION:
TLSv1_1_server_method 228 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_1_METHOD
SSL_CTX_set_cert_verify_callback 229 1_1_0d EXIST::FUNCTION:
SSL_get1_session 230 1_1_0d EXIST::FUNCTION:
TLS_method 231 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_next_protos_advertised_cb 232 1_1_0d EXIST::FUNCTION:NEXTPROTONEG
SSL_CTX_add_session 233 1_1_0d EXIST::FUNCTION:
SSL_CONF_CTX_set_ssl_ctx 234 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_quiet_shutdown 235 1_1_0d EXIST::FUNCTION:
SSL_set1_param 236 1_1_0d EXIST::FUNCTION:
SSL_set_psk_server_callback 237 1_1_0d EXIST::FUNCTION:PSK
SSL_COMP_add_compression_method 238 1_1_0d EXIST::FUNCTION:
SSL_use_RSAPrivateKey_file 239 1_1_0d EXIST::FUNCTION:RSA
SSL_get_psk_identity_hint 240 1_1_0d EXIST::FUNCTION:PSK
SSL_use_PrivateKey_file 241 1_1_0d EXIST::FUNCTION:
SSL_alert_desc_string 242 1_1_0d EXIST::FUNCTION:
SSL_add_ssl_module 243 1_1_0d EXIST::FUNCTION:
SSL_CTX_new 244 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_username_callback 245 1_1_0d EXIST::FUNCTION:SRP
SSL_set_default_read_buffer_len 246 1_1_0d EXIST::FUNCTION:
BIO_f_ssl 247 1_1_0d EXIST::FUNCTION:
SSL_get_sigalgs 248 1_1_0d EXIST::FUNCTION:
PEM_write_bio_SSL_SESSION 249 1_1_0d EXIST::FUNCTION:
SSL_clear_options 250 1_1_0d EXIST::FUNCTION:
DTLSv1_server_method 251 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_METHOD
SSL_CTX_use_serverinfo 252 1_1_0d EXIST::FUNCTION:
SSL_set_msg_callback 253 1_1_0d EXIST::FUNCTION:
SSL_use_PrivateKey_ASN1 254 1_1_0d EXIST::FUNCTION:
SSL_COMP_set0_compression_methods 255 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_digest_nid 256 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_auth_nid 257 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get0_cipher 258 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_default_verify_file 259 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_msg_callback 260 1_1_0d EXIST::FUNCTION:
SSL_set_not_resumable_session_callback 261 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_standard_name 262 1_1_0d EXIST::FUNCTION:SSL_TRACE
SSL_CTX_use_psk_identity_hint 263 1_1_0d EXIST::FUNCTION:PSK
SSL_get_current_cipher 264 1_1_0d EXIST::FUNCTION:
SSL_SESSION_up_ref 265 1_1_0d EXIST::FUNCTION:
SSL_set_verify_depth 266 1_1_0d EXIST::FUNCTION:
SSL_COMP_get0_name 267 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_RSAPrivateKey 268 1_1_0d EXIST::FUNCTION:RSA
SSL_SESSION_get_protocol_version 269 1_1_0d EXIST::FUNCTION:
SSL_set_session 270 1_1_0d EXIST::FUNCTION:
SSL_SESSION_set1_id 271 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_session_id_context 272 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_cert_store 273 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_verify_param_callback 274 1_1_0d EXIST::FUNCTION:SRP
SSL_check_private_key 275 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_time 276 1_1_0d EXIST::FUNCTION:
SSL_get_changed_async_fds 277 1_1_0d EXIST::FUNCTION:
SSL_get_verify_mode 278 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_certificate 279 1_1_0d EXIST::FUNCTION:
SSL_get0_peer_scts 280 1_1_0d EXIST::FUNCTION:CT
SSL_CTX_sess_get_remove_cb 281 1_1_0d EXIST::FUNCTION:
SSL_get_certificate 282 1_1_0d EXIST::FUNCTION:
SSL_alert_desc_string_long 283 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_generate_session_id 284 1_1_0d EXIST::FUNCTION:
SSL_get_read_ahead 285 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_certificate_chain_file 286 1_1_0d EXIST::FUNCTION:
SSL_get_srp_username 287 1_1_0d EXIST::FUNCTION:SRP
GMTLS_method 288 1_1_0d EXIST::FUNCTION:GMTLS
SSL_CTX_config 289 1_1_0d EXIST::FUNCTION:
SSL_dane_set_flags 290 1_1_0d EXIST::FUNCTION:
SSL_CTX_set1_param 291 1_1_0d EXIST::FUNCTION:
SSL_dup 292 1_1_0d EXIST::FUNCTION:
PEM_write_SSL_SESSION 293 1_1_0d EXIST::FUNCTION:STDIO
SSL_CTX_set_client_cert_engine 294 1_1_0d EXIST::FUNCTION:ENGINE
SSL_CTX_sess_get_new_cb 295 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_next_proto_select_cb 296 1_1_0d EXIST::FUNCTION:NEXTPROTONEG
SRP_Calc_A_param 297 1_1_0d EXIST::FUNCTION:SRP
SSL_set_ssl_method 298 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_alpn_select_cb 299 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_client_pwd_callback 300 1_1_0d EXIST::FUNCTION:SRP
SSL_renegotiate_abbreviated 301 1_1_0d EXIST::FUNCTION:
DTLS_client_method 302 1_1_0d EXIST::FUNCTION:
SSL_is_dtls 303 1_1_0d EXIST::FUNCTION:
SSL_free 304 1_1_0d EXIST::FUNCTION:
SSL_CTX_ctrl 305 1_1_0d EXIST::FUNCTION:
SSL_CTX_dane_clear_flags 306 1_1_0d EXIST::FUNCTION:
SSL_get_client_random 307 1_1_0d EXIST::FUNCTION:
SSL_use_psk_identity_hint 308 1_1_0d EXIST::FUNCTION:PSK
SSL_CTX_set_security_callback 309 1_1_0d EXIST::FUNCTION:
BIO_new_ssl_connect 310 1_1_0d EXIST::FUNCTION:
SSL_get_verify_result 311 1_1_0d EXIST::FUNCTION:
SSL_set_session_ticket_ext_cb 312 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_timeout 313 1_1_0d EXIST::FUNCTION:
SSL_select_next_proto 314 1_1_0d EXIST::FUNCTION:
SSL_check_chain 315 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_default_passwd_cb 316 1_1_0d EXIST::FUNCTION:
DTLSv1_2_client_method 317 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,DTLS1_2_METHOD
SSL_CONF_CTX_set_flags 318 1_1_0d EXIST::FUNCTION:
SSL_SESSION_print_keylog 319 1_1_0d EXIST::FUNCTION:
SSL_set_bio 320 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_timeout 321 1_1_0d EXIST::FUNCTION:
BIO_ssl_shutdown 322 1_1_0d EXIST::FUNCTION:
SSL_set_fd 323 1_1_0d EXIST::FUNCTION:SOCK
SSL_CIPHER_get_version 324 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_PrivateKey 325 1_1_0d EXIST::FUNCTION:
SSL_set_connect_state 326 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_tlsext_use_srtp 327 1_1_0d EXIST::FUNCTION:SRTP
SSL_CONF_CTX_set1_prefix 328 1_1_0d EXIST::FUNCTION:
SSL_set_default_passwd_cb 329 1_1_0d EXIST::FUNCTION:
SSL_set_generate_session_id 330 1_1_0d EXIST::FUNCTION:
SSL_connect 331 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_id 332 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_description 333 1_1_0d EXIST::FUNCTION:
SSL_get0_verified_chain 334 1_1_0d EXIST::FUNCTION:
SSL_set_ex_data 335 1_1_0d EXIST::FUNCTION:
SSL_SESSION_print_fp 336 1_1_0d EXIST::FUNCTION:STDIO
SSL_CTX_set_verify_depth 337 1_1_0d EXIST::FUNCTION:
TLSv1_2_method 338 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_2_METHOD
SSL_set_info_callback 339 1_1_0d EXIST::FUNCTION:
SSL_CTX_remove_session 340 1_1_0d EXIST::FUNCTION:
SSL_rstate_string 341 1_1_0d EXIST::FUNCTION:
ERR_load_SSL_strings 342 1_1_0d EXIST::FUNCTION:
SSL_CTX_set0_security_ex_data 343 1_1_0d EXIST::FUNCTION:
SSL_SESSION_set_timeout 344 1_1_0d EXIST::FUNCTION:
TLSv1_2_server_method 345 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_2_METHOD
SSL_load_client_CA_file 346 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_default_passwd_cb_userdata 347 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_default_passwd_cb_userdata 348 1_1_0d EXIST::FUNCTION:
SSL_pending 349 1_1_0d EXIST::FUNCTION:
SSL_SESSION_free 350 1_1_0d EXIST::FUNCTION:
SSL_alert_type_string 351 1_1_0d EXIST::FUNCTION:
SSL_CTX_use_certificate_ASN1 352 1_1_0d EXIST::FUNCTION:
SSL_set_hostflags 353 1_1_0d EXIST::FUNCTION:
SSL_CTX_get_verify_depth 354 1_1_0d EXIST::FUNCTION:
SSL_CTX_clear_options 355 1_1_0d EXIST::FUNCTION:
SSL_CIPHER_get_kx_nid 356 1_1_0d EXIST::FUNCTION:
SSL_get_wbio 357 1_1_0d EXIST::FUNCTION:
SSL_CTX_load_verify_locations 358 1_1_0d EXIST::FUNCTION:
SSL_CTX_sess_set_remove_cb 359 1_1_0d EXIST::FUNCTION:
SSL_get_current_compression 360 1_1_0d EXIST::FUNCTION:
SSL_ctrl 361 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_purpose 362 1_1_0d EXIST::FUNCTION:
SSL_SESSION_get_compress_id 363 1_1_0d EXIST::FUNCTION:
SSL_SESSION_set1_id_context 364 1_1_0d EXIST::FUNCTION:
SSL_set_client_CA_list 365 1_1_0d EXIST::FUNCTION:
SSL_set_trust 366 1_1_0d EXIST::FUNCTION:
SSL_renegotiate 367 1_1_0d EXIST::FUNCTION:
SSL_get_client_ciphers 368 1_1_0d EXIST::FUNCTION:
OPENSSL_init_ssl 369 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_srp_username 370 1_1_0d EXIST::FUNCTION:SRP
SSLv3_client_method 371 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,SSL3_METHOD
SSL_get_default_passwd_cb 372 1_1_0d EXIST::FUNCTION:
SSL_SESSION_new 373 1_1_0d EXIST::FUNCTION:
SSL_dup_CA_list 374 1_1_0d EXIST::FUNCTION:
SSL_CTX_get0_certificate 375 1_1_0d EXIST::FUNCTION:
SSL_copy_session_id 376 1_1_0d EXIST::FUNCTION:
SSL_CONF_cmd_argv 377 1_1_0d EXIST::FUNCTION:
SSL_CTX_get0_security_ex_data 378 1_1_0d EXIST::FUNCTION:
SSL_set_psk_client_callback 379 1_1_0d EXIST::FUNCTION:PSK
SSL_CTX_set_security_level 380 1_1_0d EXIST::FUNCTION:
SSL_get_client_CA_list 381 1_1_0d EXIST::FUNCTION:
SSL_set_verify_result 382 1_1_0d EXIST::FUNCTION:
SSL_set_default_passwd_cb_userdata 383 1_1_0d EXIST::FUNCTION:
SSL_waiting_for_async 384 1_1_0d EXIST::FUNCTION:
SSL_get_current_expansion 385 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_verify 386 1_1_0d EXIST::FUNCTION:
SSL_CTX_sessions 387 1_1_0d EXIST::FUNCTION:
SSL_CTX_callback_ctrl 388 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_not_resumable_session_callback 389 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_ex_data 390 1_1_0d EXIST::FUNCTION:
DTLSv1_listen 391 1_1_0d EXIST::FUNCTION:SOCK
SSL_trace 392 1_1_0d EXIST::FUNCTION:SSL_TRACE
SSL_has_pending 393 1_1_0d EXIST::FUNCTION:
SSL_set_tmp_dh_callback 394 1_1_0d EXIST::FUNCTION:DH
SSL_SESSION_get_master_key 395 1_1_0d EXIST::FUNCTION:
SSL_set_session_id_context 396 1_1_0d EXIST::FUNCTION:
SSL_is_server 397 1_1_0d EXIST::FUNCTION:
SSL_get_shutdown 398 1_1_0d EXIST::FUNCTION:
SSL_set_alpn_protos 399 1_1_0d EXIST::FUNCTION:
SSL_get_srp_userinfo 400 1_1_0d EXIST::FUNCTION:SRP
SSL_CTX_get0_privatekey 401 1_1_0d EXIST::FUNCTION:
SSL_set_SSL_CTX 402 1_1_0d EXIST::FUNCTION:
SSL_in_before 403 1_1_0d EXIST::FUNCTION:
SSL_CTX_set_default_read_buffer_len 404 1_1_0d EXIST::FUNCTION:
SSL_CTX_get0_ctlog_store 405 1_1_0d EXIST::FUNCTION:CT
SSL_set_shutdown 406 1_1_0d EXIST::FUNCTION:
SSL_set_rfd 407 1_1_0d EXIST::FUNCTION:SOCK
SSL_session_reused 408 1_1_0d EXIST::FUNCTION:
TLSv1_client_method 409 1_1_0d EXIST::FUNCTION:DEPRECATEDIN_1_1_0,TLS1_METHOD
SSL_get0_security_ex_data 410 1_1_0d EXIST::FUNCTION:
SSL_ctrl 411 1_1_0d EXIST::FUNCTION:
SSL_renegotiate_pending 409 1_1_0d EXIST::FUNCTION:
SSL_CTX_flush_sessions 410 1_1_0d EXIST::FUNCTION:
SSL_get_ciphers 411 1_1_0d EXIST::FUNCTION: