sync code with last fixes and improvements from OpenBSD
This commit is contained in:
parent
691f97cc10
commit
371ae113c6
GPG key ID:
F42C07F07E2E35B7
175 changed files with 2932 additions and 1512 deletions
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: aes.h,v 1.14 2014/07/09 09:10:07 miod Exp $ */
|
||||
/* $OpenBSD: aes.h,v 1.15 2023/07/31 05:04:06 tb Exp $ */
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
|
|
@ -79,8 +79,6 @@ struct aes_key_st {
|
|||
};
|
||||
typedef struct aes_key_st AES_KEY;
|
||||
|
||||
const char *AES_options(void);
|
||||
|
||||
int AES_set_encrypt_key(const unsigned char *userKey, const int bits,
|
||||
AES_KEY *key);
|
||||
int AES_set_decrypt_key(const unsigned char *userKey, const int bits,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: blowfish.h,v 1.16 2022/11/11 12:08:29 jsing Exp $ */
|
||||
/* $OpenBSD: blowfish.h,v 1.17 2023/07/31 05:04:06 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -102,7 +102,6 @@ void BF_cfb64_encrypt(const unsigned char *in, unsigned char *out, long length,
|
|||
const BF_KEY *schedule, unsigned char *ivec, int *num, int enc);
|
||||
void BF_ofb64_encrypt(const unsigned char *in, unsigned char *out, long length,
|
||||
const BF_KEY *schedule, unsigned char *ivec, int *num);
|
||||
const char *BF_options(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bio_lib.c,v 1.47 2023/07/10 02:33:33 tb Exp $ */
|
||||
/* $OpenBSD: bio_lib.c,v 1.48 2023/08/07 10:58:56 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -816,7 +816,8 @@ LCRYPTO_ALIAS(BIO_free_all);
|
|||
BIO *
|
||||
BIO_dup_chain(BIO *in)
|
||||
{
|
||||
BIO *ret = NULL, *eoc = NULL, *bio, *new_bio;
|
||||
BIO *new_chain = NULL, *new_bio = NULL, *tail = NULL;
|
||||
BIO *bio;
|
||||
|
||||
for (bio = in; bio != NULL; bio = bio->next_bio) {
|
||||
if ((new_bio = BIO_new(bio->method)) == NULL)
|
||||
|
|
@ -827,33 +828,30 @@ BIO_dup_chain(BIO *in)
|
|||
new_bio->init = bio->init;
|
||||
new_bio->shutdown = bio->shutdown;
|
||||
new_bio->flags = bio->flags;
|
||||
|
||||
/* This will let SSL_s_sock() work with stdin/stdout */
|
||||
new_bio->num = bio->num;
|
||||
|
||||
if (!BIO_dup_state(bio, (char *)new_bio)) {
|
||||
BIO_free(new_bio);
|
||||
if (!BIO_dup_state(bio, new_bio))
|
||||
goto err;
|
||||
}
|
||||
|
||||
/* copy app data */
|
||||
if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO,
|
||||
&new_bio->ex_data, &bio->ex_data))
|
||||
goto err;
|
||||
|
||||
if (ret == NULL) {
|
||||
eoc = new_bio;
|
||||
ret = eoc;
|
||||
} else {
|
||||
BIO_push(eoc, new_bio);
|
||||
eoc = new_bio;
|
||||
}
|
||||
}
|
||||
return (ret);
|
||||
err:
|
||||
BIO_free(ret);
|
||||
return (NULL);
|
||||
if (BIO_push(tail, new_bio) == NULL)
|
||||
goto err;
|
||||
|
||||
tail = new_bio;
|
||||
if (new_chain == NULL)
|
||||
new_chain = new_bio;
|
||||
}
|
||||
|
||||
return new_chain;
|
||||
|
||||
err:
|
||||
BIO_free(new_bio);
|
||||
BIO_free_all(new_chain);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
LCRYPTO_ALIAS(BIO_dup_chain);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bss_sock.c,v 1.26 2023/07/05 21:23:37 beck Exp $ */
|
||||
/* $OpenBSD: bss_sock.c,v 1.27 2023/08/07 10:54:14 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -173,7 +173,7 @@ sock_ctrl(BIO *b, int cmd, long num, void *ptr)
|
|||
switch (cmd) {
|
||||
case BIO_C_SET_FD:
|
||||
sock_free(b);
|
||||
b->num= *((int *)ptr);
|
||||
b->num = *((int *)ptr);
|
||||
b->shutdown = (int)num;
|
||||
b->init = 1;
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bn.h,v 1.74 2023/07/28 10:07:30 tb Exp $ */
|
||||
/* $OpenBSD: bn.h,v 1.75 2023/07/31 05:04:06 tb Exp $ */
|
||||
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -318,7 +318,6 @@ void BN_zero(BIGNUM *a);
|
|||
int BN_one(BIGNUM *a);
|
||||
|
||||
const BIGNUM *BN_value_one(void);
|
||||
char * BN_options(void);
|
||||
BN_CTX *BN_CTX_new(void);
|
||||
void BN_CTX_free(BN_CTX *c);
|
||||
void BN_CTX_start(BN_CTX *ctx);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bn_blind.c,v 1.24 2023/07/28 10:05:16 tb Exp $ */
|
||||
/* $OpenBSD: bn_blind.c,v 1.32 2023/08/02 09:25:36 tb Exp $ */
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
|
|
@ -123,27 +123,25 @@ struct bn_blinding_st {
|
|||
BIGNUM *A;
|
||||
BIGNUM *Ai;
|
||||
BIGNUM *e;
|
||||
BIGNUM *mod; /* just a reference */
|
||||
BIGNUM *mod;
|
||||
CRYPTO_THREADID tid;
|
||||
int counter;
|
||||
unsigned long flags;
|
||||
BN_MONT_CTX *m_ctx;
|
||||
int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
|
||||
};
|
||||
|
||||
BN_BLINDING *
|
||||
static BN_BLINDING *
|
||||
BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod)
|
||||
{
|
||||
BN_BLINDING *ret = NULL;
|
||||
|
||||
|
||||
if ((ret = calloc(1, sizeof(BN_BLINDING))) == NULL) {
|
||||
BNerror(ERR_R_MALLOC_FAILURE);
|
||||
return (NULL);
|
||||
return NULL;
|
||||
}
|
||||
if (A != NULL) {
|
||||
if ((ret->A = BN_dup(A)) == NULL)
|
||||
if ((ret->A = BN_dup(A)) == NULL)
|
||||
goto err;
|
||||
}
|
||||
if (Ai != NULL) {
|
||||
|
|
@ -164,10 +162,11 @@ BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod)
|
|||
CRYPTO_THREADID_current(&ret->tid);
|
||||
return (ret);
|
||||
|
||||
err:
|
||||
err:
|
||||
if (ret != NULL)
|
||||
BN_BLINDING_free(ret);
|
||||
return (NULL);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -183,12 +182,12 @@ BN_BLINDING_free(BN_BLINDING *r)
|
|||
free(r);
|
||||
}
|
||||
|
||||
int
|
||||
static int
|
||||
BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
if ((b->A == NULL) || (b->Ai == NULL)) {
|
||||
if (b->A == NULL || b->Ai == NULL) {
|
||||
BNerror(BN_R_NOT_INITIALIZED);
|
||||
goto err;
|
||||
}
|
||||
|
|
@ -196,12 +195,11 @@ BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
|
|||
if (b->counter == -1)
|
||||
b->counter = 0;
|
||||
|
||||
if (++b->counter == BN_BLINDING_COUNTER && b->e != NULL &&
|
||||
!(b->flags & BN_BLINDING_NO_RECREATE)) {
|
||||
if (++b->counter == BN_BLINDING_COUNTER && b->e != NULL) {
|
||||
/* re-create blinding parameters */
|
||||
if (!BN_BLINDING_create_param(b, NULL, NULL, ctx, NULL, NULL))
|
||||
goto err;
|
||||
} else if (!(b->flags & BN_BLINDING_NO_UPDATE)) {
|
||||
} else {
|
||||
if (!BN_mod_mul(b->A, b->A, b->A, b->mod, ctx))
|
||||
goto err;
|
||||
if (!BN_mod_mul(b->Ai, b->Ai, b->Ai, b->mod, ctx))
|
||||
|
|
@ -210,58 +208,45 @@ BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
|
|||
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
err:
|
||||
if (b->counter == BN_BLINDING_COUNTER)
|
||||
b->counter = 0;
|
||||
return (ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int
|
||||
BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
|
||||
{
|
||||
return BN_BLINDING_convert_ex(n, NULL, b, ctx);
|
||||
}
|
||||
|
||||
int
|
||||
BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx)
|
||||
BN_BLINDING_convert(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx)
|
||||
{
|
||||
int ret = 1;
|
||||
|
||||
|
||||
if ((b->A == NULL) || (b->Ai == NULL)) {
|
||||
if (b->A == NULL || b->Ai == NULL) {
|
||||
BNerror(BN_R_NOT_INITIALIZED);
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (b->counter == -1)
|
||||
/* Fresh blinding, doesn't need updating. */
|
||||
b->counter = 0;
|
||||
else if (!BN_BLINDING_update(b, ctx))
|
||||
return (0);
|
||||
return 0;
|
||||
|
||||
if (r != NULL) {
|
||||
if (!bn_copy(r, b->Ai))
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
if (!BN_mod_mul(n, n,b->A, b->mod, ctx))
|
||||
if (!BN_mod_mul(n, n, b->A, b->mod, ctx))
|
||||
ret = 0;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int
|
||||
BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
|
||||
{
|
||||
return BN_BLINDING_invert_ex(n, NULL, b, ctx);
|
||||
}
|
||||
|
||||
int
|
||||
BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx)
|
||||
BN_BLINDING_invert(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx)
|
||||
{
|
||||
int ret;
|
||||
|
||||
|
||||
if (r != NULL)
|
||||
ret = BN_mod_mul(n, n, r, b->mod, ctx);
|
||||
else {
|
||||
|
|
@ -272,7 +257,7 @@ BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx)
|
|||
ret = BN_mod_mul(n, n, b->Ai, b->mod, ctx);
|
||||
}
|
||||
|
||||
return (ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
CRYPTO_THREADID *
|
||||
|
|
@ -281,25 +266,13 @@ BN_BLINDING_thread_id(BN_BLINDING *b)
|
|||
return &b->tid;
|
||||
}
|
||||
|
||||
unsigned long
|
||||
BN_BLINDING_get_flags(const BN_BLINDING *b)
|
||||
{
|
||||
return b->flags;
|
||||
}
|
||||
|
||||
void
|
||||
BN_BLINDING_set_flags(BN_BLINDING *b, unsigned long flags)
|
||||
{
|
||||
b->flags = flags;
|
||||
}
|
||||
|
||||
BN_BLINDING *
|
||||
BN_BLINDING_create_param(BN_BLINDING *b, const BIGNUM *e, BIGNUM *m,
|
||||
BN_CTX *ctx, int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx), BN_MONT_CTX *m_ctx)
|
||||
BN_BLINDING_create_param(BN_BLINDING *b, const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
|
||||
int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx), BN_MONT_CTX *m_ctx)
|
||||
{
|
||||
int retry_counter = 32;
|
||||
BN_BLINDING *ret = NULL;
|
||||
int retry_counter = 32;
|
||||
|
||||
if (b == NULL)
|
||||
ret = BN_BLINDING_new(NULL, NULL, m);
|
||||
|
|
@ -309,7 +282,7 @@ BN_BLINDING_create_param(BN_BLINDING *b, const BIGNUM *e, BIGNUM *m,
|
|||
if (ret == NULL)
|
||||
goto err;
|
||||
|
||||
if (ret->A == NULL && (ret->A = BN_new()) == NULL)
|
||||
if (ret->A == NULL && (ret->A = BN_new()) == NULL)
|
||||
goto err;
|
||||
if (ret->Ai == NULL && (ret->Ai = BN_new()) == NULL)
|
||||
goto err;
|
||||
|
|
@ -355,7 +328,7 @@ BN_BLINDING_create_param(BN_BLINDING *b, const BIGNUM *e, BIGNUM *m,
|
|||
|
||||
return ret;
|
||||
|
||||
err:
|
||||
err:
|
||||
if (b == NULL && ret != NULL) {
|
||||
BN_BLINDING_free(ret);
|
||||
ret = NULL;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bn_bpsw.c,v 1.10 2023/05/10 21:05:24 tb Exp $ */
|
||||
/* $OpenBSD: bn_bpsw.c,v 1.11 2023/08/03 18:53:55 tb Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2022 Martin Grenouilloux <martin.grenouilloux@lse.epita.fr>
|
||||
* Copyright (c) 2022 Theo Buehler <tb@openbsd.org>
|
||||
|
|
@ -385,7 +385,7 @@ bn_miller_rabin(int *is_pseudoprime, const BIGNUM *n, BN_CTX *ctx,
|
|||
size_t rounds)
|
||||
{
|
||||
BN_MONT_CTX *mctx = NULL;
|
||||
BIGNUM *base, *k, *n_minus_one, *three;
|
||||
BIGNUM *base, *k, *n_minus_one;
|
||||
size_t i;
|
||||
int s;
|
||||
int ret = 0;
|
||||
|
|
@ -398,8 +398,6 @@ bn_miller_rabin(int *is_pseudoprime, const BIGNUM *n, BN_CTX *ctx,
|
|||
goto err;
|
||||
if ((n_minus_one = BN_CTX_get(ctx)) == NULL)
|
||||
goto err;
|
||||
if ((three = BN_CTX_get(ctx)) == NULL)
|
||||
goto err;
|
||||
|
||||
if (BN_is_word(n, 2) || BN_is_word(n, 3)) {
|
||||
*is_pseudoprime = 1;
|
||||
|
|
@ -451,11 +449,8 @@ bn_miller_rabin(int *is_pseudoprime, const BIGNUM *n, BN_CTX *ctx,
|
|||
* risk of false positives in BPSW.
|
||||
*/
|
||||
|
||||
if (!BN_set_word(three, 3))
|
||||
goto err;
|
||||
|
||||
for (i = 0; i < rounds; i++) {
|
||||
if (!bn_rand_interval(base, three, n_minus_one))
|
||||
if (!bn_rand_interval(base, 3, n_minus_one))
|
||||
goto err;
|
||||
|
||||
if (!bn_fermat(is_pseudoprime, n, n_minus_one, k, s, base, ctx,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bn_local.h,v 1.27 2023/07/28 10:05:16 tb Exp $ */
|
||||
/* $OpenBSD: bn_local.h,v 1.33 2023/08/03 18:53:55 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -274,7 +274,8 @@ void bn_div_rem_words(BN_ULONG h, BN_ULONG l, BN_ULONG d, BN_ULONG *out_q,
|
|||
BN_ULONG *out_r);
|
||||
|
||||
int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom);
|
||||
int bn_rand_interval(BIGNUM *rnd, const BIGNUM *lower_inc, const BIGNUM *upper_exc);
|
||||
int bn_rand_in_range(BIGNUM *rnd, const BIGNUM *lower_inc, const BIGNUM *upper_exc);
|
||||
int bn_rand_interval(BIGNUM *rnd, BN_ULONG lower_word, const BIGNUM *upper_exc);
|
||||
|
||||
void BN_init(BIGNUM *);
|
||||
|
||||
|
|
@ -291,21 +292,11 @@ int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|||
int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
|
||||
BN_RECP_CTX *recp, BN_CTX *ctx);
|
||||
|
||||
/* BN_BLINDING flags */
|
||||
#define BN_BLINDING_NO_UPDATE 0x00000001
|
||||
#define BN_BLINDING_NO_RECREATE 0x00000002
|
||||
|
||||
BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
|
||||
void BN_BLINDING_free(BN_BLINDING *b);
|
||||
int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
|
||||
int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
|
||||
int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
|
||||
int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
|
||||
int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *);
|
||||
int BN_BLINDING_convert(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
|
||||
int BN_BLINDING_invert(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *);
|
||||
|
||||
CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *);
|
||||
unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
|
||||
void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
|
||||
BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
|
||||
const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
|
||||
int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bn_mod_sqrt.c,v 1.2 2023/07/08 12:21:58 beck Exp $ */
|
||||
/* $OpenBSD: bn_mod_sqrt.c,v 1.3 2023/08/03 18:53:55 tb Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2022 Theo Buehler <tb@openbsd.org>
|
||||
|
|
@ -237,7 +237,7 @@ static int
|
|||
bn_mod_sqrt_find_sylow_generator(BIGNUM *out_generator, const BIGNUM *p,
|
||||
const BIGNUM *q, BN_CTX *ctx)
|
||||
{
|
||||
BIGNUM *n, *p_abs, *thirty_two;
|
||||
BIGNUM *n, *p_abs;
|
||||
int i, is_non_residue;
|
||||
int ret = 0;
|
||||
|
||||
|
|
@ -245,8 +245,6 @@ bn_mod_sqrt_find_sylow_generator(BIGNUM *out_generator, const BIGNUM *p,
|
|||
|
||||
if ((n = BN_CTX_get(ctx)) == NULL)
|
||||
goto err;
|
||||
if ((thirty_two = BN_CTX_get(ctx)) == NULL)
|
||||
goto err;
|
||||
if ((p_abs = BN_CTX_get(ctx)) == NULL)
|
||||
goto err;
|
||||
|
||||
|
|
@ -259,14 +257,12 @@ bn_mod_sqrt_find_sylow_generator(BIGNUM *out_generator, const BIGNUM *p,
|
|||
goto found;
|
||||
}
|
||||
|
||||
if (!BN_set_word(thirty_two, 32))
|
||||
goto err;
|
||||
if (!bn_copy(p_abs, p))
|
||||
goto err;
|
||||
BN_set_negative(p_abs, 0);
|
||||
|
||||
for (i = 0; i < 128; i++) {
|
||||
if (!bn_rand_interval(n, thirty_two, p_abs))
|
||||
if (!bn_rand_interval(n, 32, p_abs))
|
||||
goto err;
|
||||
if (!bn_mod_sqrt_n_is_non_residue(&is_non_residue, n, p, ctx))
|
||||
goto err;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bn_rand.c,v 1.28 2023/07/08 12:21:58 beck Exp $ */
|
||||
/* $OpenBSD: bn_rand.c,v 1.29 2023/08/03 18:53:55 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -284,29 +284,46 @@ BN_rand_range(BIGNUM *r, const BIGNUM *range)
|
|||
LCRYPTO_ALIAS(BN_rand_range);
|
||||
|
||||
int
|
||||
bn_rand_interval(BIGNUM *rnd, const BIGNUM *lower_inc, const BIGNUM *upper_exc)
|
||||
bn_rand_in_range(BIGNUM *rnd, const BIGNUM *lower_inc, const BIGNUM *upper_exc)
|
||||
{
|
||||
BIGNUM *len = NULL;
|
||||
BIGNUM *len;
|
||||
int ret = 0;
|
||||
|
||||
if (BN_cmp(lower_inc, upper_exc) >= 0)
|
||||
goto err;
|
||||
|
||||
if ((len = BN_new()) == NULL)
|
||||
goto err;
|
||||
|
||||
if (!BN_sub(len, upper_exc, lower_inc))
|
||||
goto err;
|
||||
|
||||
if (!bn_rand_range(0, rnd, len))
|
||||
if (!BN_rand_range(rnd, len))
|
||||
goto err;
|
||||
|
||||
if (!BN_add(rnd, rnd, lower_inc))
|
||||
goto err;
|
||||
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
BN_free(len);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int
|
||||
bn_rand_interval(BIGNUM *rnd, BN_ULONG lower_word, const BIGNUM *upper_exc)
|
||||
{
|
||||
BIGNUM *lower_inc = NULL;
|
||||
int ret = 0;
|
||||
|
||||
if ((lower_inc = BN_new()) == NULL)
|
||||
goto err;
|
||||
if (!BN_set_word(lower_inc, lower_word))
|
||||
goto err;
|
||||
if (!bn_rand_in_range(rnd, lower_inc, upper_exc))
|
||||
goto err;
|
||||
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
BN_free(lower_inc);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: des.h,v 1.20 2023/07/08 07:11:07 beck Exp $ */
|
||||
/* $OpenBSD: des.h,v 1.21 2023/07/31 05:04:06 tb Exp $ */
|
||||
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -107,7 +107,6 @@ typedef struct DES_ks {
|
|||
extern int DES_check_key; /* defaults to false */
|
||||
extern int DES_rw_mode; /* defaults to DES_PCBC_MODE */
|
||||
|
||||
const char *DES_options(void);
|
||||
void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output,
|
||||
DES_key_schedule *ks1, DES_key_schedule *ks2,
|
||||
DES_key_schedule *ks3, int enc);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ecb_enc.c,v 1.18 2023/07/08 07:11:07 beck Exp $ */
|
||||
/* $OpenBSD: ecb_enc.c,v 1.19 2023/07/31 05:04:06 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -60,46 +60,6 @@
|
|||
#include <openssl/opensslv.h>
|
||||
#include <openssl/bio.h>
|
||||
|
||||
const char *
|
||||
DES_options(void)
|
||||
{
|
||||
static int init = 1;
|
||||
static char buf[32];
|
||||
|
||||
if (init) {
|
||||
const char *ptr, *unroll, *risc, *size;
|
||||
|
||||
#ifdef DES_PTR
|
||||
ptr = "ptr";
|
||||
#else
|
||||
ptr = "idx";
|
||||
#endif
|
||||
#if defined(DES_RISC1) || defined(DES_RISC2)
|
||||
#ifdef DES_RISC1
|
||||
risc = "risc1";
|
||||
#endif
|
||||
#ifdef DES_RISC2
|
||||
risc = "risc2";
|
||||
#endif
|
||||
#else
|
||||
risc = "cisc";
|
||||
#endif
|
||||
#ifdef DES_UNROLL
|
||||
unroll = "16";
|
||||
#else
|
||||
unroll = "2";
|
||||
#endif
|
||||
if (sizeof(DES_LONG) != sizeof(long))
|
||||
size = "int";
|
||||
else
|
||||
size = "long";
|
||||
snprintf(buf, sizeof buf, "des(%s,%s,%s,%s)", ptr, risc, unroll,
|
||||
size);
|
||||
init = 0;
|
||||
}
|
||||
return (buf);
|
||||
}
|
||||
|
||||
void
|
||||
DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output,
|
||||
DES_key_schedule *ks, int enc)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: dh_key.c,v 1.39 2023/07/08 15:29:03 beck Exp $ */
|
||||
/* $OpenBSD: dh_key.c,v 1.40 2023/08/03 18:53:55 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -109,7 +109,7 @@ generate_key(DH *dh)
|
|||
unsigned l;
|
||||
BN_CTX *ctx;
|
||||
BN_MONT_CTX *mont = NULL;
|
||||
BIGNUM *pub_key = NULL, *priv_key = NULL, *two = NULL;
|
||||
BIGNUM *pub_key = NULL, *priv_key = NULL;
|
||||
|
||||
if (BN_num_bits(dh->p) > OPENSSL_DH_MAX_MODULUS_BITS) {
|
||||
DHerror(DH_R_MODULUS_TOO_LARGE);
|
||||
|
|
@ -139,11 +139,7 @@ generate_key(DH *dh)
|
|||
|
||||
if (dh->priv_key == NULL) {
|
||||
if (dh->q) {
|
||||
if ((two = BN_new()) == NULL)
|
||||
goto err;
|
||||
if (!BN_add(two, BN_value_one(), BN_value_one()))
|
||||
goto err;
|
||||
if (!bn_rand_interval(priv_key, two, dh->q))
|
||||
if (!bn_rand_interval(priv_key, 2, dh->q))
|
||||
goto err;
|
||||
} else {
|
||||
/* secret exponent length */
|
||||
|
|
@ -169,7 +165,7 @@ generate_key(DH *dh)
|
|||
if (dh->priv_key == NULL)
|
||||
BN_free(priv_key);
|
||||
BN_CTX_free(ctx);
|
||||
BN_free(two);
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: dsa_key.c,v 1.34 2023/07/08 14:28:15 beck Exp $ */
|
||||
/* $OpenBSD: dsa_key.c,v 1.35 2023/08/03 18:53:55 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -95,7 +95,7 @@ dsa_builtin_keygen(DSA *dsa)
|
|||
if ((ctx = BN_CTX_new()) == NULL)
|
||||
goto err;
|
||||
|
||||
if (!bn_rand_interval(priv_key, BN_value_one(), dsa->q))
|
||||
if (!bn_rand_interval(priv_key, 1, dsa->q))
|
||||
goto err;
|
||||
if (!BN_mod_exp_ct(pub_key, dsa->g, priv_key, dsa->p, ctx))
|
||||
goto err;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: dsa_ossl.c,v 1.52 2023/07/08 14:28:15 beck Exp $ */
|
||||
/* $OpenBSD: dsa_ossl.c,v 1.53 2023/08/03 18:53:55 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -172,7 +172,7 @@ dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
|
|||
*
|
||||
* Where b is a random value in the range [1, q).
|
||||
*/
|
||||
if (!bn_rand_interval(b, BN_value_one(), dsa->q))
|
||||
if (!bn_rand_interval(b, 1, dsa->q))
|
||||
goto err;
|
||||
if (BN_mod_inverse_ct(binv, b, dsa->q, ctx) == NULL)
|
||||
goto err;
|
||||
|
|
@ -261,7 +261,7 @@ dsa_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)
|
|||
!BN_set_bit(m, q_bits))
|
||||
goto err;
|
||||
|
||||
if (!bn_rand_interval(k, BN_value_one(), dsa->q))
|
||||
if (!bn_rand_interval(k, 1, dsa->q))
|
||||
goto err;
|
||||
|
||||
BN_set_flags(k, BN_FLG_CONSTTIME);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ec_key.c,v 1.36 2023/07/07 13:54:45 beck Exp $ */
|
||||
/* $OpenBSD: ec_key.c,v 1.37 2023/08/03 18:53:56 tb Exp $ */
|
||||
/*
|
||||
* Written by Nils Larsch for the OpenSSL project.
|
||||
*/
|
||||
|
|
@ -269,7 +269,7 @@ ec_key_gen(EC_KEY *eckey)
|
|||
|
||||
if ((order = EC_GROUP_get0_order(eckey->group)) == NULL)
|
||||
goto err;
|
||||
if (!bn_rand_interval(priv_key, BN_value_one(), order))
|
||||
if (!bn_rand_interval(priv_key, 1, order))
|
||||
goto err;
|
||||
if (!EC_POINT_mul(eckey->group, pub_key, priv_key, NULL, NULL, NULL))
|
||||
goto err;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ecp_smpl.c,v 1.55 2023/07/26 17:15:25 tb Exp $ */
|
||||
/* $OpenBSD: ecp_smpl.c,v 1.56 2023/08/03 18:53:56 tb Exp $ */
|
||||
/* Includes code written by Lenka Fibikova <fibikova@exp-math.uni-essen.de>
|
||||
* for the OpenSSL project.
|
||||
* Includes code written by Bodo Moeller for the OpenSSL project.
|
||||
|
|
@ -1227,7 +1227,7 @@ ec_GFp_simple_blind_coordinates(const EC_GROUP *group, EC_POINT *p, BN_CTX *ctx)
|
|||
goto err;
|
||||
|
||||
/* Generate lambda in [1, group->field). */
|
||||
if (!bn_rand_interval(lambda, BN_value_one(), &group->field))
|
||||
if (!bn_rand_interval(lambda, 1, &group->field))
|
||||
goto err;
|
||||
|
||||
if (group->meth->field_encode != NULL &&
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: ecdsa.c,v 1.16 2023/07/28 09:18:10 tb Exp $ */
|
||||
/* $OpenBSD: ecdsa.c,v 1.17 2023/08/03 18:53:56 tb Exp $ */
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2000-2002 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
|
|
@ -338,7 +338,7 @@ ecdsa_sign_setup(EC_KEY *key, BN_CTX *in_ctx, BIGNUM **out_kinv, BIGNUM **out_r)
|
|||
/* Step 11: repeat until r != 0. */
|
||||
do {
|
||||
/* Step 3: generate random k. */
|
||||
if (!bn_rand_interval(k, BN_value_one(), order))
|
||||
if (!bn_rand_interval(k, 1, order))
|
||||
goto err;
|
||||
|
||||
/*
|
||||
|
|
@ -472,7 +472,7 @@ ecdsa_compute_s(BIGNUM **out_s, const BIGNUM *e, const BIGNUM *kinv,
|
|||
goto err;
|
||||
}
|
||||
|
||||
if (!bn_rand_interval(b, BN_value_one(), order)) {
|
||||
if (!bn_rand_interval(b, 1, order)) {
|
||||
ECerror(ERR_R_BN_LIB);
|
||||
goto err;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: engine.h,v 1.41 2023/07/28 09:22:26 tb Exp $ */
|
||||
/* $OpenBSD: engine.h,v 1.42 2023/08/04 05:44:51 tb Exp $ */
|
||||
/* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
|
||||
* project 2000.
|
||||
*/
|
||||
|
|
@ -246,8 +246,8 @@ void ENGINE_load_openssl(void);
|
|||
int ENGINE_register_all_complete(void);
|
||||
|
||||
void ENGINE_cleanup(void);
|
||||
ENGINE *ENGINE_new(void);
|
||||
|
||||
ENGINE *ENGINE_new(void);
|
||||
int ENGINE_free(ENGINE *engine);
|
||||
int ENGINE_init(ENGINE *engine);
|
||||
int ENGINE_finish(ENGINE *engine);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
.\" $OpenBSD: BF_set_key.3,v 1.11 2023/07/29 03:05:35 tb Exp $
|
||||
.\" $OpenBSD: BF_set_key.3,v 1.12 2023/08/05 18:27:55 jmc Exp $
|
||||
.\" OpenSSL 99d63d46 Jul 19 09:27:53 2016 -0400
|
||||
.\"
|
||||
.\" This file was written by Richard Levitte <levitte@openssl.org>.
|
||||
|
|
@ -49,7 +49,7 @@
|
|||
.\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
.\" OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
.\"
|
||||
.Dd $Mdocdate: July 29 2023 $
|
||||
.Dd $Mdocdate: August 5 2023 $
|
||||
.Dt BF_SET_KEY 3
|
||||
.Os
|
||||
.Sh NAME
|
||||
|
|
@ -59,7 +59,7 @@
|
|||
.Nm BF_ecb_encrypt ,
|
||||
.Nm BF_cbc_encrypt ,
|
||||
.Nm BF_cfb64_encrypt ,
|
||||
.Nm BF_ofb64_encrypt ,
|
||||
.Nm BF_ofb64_encrypt
|
||||
.Nd Blowfish encryption
|
||||
.Sh SYNOPSIS
|
||||
.In openssl/blowfish.h
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: rsa_eay.c,v 1.62 2023/07/08 12:26:45 beck Exp $ */
|
||||
/* $OpenBSD: rsa_eay.c,v 1.63 2023/08/02 08:44:38 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -282,7 +282,7 @@ rsa_blinding_convert(BN_BLINDING *b, BIGNUM *f, BIGNUM *unblind, BN_CTX *ctx)
|
|||
* Local blinding: store the unblinding factor
|
||||
* in BN_BLINDING.
|
||||
*/
|
||||
return BN_BLINDING_convert_ex(f, NULL, b, ctx);
|
||||
return BN_BLINDING_convert(f, NULL, b, ctx);
|
||||
else {
|
||||
/*
|
||||
* Shared blinding: store the unblinding factor
|
||||
|
|
@ -290,7 +290,7 @@ rsa_blinding_convert(BN_BLINDING *b, BIGNUM *f, BIGNUM *unblind, BN_CTX *ctx)
|
|||
*/
|
||||
int ret;
|
||||
CRYPTO_w_lock(CRYPTO_LOCK_RSA_BLINDING);
|
||||
ret = BN_BLINDING_convert_ex(f, unblind, b, ctx);
|
||||
ret = BN_BLINDING_convert(f, unblind, b, ctx);
|
||||
CRYPTO_w_unlock(CRYPTO_LOCK_RSA_BLINDING);
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -300,14 +300,14 @@ static int
|
|||
rsa_blinding_invert(BN_BLINDING *b, BIGNUM *f, BIGNUM *unblind, BN_CTX *ctx)
|
||||
{
|
||||
/*
|
||||
* For local blinding, unblind is set to NULL, and BN_BLINDING_invert_ex
|
||||
* For local blinding, unblind is set to NULL, and BN_BLINDING_invert()
|
||||
* will use the unblinding factor stored in BN_BLINDING.
|
||||
* If BN_BLINDING is shared between threads, unblind must be non-null:
|
||||
* BN_BLINDING_invert_ex will then use the local unblinding factor,
|
||||
* BN_BLINDING_invert() will then use the local unblinding factor,
|
||||
* and will only read the modulus from BN_BLINDING.
|
||||
* In both cases it's safe to access the blinding without a lock.
|
||||
*/
|
||||
return BN_BLINDING_invert_ex(f, unblind, b, ctx);
|
||||
return BN_BLINDING_invert(f, unblind, b, ctx);
|
||||
}
|
||||
|
||||
/* signing */
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: safestack.h,v 1.28 2023/07/28 10:26:33 tb Exp $ */
|
||||
/* $OpenBSD: safestack.h,v 1.29 2023/08/03 16:32:15 tb Exp $ */
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1999 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
|
|
@ -125,13 +125,6 @@ typedef const char *OPENSSL_CSTRING;
|
|||
|
||||
DECLARE_SPECIAL_STACK_OF(OPENSSL_STRING, char)
|
||||
|
||||
/* Similarly, we sometimes use a block of characters, NOT
|
||||
* nul-terminated. These should also be distinguished from "normal"
|
||||
* stacks. */
|
||||
|
||||
typedef void *OPENSSL_BLOCK;
|
||||
DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
|
||||
|
||||
/* SKM_sk_... stack macros are internal to safestack.h:
|
||||
* never use them directly, use sk_<type>_... instead */
|
||||
#define SKM_sk_new(type, cmp) \
|
||||
|
|
@ -685,50 +678,6 @@ DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
|
|||
#define sk_DIST_POINT_sort(st) SKM_sk_sort(DIST_POINT, (st))
|
||||
#define sk_DIST_POINT_is_sorted(st) SKM_sk_is_sorted(DIST_POINT, (st))
|
||||
|
||||
#define sk_ENGINE_new(cmp) SKM_sk_new(ENGINE, (cmp))
|
||||
#define sk_ENGINE_new_null() SKM_sk_new_null(ENGINE)
|
||||
#define sk_ENGINE_free(st) SKM_sk_free(ENGINE, (st))
|
||||
#define sk_ENGINE_num(st) SKM_sk_num(ENGINE, (st))
|
||||
#define sk_ENGINE_value(st, i) SKM_sk_value(ENGINE, (st), (i))
|
||||
#define sk_ENGINE_set(st, i, val) SKM_sk_set(ENGINE, (st), (i), (val))
|
||||
#define sk_ENGINE_zero(st) SKM_sk_zero(ENGINE, (st))
|
||||
#define sk_ENGINE_push(st, val) SKM_sk_push(ENGINE, (st), (val))
|
||||
#define sk_ENGINE_unshift(st, val) SKM_sk_unshift(ENGINE, (st), (val))
|
||||
#define sk_ENGINE_find(st, val) SKM_sk_find(ENGINE, (st), (val))
|
||||
#define sk_ENGINE_find_ex(st, val) SKM_sk_find_ex(ENGINE, (st), (val))
|
||||
#define sk_ENGINE_delete(st, i) SKM_sk_delete(ENGINE, (st), (i))
|
||||
#define sk_ENGINE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ENGINE, (st), (ptr))
|
||||
#define sk_ENGINE_insert(st, val, i) SKM_sk_insert(ENGINE, (st), (val), (i))
|
||||
#define sk_ENGINE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ENGINE, (st), (cmp))
|
||||
#define sk_ENGINE_dup(st) SKM_sk_dup(ENGINE, st)
|
||||
#define sk_ENGINE_pop_free(st, free_func) SKM_sk_pop_free(ENGINE, (st), (free_func))
|
||||
#define sk_ENGINE_shift(st) SKM_sk_shift(ENGINE, (st))
|
||||
#define sk_ENGINE_pop(st) SKM_sk_pop(ENGINE, (st))
|
||||
#define sk_ENGINE_sort(st) SKM_sk_sort(ENGINE, (st))
|
||||
#define sk_ENGINE_is_sorted(st) SKM_sk_is_sorted(ENGINE, (st))
|
||||
|
||||
#define sk_ENGINE_CLEANUP_ITEM_new(cmp) SKM_sk_new(ENGINE_CLEANUP_ITEM, (cmp))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_new_null() SKM_sk_new_null(ENGINE_CLEANUP_ITEM)
|
||||
#define sk_ENGINE_CLEANUP_ITEM_free(st) SKM_sk_free(ENGINE_CLEANUP_ITEM, (st))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_num(st) SKM_sk_num(ENGINE_CLEANUP_ITEM, (st))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_value(st, i) SKM_sk_value(ENGINE_CLEANUP_ITEM, (st), (i))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_set(st, i, val) SKM_sk_set(ENGINE_CLEANUP_ITEM, (st), (i), (val))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_zero(st) SKM_sk_zero(ENGINE_CLEANUP_ITEM, (st))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_push(st, val) SKM_sk_push(ENGINE_CLEANUP_ITEM, (st), (val))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_unshift(st, val) SKM_sk_unshift(ENGINE_CLEANUP_ITEM, (st), (val))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_find(st, val) SKM_sk_find(ENGINE_CLEANUP_ITEM, (st), (val))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_find_ex(st, val) SKM_sk_find_ex(ENGINE_CLEANUP_ITEM, (st), (val))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_delete(st, i) SKM_sk_delete(ENGINE_CLEANUP_ITEM, (st), (i))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_delete_ptr(st, ptr) SKM_sk_delete_ptr(ENGINE_CLEANUP_ITEM, (st), (ptr))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_insert(st, val, i) SKM_sk_insert(ENGINE_CLEANUP_ITEM, (st), (val), (i))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ENGINE_CLEANUP_ITEM, (st), (cmp))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_dup(st) SKM_sk_dup(ENGINE_CLEANUP_ITEM, st)
|
||||
#define sk_ENGINE_CLEANUP_ITEM_pop_free(st, free_func) SKM_sk_pop_free(ENGINE_CLEANUP_ITEM, (st), (free_func))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_shift(st) SKM_sk_shift(ENGINE_CLEANUP_ITEM, (st))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_pop(st) SKM_sk_pop(ENGINE_CLEANUP_ITEM, (st))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_sort(st) SKM_sk_sort(ENGINE_CLEANUP_ITEM, (st))
|
||||
#define sk_ENGINE_CLEANUP_ITEM_is_sorted(st) SKM_sk_is_sorted(ENGINE_CLEANUP_ITEM, (st))
|
||||
|
||||
#define sk_ESS_CERT_ID_new(cmp) SKM_sk_new(ESS_CERT_ID, (cmp))
|
||||
#define sk_ESS_CERT_ID_new_null() SKM_sk_new_null(ESS_CERT_ID)
|
||||
#define sk_ESS_CERT_ID_free(st) SKM_sk_free(ESS_CERT_ID, (st))
|
||||
|
|
@ -973,28 +922,6 @@ DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
|
|||
#define sk_IPAddressOrRange_sort(st) SKM_sk_sort(IPAddressOrRange, (st))
|
||||
#define sk_IPAddressOrRange_is_sorted(st) SKM_sk_is_sorted(IPAddressOrRange, (st))
|
||||
|
||||
#define sk_MEM_OBJECT_DATA_new(cmp) SKM_sk_new(MEM_OBJECT_DATA, (cmp))
|
||||
#define sk_MEM_OBJECT_DATA_new_null() SKM_sk_new_null(MEM_OBJECT_DATA)
|
||||
#define sk_MEM_OBJECT_DATA_free(st) SKM_sk_free(MEM_OBJECT_DATA, (st))
|
||||
#define sk_MEM_OBJECT_DATA_num(st) SKM_sk_num(MEM_OBJECT_DATA, (st))
|
||||
#define sk_MEM_OBJECT_DATA_value(st, i) SKM_sk_value(MEM_OBJECT_DATA, (st), (i))
|
||||
#define sk_MEM_OBJECT_DATA_set(st, i, val) SKM_sk_set(MEM_OBJECT_DATA, (st), (i), (val))
|
||||
#define sk_MEM_OBJECT_DATA_zero(st) SKM_sk_zero(MEM_OBJECT_DATA, (st))
|
||||
#define sk_MEM_OBJECT_DATA_push(st, val) SKM_sk_push(MEM_OBJECT_DATA, (st), (val))
|
||||
#define sk_MEM_OBJECT_DATA_unshift(st, val) SKM_sk_unshift(MEM_OBJECT_DATA, (st), (val))
|
||||
#define sk_MEM_OBJECT_DATA_find(st, val) SKM_sk_find(MEM_OBJECT_DATA, (st), (val))
|
||||
#define sk_MEM_OBJECT_DATA_find_ex(st, val) SKM_sk_find_ex(MEM_OBJECT_DATA, (st), (val))
|
||||
#define sk_MEM_OBJECT_DATA_delete(st, i) SKM_sk_delete(MEM_OBJECT_DATA, (st), (i))
|
||||
#define sk_MEM_OBJECT_DATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(MEM_OBJECT_DATA, (st), (ptr))
|
||||
#define sk_MEM_OBJECT_DATA_insert(st, val, i) SKM_sk_insert(MEM_OBJECT_DATA, (st), (val), (i))
|
||||
#define sk_MEM_OBJECT_DATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(MEM_OBJECT_DATA, (st), (cmp))
|
||||
#define sk_MEM_OBJECT_DATA_dup(st) SKM_sk_dup(MEM_OBJECT_DATA, st)
|
||||
#define sk_MEM_OBJECT_DATA_pop_free(st, free_func) SKM_sk_pop_free(MEM_OBJECT_DATA, (st), (free_func))
|
||||
#define sk_MEM_OBJECT_DATA_shift(st) SKM_sk_shift(MEM_OBJECT_DATA, (st))
|
||||
#define sk_MEM_OBJECT_DATA_pop(st) SKM_sk_pop(MEM_OBJECT_DATA, (st))
|
||||
#define sk_MEM_OBJECT_DATA_sort(st) SKM_sk_sort(MEM_OBJECT_DATA, (st))
|
||||
#define sk_MEM_OBJECT_DATA_is_sorted(st) SKM_sk_is_sorted(MEM_OBJECT_DATA, (st))
|
||||
|
||||
#define sk_MIME_HEADER_new(cmp) SKM_sk_new(MIME_HEADER, (cmp))
|
||||
#define sk_MIME_HEADER_new_null() SKM_sk_new_null(MIME_HEADER)
|
||||
#define sk_MIME_HEADER_free(st) SKM_sk_free(MIME_HEADER, (st))
|
||||
|
|
@ -1855,30 +1782,6 @@ DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
|
|||
#define sk_OPENSSL_STRING_sort(st) SKM_sk_sort(OPENSSL_STRING, (st))
|
||||
#define sk_OPENSSL_STRING_is_sorted(st) SKM_sk_is_sorted(OPENSSL_STRING, (st))
|
||||
|
||||
#define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK) *)sk_new(CHECKED_SK_CMP_FUNC(void, cmp)))
|
||||
#define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)sk_new_null())
|
||||
#define sk_OPENSSL_BLOCK_push(st, val) sk_push(CHECKED_STACK_OF(OPENSSL_BLOCK, st), CHECKED_PTR_OF(void, val))
|
||||
#define sk_OPENSSL_BLOCK_find(st, val) sk_find(CHECKED_STACK_OF(OPENSSL_BLOCK, st), CHECKED_PTR_OF(void, val))
|
||||
#define sk_OPENSSL_BLOCK_value(st, i) ((OPENSSL_BLOCK)sk_value(CHECKED_STACK_OF(OPENSSL_BLOCK, st), i))
|
||||
#define sk_OPENSSL_BLOCK_num(st) SKM_sk_num(OPENSSL_BLOCK, st)
|
||||
#define sk_OPENSSL_BLOCK_pop_free(st, free_func) sk_pop_free(CHECKED_STACK_OF(OPENSSL_BLOCK, st), CHECKED_SK_FREE_FUNC2(OPENSSL_BLOCK, free_func))
|
||||
#define sk_OPENSSL_BLOCK_insert(st, val, i) sk_insert(CHECKED_STACK_OF(OPENSSL_BLOCK, st), CHECKED_PTR_OF(void, val), i)
|
||||
#define sk_OPENSSL_BLOCK_free(st) SKM_sk_free(OPENSSL_BLOCK, st)
|
||||
#define sk_OPENSSL_BLOCK_set(st, i, val) sk_set(CHECKED_STACK_OF(OPENSSL_BLOCK, st), i, CHECKED_PTR_OF(void, val))
|
||||
#define sk_OPENSSL_BLOCK_zero(st) SKM_sk_zero(OPENSSL_BLOCK, (st))
|
||||
#define sk_OPENSSL_BLOCK_unshift(st, val) sk_unshift(CHECKED_STACK_OF(OPENSSL_BLOCK, st), CHECKED_PTR_OF(void, val))
|
||||
#define sk_OPENSSL_BLOCK_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_CONST_PTR_OF(void, val))
|
||||
#define sk_OPENSSL_BLOCK_delete(st, i) SKM_sk_delete(OPENSSL_BLOCK, (st), (i))
|
||||
#define sk_OPENSSL_BLOCK_delete_ptr(st, ptr) (OPENSSL_BLOCK *)sk_delete_ptr(CHECKED_STACK_OF(OPENSSL_BLOCK, st), CHECKED_PTR_OF(void, ptr))
|
||||
#define sk_OPENSSL_BLOCK_set_cmp_func(st, cmp) \
|
||||
((int (*)(const void * const *,const void * const *)) \
|
||||
sk_set_cmp_func(CHECKED_STACK_OF(OPENSSL_BLOCK, st), CHECKED_SK_CMP_FUNC(void, cmp)))
|
||||
#define sk_OPENSSL_BLOCK_dup(st) SKM_sk_dup(OPENSSL_BLOCK, st)
|
||||
#define sk_OPENSSL_BLOCK_shift(st) SKM_sk_shift(OPENSSL_BLOCK, (st))
|
||||
#define sk_OPENSSL_BLOCK_pop(st) (void *)sk_pop(CHECKED_STACK_OF(OPENSSL_BLOCK, st))
|
||||
#define sk_OPENSSL_BLOCK_sort(st) SKM_sk_sort(OPENSSL_BLOCK, (st))
|
||||
#define sk_OPENSSL_BLOCK_is_sorted(st) SKM_sk_is_sorted(OPENSSL_BLOCK, (st))
|
||||
|
||||
#define sk_OPENSSL_PSTRING_new(cmp) ((STACK_OF(OPENSSL_PSTRING) *)sk_new(CHECKED_SK_CMP_FUNC(OPENSSL_STRING, cmp)))
|
||||
#define sk_OPENSSL_PSTRING_new_null() ((STACK_OF(OPENSSL_PSTRING) *)sk_new_null())
|
||||
#define sk_OPENSSL_PSTRING_push(st, val) sk_push(CHECKED_STACK_OF(OPENSSL_PSTRING, st), CHECKED_PTR_OF(OPENSSL_STRING, val))
|
||||
|
|
@ -1921,24 +1824,6 @@ DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
|
|||
LHM_lh_stats_bio(ADDED_OBJ,lh,out)
|
||||
#define lh_ADDED_OBJ_free(lh) LHM_lh_free(ADDED_OBJ,lh)
|
||||
|
||||
#define lh_APP_INFO_new() LHM_lh_new(APP_INFO,app_info)
|
||||
#define lh_APP_INFO_insert(lh,inst) LHM_lh_insert(APP_INFO,lh,inst)
|
||||
#define lh_APP_INFO_retrieve(lh,inst) LHM_lh_retrieve(APP_INFO,lh,inst)
|
||||
#define lh_APP_INFO_delete(lh,inst) LHM_lh_delete(APP_INFO,lh,inst)
|
||||
#define lh_APP_INFO_doall(lh,fn) LHM_lh_doall(APP_INFO,lh,fn)
|
||||
#define lh_APP_INFO_doall_arg(lh,fn,arg_type,arg) \
|
||||
LHM_lh_doall_arg(APP_INFO,lh,fn,arg_type,arg)
|
||||
#define lh_APP_INFO_error(lh) LHM_lh_error(APP_INFO,lh)
|
||||
#define lh_APP_INFO_num_items(lh) LHM_lh_num_items(APP_INFO,lh)
|
||||
#define lh_APP_INFO_down_load(lh) LHM_lh_down_load(APP_INFO,lh)
|
||||
#define lh_APP_INFO_node_stats_bio(lh,out) \
|
||||
LHM_lh_node_stats_bio(APP_INFO,lh,out)
|
||||
#define lh_APP_INFO_node_usage_stats_bio(lh,out) \
|
||||
LHM_lh_node_usage_stats_bio(APP_INFO,lh,out)
|
||||
#define lh_APP_INFO_stats_bio(lh,out) \
|
||||
LHM_lh_stats_bio(APP_INFO,lh,out)
|
||||
#define lh_APP_INFO_free(lh) LHM_lh_free(APP_INFO,lh)
|
||||
|
||||
#define lh_CONF_VALUE_new() LHM_lh_new(CONF_VALUE,conf_value)
|
||||
#define lh_CONF_VALUE_insert(lh,inst) LHM_lh_insert(CONF_VALUE,lh,inst)
|
||||
#define lh_CONF_VALUE_retrieve(lh,inst) LHM_lh_retrieve(CONF_VALUE,lh,inst)
|
||||
|
|
@ -1957,24 +1842,6 @@ DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
|
|||
LHM_lh_stats_bio(CONF_VALUE,lh,out)
|
||||
#define lh_CONF_VALUE_free(lh) LHM_lh_free(CONF_VALUE,lh)
|
||||
|
||||
#define lh_ENGINE_PILE_new() LHM_lh_new(ENGINE_PILE,engine_pile)
|
||||
#define lh_ENGINE_PILE_insert(lh,inst) LHM_lh_insert(ENGINE_PILE,lh,inst)
|
||||
#define lh_ENGINE_PILE_retrieve(lh,inst) LHM_lh_retrieve(ENGINE_PILE,lh,inst)
|
||||
#define lh_ENGINE_PILE_delete(lh,inst) LHM_lh_delete(ENGINE_PILE,lh,inst)
|
||||
#define lh_ENGINE_PILE_doall(lh,fn) LHM_lh_doall(ENGINE_PILE,lh,fn)
|
||||
#define lh_ENGINE_PILE_doall_arg(lh,fn,arg_type,arg) \
|
||||
LHM_lh_doall_arg(ENGINE_PILE,lh,fn,arg_type,arg)
|
||||
#define lh_ENGINE_PILE_error(lh) LHM_lh_error(ENGINE_PILE,lh)
|
||||
#define lh_ENGINE_PILE_num_items(lh) LHM_lh_num_items(ENGINE_PILE,lh)
|
||||
#define lh_ENGINE_PILE_down_load(lh) LHM_lh_down_load(ENGINE_PILE,lh)
|
||||
#define lh_ENGINE_PILE_node_stats_bio(lh,out) \
|
||||
LHM_lh_node_stats_bio(ENGINE_PILE,lh,out)
|
||||
#define lh_ENGINE_PILE_node_usage_stats_bio(lh,out) \
|
||||
LHM_lh_node_usage_stats_bio(ENGINE_PILE,lh,out)
|
||||
#define lh_ENGINE_PILE_stats_bio(lh,out) \
|
||||
LHM_lh_stats_bio(ENGINE_PILE,lh,out)
|
||||
#define lh_ENGINE_PILE_free(lh) LHM_lh_free(ENGINE_PILE,lh)
|
||||
|
||||
#define lh_ERR_STATE_new() LHM_lh_new(ERR_STATE,err_state)
|
||||
#define lh_ERR_STATE_insert(lh,inst) LHM_lh_insert(ERR_STATE,lh,inst)
|
||||
#define lh_ERR_STATE_retrieve(lh,inst) LHM_lh_retrieve(ERR_STATE,lh,inst)
|
||||
|
|
@ -2047,24 +1914,6 @@ DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
|
|||
LHM_lh_stats_bio(FUNCTION,lh,out)
|
||||
#define lh_FUNCTION_free(lh) LHM_lh_free(FUNCTION,lh)
|
||||
|
||||
#define lh_MEM_new() LHM_lh_new(MEM,mem)
|
||||
#define lh_MEM_insert(lh,inst) LHM_lh_insert(MEM,lh,inst)
|
||||
#define lh_MEM_retrieve(lh,inst) LHM_lh_retrieve(MEM,lh,inst)
|
||||
#define lh_MEM_delete(lh,inst) LHM_lh_delete(MEM,lh,inst)
|
||||
#define lh_MEM_doall(lh,fn) LHM_lh_doall(MEM,lh,fn)
|
||||
#define lh_MEM_doall_arg(lh,fn,arg_type,arg) \
|
||||
LHM_lh_doall_arg(MEM,lh,fn,arg_type,arg)
|
||||
#define lh_MEM_error(lh) LHM_lh_error(MEM,lh)
|
||||
#define lh_MEM_num_items(lh) LHM_lh_num_items(MEM,lh)
|
||||
#define lh_MEM_down_load(lh) LHM_lh_down_load(MEM,lh)
|
||||
#define lh_MEM_node_stats_bio(lh,out) \
|
||||
LHM_lh_node_stats_bio(MEM,lh,out)
|
||||
#define lh_MEM_node_usage_stats_bio(lh,out) \
|
||||
LHM_lh_node_usage_stats_bio(MEM,lh,out)
|
||||
#define lh_MEM_stats_bio(lh,out) \
|
||||
LHM_lh_stats_bio(MEM,lh,out)
|
||||
#define lh_MEM_free(lh) LHM_lh_free(MEM,lh)
|
||||
|
||||
#define lh_OBJ_NAME_new() LHM_lh_new(OBJ_NAME,obj_name)
|
||||
#define lh_OBJ_NAME_insert(lh,inst) LHM_lh_insert(OBJ_NAME,lh,inst)
|
||||
#define lh_OBJ_NAME_retrieve(lh,inst) LHM_lh_retrieve(OBJ_NAME,lh,inst)
|
||||
|
|
@ -2083,24 +1932,6 @@ DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
|
|||
LHM_lh_stats_bio(OBJ_NAME,lh,out)
|
||||
#define lh_OBJ_NAME_free(lh) LHM_lh_free(OBJ_NAME,lh)
|
||||
|
||||
#define lh_OPENSSL_CSTRING_new() LHM_lh_new(OPENSSL_CSTRING,openssl_cstring)
|
||||
#define lh_OPENSSL_CSTRING_insert(lh,inst) LHM_lh_insert(OPENSSL_CSTRING,lh,inst)
|
||||
#define lh_OPENSSL_CSTRING_retrieve(lh,inst) LHM_lh_retrieve(OPENSSL_CSTRING,lh,inst)
|
||||
#define lh_OPENSSL_CSTRING_delete(lh,inst) LHM_lh_delete(OPENSSL_CSTRING,lh,inst)
|
||||
#define lh_OPENSSL_CSTRING_doall(lh,fn) LHM_lh_doall(OPENSSL_CSTRING,lh,fn)
|
||||
#define lh_OPENSSL_CSTRING_doall_arg(lh,fn,arg_type,arg) \
|
||||
LHM_lh_doall_arg(OPENSSL_CSTRING,lh,fn,arg_type,arg)
|
||||
#define lh_OPENSSL_CSTRING_error(lh) LHM_lh_error(OPENSSL_CSTRING,lh)
|
||||
#define lh_OPENSSL_CSTRING_num_items(lh) LHM_lh_num_items(OPENSSL_CSTRING,lh)
|
||||
#define lh_OPENSSL_CSTRING_down_load(lh) LHM_lh_down_load(OPENSSL_CSTRING,lh)
|
||||
#define lh_OPENSSL_CSTRING_node_stats_bio(lh,out) \
|
||||
LHM_lh_node_stats_bio(OPENSSL_CSTRING,lh,out)
|
||||
#define lh_OPENSSL_CSTRING_node_usage_stats_bio(lh,out) \
|
||||
LHM_lh_node_usage_stats_bio(OPENSSL_CSTRING,lh,out)
|
||||
#define lh_OPENSSL_CSTRING_stats_bio(lh,out) \
|
||||
LHM_lh_stats_bio(OPENSSL_CSTRING,lh,out)
|
||||
#define lh_OPENSSL_CSTRING_free(lh) LHM_lh_free(OPENSSL_CSTRING,lh)
|
||||
|
||||
#define lh_OPENSSL_STRING_new() LHM_lh_new(OPENSSL_STRING,openssl_string)
|
||||
#define lh_OPENSSL_STRING_insert(lh,inst) LHM_lh_insert(OPENSSL_STRING,lh,inst)
|
||||
#define lh_OPENSSL_STRING_retrieve(lh,inst) LHM_lh_retrieve(OPENSSL_STRING,lh,inst)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue