early-access version 2698

externals/libressl/crypto/evp/evp_lib.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_lib.c,v 1.17 2018/09/12 06:35:38 djm Exp $ */
+/* $OpenBSD: evp_lib.c,v 1.24 2022/01/10 13:42:28 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -63,6 +63,9 @@
 #include <openssl/evp.h>
 #include <openssl/objects.h>
 
+#include "asn1_locl.h"
+#include "evp_locl.h"
+
 int
 EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
 {
@@ -237,6 +240,23 @@ EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
 	ctx->app_data = data;
 }
 
+void *
+EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx)
+{
+	return ctx->cipher_data;
+}
+
+void *
+EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data)
+{
+	void *old_cipher_data;
+
+	old_cipher_data = ctx->cipher_data;
+	ctx->cipher_data = cipher_data;
+
+	return old_cipher_data;
+}
+
 int
 EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
 {
@@ -249,6 +269,12 @@ EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
 	return ctx->cipher->iv_len;
 }
 
+unsigned char *
+EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx)
+{
+	return ctx->buf;
+}
+
 int
 EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
 {
@@ -345,6 +371,114 @@ EVP_MD_flags(const EVP_MD *md)
 	return md->flags;
 }
 
+EVP_MD *
+EVP_MD_meth_new(int md_type, int pkey_type)
+{
+	EVP_MD *md;
+
+	if ((md = calloc(1, sizeof(*md))) == NULL)
+		return NULL;
+
+	md->type = md_type;
+	md->pkey_type = pkey_type;
+
+	return md;
+}
+
+EVP_MD *
+EVP_MD_meth_dup(const EVP_MD *md)
+{
+	EVP_MD *to;
+
+	if ((to = EVP_MD_meth_new(md->type, md->pkey_type)) == NULL)
+		return NULL;
+
+	memcpy(to, md, sizeof(*to));
+
+	return to;
+}
+
+void
+EVP_MD_meth_free(EVP_MD *md)
+{
+	freezero(md, sizeof(*md));
+}
+
+int
+EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)
+{
+	md->block_size = blocksize;
+	return 1;
+}
+
+int
+EVP_MD_meth_set_result_size(EVP_MD *md, int result_size)
+{
+	md->md_size = result_size;
+	return 1;
+}
+
+int
+EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)
+{
+	md->ctx_size = datasize;
+	return 1;
+}
+
+int
+EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)
+{
+	md->flags = flags;
+	return 1;
+}
+
+int
+EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx))
+{
+	md->init = init;
+	return 1;
+}
+
+int
+EVP_MD_meth_set_update(EVP_MD *md,
+    int (*update)(EVP_MD_CTX *ctx, const void *data, size_t count))
+{
+	md->update = update;
+	return 1;
+}
+
+int
+EVP_MD_meth_set_final(EVP_MD *md,
+    int (*final)(EVP_MD_CTX *ctx, unsigned char *md))
+{
+	md->final = final;
+	return 1;
+}
+
+int
+EVP_MD_meth_set_copy(EVP_MD *md,
+    int (*copy)(EVP_MD_CTX *to, const EVP_MD_CTX *from))
+{
+	md->copy = copy;
+	return 1;
+}
+
+int
+EVP_MD_meth_set_cleanup(EVP_MD *md,
+    int (*cleanup)(EVP_MD_CTX *ctx))
+{
+	md->cleanup = cleanup;
+	return 1;
+}
+
+int
+EVP_MD_meth_set_ctrl(EVP_MD *md,
+    int (*ctrl)(EVP_MD_CTX *ctx, int cmd, int p1, void *p2))
+{
+	md->md_ctrl = ctrl;
+	return 1;
+}
+
 const EVP_MD *
 EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
 {
@@ -353,6 +487,41 @@ EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
 	return ctx->digest;
 }
 
+void *
+EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx)
+{
+	return ctx->md_data;
+}
+
+EVP_PKEY_CTX *
+EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx)
+{
+	return ctx->pctx;
+}
+
+void
+EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx)
+{
+	if (EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX)) {
+		EVP_MD_CTX_clear_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
+	} else {
+		EVP_PKEY_CTX_free(ctx->pctx);
+	}
+
+	ctx->pctx = pctx;
+
+	if (pctx != NULL) {
+		/*
+		 * For unclear reasons it was decided that the caller keeps
+		 * ownership of pctx. So a flag was invented to make sure we
+		 * don't free it in EVP_MD_CTX_cleanup(). We also need to
+		 * unset it in EVP_MD_CTX_copy_ex(). Fortunately, the flag
+		 * isn't public...
+		 */
+		EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
+	}
+}
+
 void
 EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
 {