_libre_CMAC_Update
_libre_CMAC_Final
_libre_CMAC_resume
+_libre_d2i_DSAparams_bio
+_libre_i2d_DSAparams_bio
+_libre_d2i_DSAparams_fp
+_libre_i2d_DSAparams_fp
+_libre_DSAparams_dup
+_libre_DSA_SIG_new
+_libre_DSA_SIG_free
+_libre_i2d_DSA_SIG
+_libre_d2i_DSA_SIG
+_libre_DSA_SIG_get0
+_libre_DSA_SIG_set0
+_libre_DSA_do_sign
+_libre_DSA_do_verify
+_libre_DSA_OpenSSL
+_libre_DSA_set_default_method
+_libre_DSA_get_default_method
+_libre_DSA_set_method
+_libre_DSA_new
+_libre_DSA_new_method
+_libre_DSA_free
+_libre_DSA_up_ref
+_libre_DSA_size
+_libre_DSA_bits
+_libre_DSA_sign_setup
+_libre_DSA_sign
+_libre_DSA_verify
+_libre_DSA_get_ex_new_index
+_libre_DSA_set_ex_data
+_libre_DSA_get_ex_data
+_libre_DSA_security_bits
+_libre_d2i_DSAPublicKey
+_libre_i2d_DSAPublicKey
+_libre_d2i_DSAPrivateKey
+_libre_i2d_DSAPrivateKey
+_libre_d2i_DSAparams
+_libre_i2d_DSAparams
+_libre_DSA_generate_parameters
+_libre_DSA_generate_parameters_ex
+_libre_DSA_generate_key
+_libre_DSAparams_print
+_libre_DSA_print
+_libre_DSAparams_print_fp
+_libre_DSA_print_fp
+_libre_DSA_dup_DH
+_libre_DSA_get0_pqg
+_libre_DSA_set0_pqg
+_libre_DSA_get0_key
+_libre_DSA_set0_key
+_libre_DSA_get0_p
+_libre_DSA_get0_q
+_libre_DSA_get0_g
+_libre_DSA_get0_pub_key
+_libre_DSA_get0_priv_key
+_libre_DSA_clear_flags
+_libre_DSA_test_flags
+_libre_DSA_set_flags
+_libre_DSA_get0_engine
+_libre_DSA_meth_new
+_libre_DSA_meth_free
+_libre_DSA_meth_dup
+_libre_DSA_meth_get0_name
+_libre_DSA_meth_set1_name
+_libre_DSA_meth_set_sign
+_libre_DSA_meth_set_finish
+_libre_ERR_load_DSA_strings
-/* $OpenBSD: dsa_asn1.c,v 1.30 2023/03/25 09:09:28 tb Exp $ */
+/* $OpenBSD: dsa_asn1.c,v 1.31 2023/07/08 14:28:15 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
return (DSA_SIG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&DSA_SIG_it);
}
+LCRYPTO_ALIAS(d2i_DSA_SIG);
int
i2d_DSA_SIG(const DSA_SIG *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &DSA_SIG_it);
}
+LCRYPTO_ALIAS(i2d_DSA_SIG);
void
DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
if (ps != NULL)
*ps = sig->s;
}
+LCRYPTO_ALIAS(DSA_SIG_get0);
int
DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s)
return 1;
}
+LCRYPTO_ALIAS(DSA_SIG_set0);
/* Override the default free and new methods */
static int
return (DSA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&DSAPrivateKey_it);
}
+LCRYPTO_ALIAS(d2i_DSAPrivateKey);
int
i2d_DSAPrivateKey(const DSA *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &DSAPrivateKey_it);
}
+LCRYPTO_ALIAS(i2d_DSAPrivateKey);
static const ASN1_AUX DSAparams_aux = {
.app_data = NULL,
return (DSA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&DSAparams_it);
}
+LCRYPTO_ALIAS(d2i_DSAparams);
int
i2d_DSAparams(const DSA *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &DSAparams_it);
}
+LCRYPTO_ALIAS(i2d_DSAparams);
DSA *
d2i_DSAparams_bio(BIO *bp, DSA **a)
{
return ASN1_item_d2i_bio(&DSAparams_it, bp, a);
}
+LCRYPTO_ALIAS(d2i_DSAparams_bio);
int
i2d_DSAparams_bio(BIO *bp, DSA *a)
{
return ASN1_item_i2d_bio(&DSAparams_it, bp, a);
}
+LCRYPTO_ALIAS(i2d_DSAparams_bio);
DSA *
d2i_DSAparams_fp(FILE *fp, DSA **a)
{
return ASN1_item_d2i_fp(&DSAparams_it, fp, a);
}
+LCRYPTO_ALIAS(d2i_DSAparams_fp);
int
i2d_DSAparams_fp(FILE *fp, DSA *a)
{
return ASN1_item_i2d_fp(&DSAparams_it, fp, a);
}
+LCRYPTO_ALIAS(i2d_DSAparams_fp);
static const ASN1_AUX DSAPublicKey_aux = {
.app_data = NULL,
return (DSA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&DSAPublicKey_it);
}
+LCRYPTO_ALIAS(d2i_DSAPublicKey);
int
i2d_DSAPublicKey(const DSA *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &DSAPublicKey_it);
}
+LCRYPTO_ALIAS(i2d_DSAPublicKey);
DSA *
DSAparams_dup(DSA *dsa)
{
return ASN1_item_dup(&DSAparams_it, dsa);
}
+LCRYPTO_ALIAS(DSAparams_dup);
int
DSA_sign(int type, const unsigned char *dgst, int dlen, unsigned char *sig,
return ret;
}
+LCRYPTO_ALIAS(DSA_sign);
/*
* data has already been hashed (probably with SHA or SHA-1).
return ret;
}
+LCRYPTO_ALIAS(DSA_verify);
-/* $OpenBSD: dsa_err.c,v 1.18 2023/03/04 20:47:04 tb Exp $ */
+/* $OpenBSD: dsa_err.c,v 1.19 2023/07/08 14:28:15 beck Exp $ */
/* ====================================================================
* Copyright (c) 1999-2011 The OpenSSL Project. All rights reserved.
*
}
#endif
}
+LCRYPTO_ALIAS(ERR_load_DSA_strings);
-/* $OpenBSD: dsa_gen.c,v 1.29 2023/04/13 14:58:27 tb Exp $ */
+/* $OpenBSD: dsa_gen.c,v 1.30 2023/07/08 14:28:15 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
seed_len, NULL, counter_ret, h_ret, cb);
}
}
+LCRYPTO_ALIAS(DSA_generate_parameters_ex);
int
dsa_builtin_paramgen(DSA *ret, size_t bits, size_t qbits, const EVP_MD *evpmd,
DSA_free(ret);
return NULL;
}
+LCRYPTO_ALIAS(DSA_generate_parameters);
#endif
-/* $OpenBSD: dsa_key.c,v 1.33 2023/01/11 04:35:26 jsing Exp $ */
+/* $OpenBSD: dsa_key.c,v 1.34 2023/07/08 14:28:15 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return dsa->meth->dsa_keygen(dsa);
return dsa_builtin_keygen(dsa);
}
+LCRYPTO_ALIAS(DSA_generate_key);
static int
dsa_builtin_keygen(DSA *dsa)
-/* $OpenBSD: dsa_lib.c,v 1.42 2023/03/11 15:29:03 tb Exp $ */
+/* $OpenBSD: dsa_lib.c,v 1.43 2023/07/08 14:28:15 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
default_DSA_method = meth;
}
+LCRYPTO_ALIAS(DSA_set_default_method);
const DSA_METHOD *
DSA_get_default_method(void)
default_DSA_method = DSA_OpenSSL();
return default_DSA_method;
}
+LCRYPTO_ALIAS(DSA_get_default_method);
DSA *
DSA_new(void)
{
return DSA_new_method(NULL);
}
+LCRYPTO_ALIAS(DSA_new);
int
DSA_set_method(DSA *dsa, const DSA_METHOD *meth)
meth->init(dsa);
return 1;
}
+LCRYPTO_ALIAS(DSA_set_method);
DSA *
DSA_new_method(ENGINE *engine)
return ret;
}
+LCRYPTO_ALIAS(DSA_new_method);
void
DSA_free(DSA *r)
BN_free(r->r);
free(r);
}
+LCRYPTO_ALIAS(DSA_free);
int
DSA_up_ref(DSA *r)
int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_DSA);
return i > 1 ? 1 : 0;
}
+LCRYPTO_ALIAS(DSA_up_ref);
int
DSA_size(const DSA *r)
return ret;
}
+LCRYPTO_ALIAS(DSA_size);
int
DSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DSA, argl, argp,
new_func, dup_func, free_func);
}
+LCRYPTO_ALIAS(DSA_get_ex_new_index);
int
DSA_set_ex_data(DSA *d, int idx, void *arg)
{
return CRYPTO_set_ex_data(&d->ex_data, idx, arg);
}
+LCRYPTO_ALIAS(DSA_set_ex_data);
void *
DSA_get_ex_data(DSA *d, int idx)
{
return CRYPTO_get_ex_data(&d->ex_data, idx);
}
+LCRYPTO_ALIAS(DSA_get_ex_data);
int
DSA_security_bits(const DSA *d)
return BN_security_bits(BN_num_bits(d->p), BN_num_bits(d->q));
}
+LCRYPTO_ALIAS(DSA_security_bits);
#ifndef OPENSSL_NO_DH
DH *
DH_free(ret);
return NULL;
}
+LCRYPTO_ALIAS(DSA_dup_DH);
#endif
void
if (g != NULL)
*g = d->g;
}
+LCRYPTO_ALIAS(DSA_get0_pqg);
int
DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g)
return 1;
}
+LCRYPTO_ALIAS(DSA_set0_pqg);
void
DSA_get0_key(const DSA *d, const BIGNUM **pub_key, const BIGNUM **priv_key)
if (priv_key != NULL)
*priv_key = d->priv_key;
}
+LCRYPTO_ALIAS(DSA_get0_key);
int
DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key)
return 1;
}
+LCRYPTO_ALIAS(DSA_set0_key);
const BIGNUM *
DSA_get0_p(const DSA *d)
{
return d->p;
}
+LCRYPTO_ALIAS(DSA_get0_p);
const BIGNUM *
DSA_get0_q(const DSA *d)
{
return d->q;
}
+LCRYPTO_ALIAS(DSA_get0_q);
const BIGNUM *
DSA_get0_g(const DSA *d)
{
return d->g;
}
+LCRYPTO_ALIAS(DSA_get0_g);
const BIGNUM *
DSA_get0_pub_key(const DSA *d)
{
return d->pub_key;
}
+LCRYPTO_ALIAS(DSA_get0_pub_key);
const BIGNUM *
DSA_get0_priv_key(const DSA *d)
{
return d->priv_key;
}
+LCRYPTO_ALIAS(DSA_get0_priv_key);
void
DSA_clear_flags(DSA *d, int flags)
{
d->flags &= ~flags;
}
+LCRYPTO_ALIAS(DSA_clear_flags);
int
DSA_test_flags(const DSA *d, int flags)
{
return d->flags & flags;
}
+LCRYPTO_ALIAS(DSA_test_flags);
void
DSA_set_flags(DSA *d, int flags)
{
d->flags |= flags;
}
+LCRYPTO_ALIAS(DSA_set_flags);
ENGINE *
DSA_get0_engine(DSA *d)
{
return d->engine;
}
+LCRYPTO_ALIAS(DSA_get0_engine);
int
DSA_bits(const DSA *dsa)
{
return BN_num_bits(dsa->p);
}
+LCRYPTO_ALIAS(DSA_bits);
int
dsa_check_key(const DSA *dsa)
-/* $OpenBSD: dsa_meth.c,v 1.6 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: dsa_meth.c,v 1.7 2023/07/08 14:28:15 beck Exp $ */
/*
* Copyright (c) 2018 Theo Buehler <tb@openbsd.org>
*
return meth;
}
+LCRYPTO_ALIAS(DSA_meth_new);
void
DSA_meth_free(DSA_METHOD *meth)
free(meth->name);
free(meth);
}
+LCRYPTO_ALIAS(DSA_meth_free);
DSA_METHOD *
DSA_meth_dup(const DSA_METHOD *meth)
return copy;
}
+LCRYPTO_ALIAS(DSA_meth_dup);
const char *
DSA_meth_get0_name(const DSA_METHOD *meth)
{
return meth->name;
}
+LCRYPTO_ALIAS(DSA_meth_get0_name);
int
DSA_meth_set1_name(DSA_METHOD *meth, const char *name)
return 1;
}
+LCRYPTO_ALIAS(DSA_meth_set1_name);
int
DSA_meth_set_sign(DSA_METHOD *meth,
meth->dsa_do_sign = sign;
return 1;
}
+LCRYPTO_ALIAS(DSA_meth_set_sign);
int
DSA_meth_set_finish(DSA_METHOD *meth, int (*finish)(DSA *))
meth->finish = finish;
return 1;
}
+LCRYPTO_ALIAS(DSA_meth_set_finish);
-/* $OpenBSD: dsa_ossl.c,v 1.51 2023/03/27 10:25:02 tb Exp $ */
+/* $OpenBSD: dsa_ossl.c,v 1.52 2023/07/08 14:28:15 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return &openssl_dsa_meth;
}
+LCRYPTO_ALIAS(DSA_OpenSSL);
/*
* Since DSA parameters are entirely arbitrary and checking them to be
{
return calloc(1, sizeof(DSA_SIG));
}
+LCRYPTO_ALIAS(DSA_SIG_new);
void
DSA_SIG_free(DSA_SIG *sig)
BN_free(sig->s);
free(sig);
}
+LCRYPTO_ALIAS(DSA_SIG_free);
int
DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)
{
return dsa->meth->dsa_sign_setup(dsa, ctx_in, kinvp, rp);
}
+LCRYPTO_ALIAS(DSA_sign_setup);
DSA_SIG *
DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
{
return dsa->meth->dsa_do_sign(dgst, dlen, dsa);
}
+LCRYPTO_ALIAS(DSA_do_sign);
int
DSA_do_verify(const unsigned char *dgst, int dgst_len, DSA_SIG *sig, DSA *dsa)
{
return dsa->meth->dsa_do_verify(dgst, dgst_len, sig, dsa);
}
+LCRYPTO_ALIAS(DSA_do_verify);
-/* $OpenBSD: dsa_prn.c,v 1.9 2022/11/19 06:33:00 tb Exp $ */
+/* $OpenBSD: dsa_prn.c,v 1.10 2023/07/08 14:28:15 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2006.
*/
BIO_free(b);
return ret;
}
+LCRYPTO_ALIAS(DSA_print_fp);
int
DSAparams_print_fp(FILE *fp, const DSA *x)
BIO_free(b);
return ret;
}
+LCRYPTO_ALIAS(DSAparams_print_fp);
int
DSA_print(BIO *bp, const DSA *x, int off)
EVP_PKEY_free(pk);
return ret;
}
+LCRYPTO_ALIAS(DSA_print);
int
DSAparams_print(BIO *bp, const DSA *x)
EVP_PKEY_free(pk);
return ret;
}
+LCRYPTO_ALIAS(DSAparams_print);
--- /dev/null
+/* $OpenBSD: dsa.h,v 1.1 2023/07/08 14:28:15 beck Exp $ */
+/*
+ * Copyright (c) 2023 Bob Beck <beck@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _LIBCRYPTO_DSA_H
+#define _LIBCRYPTO_DSA_H
+
+#ifndef _MSC_VER
+#include_next <openssl/dsa.h>
+#else
+#include "../include/openssl/dsa.h"
+#endif
+#include "crypto_namespace.h"
+
+LCRYPTO_USED(d2i_DSAparams_bio);
+LCRYPTO_USED(i2d_DSAparams_bio);
+LCRYPTO_USED(d2i_DSAparams_fp);
+LCRYPTO_USED(i2d_DSAparams_fp);
+LCRYPTO_USED(DSAparams_dup);
+LCRYPTO_USED(DSA_SIG_new);
+LCRYPTO_USED(DSA_SIG_free);
+LCRYPTO_USED(i2d_DSA_SIG);
+LCRYPTO_USED(d2i_DSA_SIG);
+LCRYPTO_USED(DSA_SIG_get0);
+LCRYPTO_USED(DSA_SIG_set0);
+LCRYPTO_USED(DSA_do_sign);
+LCRYPTO_USED(DSA_do_verify);
+LCRYPTO_USED(DSA_OpenSSL);
+LCRYPTO_USED(DSA_set_default_method);
+LCRYPTO_USED(DSA_get_default_method);
+LCRYPTO_USED(DSA_set_method);
+LCRYPTO_USED(DSA_new);
+LCRYPTO_USED(DSA_new_method);
+LCRYPTO_USED(DSA_free);
+LCRYPTO_USED(DSA_up_ref);
+LCRYPTO_USED(DSA_size);
+LCRYPTO_USED(DSA_bits);
+LCRYPTO_USED(DSA_sign_setup);
+LCRYPTO_USED(DSA_sign);
+LCRYPTO_USED(DSA_verify);
+LCRYPTO_USED(DSA_get_ex_new_index);
+LCRYPTO_USED(DSA_set_ex_data);
+LCRYPTO_USED(DSA_get_ex_data);
+LCRYPTO_USED(DSA_security_bits);
+LCRYPTO_USED(d2i_DSAPublicKey);
+LCRYPTO_USED(i2d_DSAPublicKey);
+LCRYPTO_USED(d2i_DSAPrivateKey);
+LCRYPTO_USED(i2d_DSAPrivateKey);
+LCRYPTO_USED(d2i_DSAparams);
+LCRYPTO_USED(i2d_DSAparams);
+LCRYPTO_USED(DSA_generate_parameters);
+LCRYPTO_USED(DSA_generate_parameters_ex);
+LCRYPTO_USED(DSA_generate_key);
+LCRYPTO_USED(DSAparams_print);
+LCRYPTO_USED(DSA_print);
+LCRYPTO_USED(DSAparams_print_fp);
+LCRYPTO_USED(DSA_print_fp);
+LCRYPTO_USED(DSA_dup_DH);
+LCRYPTO_USED(DSA_get0_pqg);
+LCRYPTO_USED(DSA_set0_pqg);
+LCRYPTO_USED(DSA_get0_key);
+LCRYPTO_USED(DSA_set0_key);
+LCRYPTO_USED(DSA_get0_p);
+LCRYPTO_USED(DSA_get0_q);
+LCRYPTO_USED(DSA_get0_g);
+LCRYPTO_USED(DSA_get0_pub_key);
+LCRYPTO_USED(DSA_get0_priv_key);
+LCRYPTO_USED(DSA_clear_flags);
+LCRYPTO_USED(DSA_test_flags);
+LCRYPTO_USED(DSA_set_flags);
+LCRYPTO_USED(DSA_get0_engine);
+LCRYPTO_USED(DSA_meth_new);
+LCRYPTO_USED(DSA_meth_free);
+LCRYPTO_USED(DSA_meth_dup);
+LCRYPTO_USED(DSA_meth_get0_name);
+LCRYPTO_USED(DSA_meth_set1_name);
+LCRYPTO_USED(DSA_meth_set_sign);
+LCRYPTO_USED(DSA_meth_set_finish);
+LCRYPTO_USED(ERR_load_DSA_strings);
+
+#endif /* _LIBCRYPTO_DSA_H */
projects / openbsd / commitdiff