Replace EVP_MAC_CTX_copy() by EVP_MAC_CTX_dup()
[openssl.git] / crypto / evp / mac_lib.c
1 /*
2  * Copyright 2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <string.h>
11 #include <stdarg.h>
12 #include <openssl/evp.h>
13 #include <openssl/err.h>
14 #include <openssl/ossl_typ.h>
15 #include "internal/nelem.h"
16 #include "internal/evp_int.h"
17 #include "evp_locl.h"
18
19 EVP_MAC_CTX *EVP_MAC_CTX_new_id(int id)
20 {
21     const EVP_MAC *mac = EVP_get_macbynid(id);
22
23     if (mac == NULL)
24         return NULL;
25     return EVP_MAC_CTX_new(mac);
26 }
27
28 EVP_MAC_CTX *EVP_MAC_CTX_new(const EVP_MAC *mac)
29 {
30     EVP_MAC_CTX *ctx = OPENSSL_zalloc(sizeof(EVP_MAC_CTX));
31
32     if (ctx == NULL || (ctx->data = mac->new()) == NULL) {
33         EVPerr(EVP_F_EVP_MAC_CTX_NEW, ERR_R_MALLOC_FAILURE);
34         OPENSSL_free(ctx);
35         ctx = NULL;
36     } else {
37         ctx->meth = mac;
38     }
39     return ctx;
40 }
41
42 void EVP_MAC_CTX_free(EVP_MAC_CTX *ctx)
43 {
44     if (ctx != NULL && ctx->data != NULL) {
45         ctx->meth->free(ctx->data);
46         ctx->data = NULL;
47     }
48     OPENSSL_free(ctx);
49 }
50
51 EVP_MAC_CTX *EVP_MAC_CTX_dup(const EVP_MAC_CTX *src)
52 {
53     EVP_MAC_CTX *dst = EVP_MAC_CTX_new(src->meth);
54
55     if (dst == NULL)
56         return NULL;
57
58     dst = OPENSSL_malloc(sizeof(*dst));
59     if (dst == NULL) {
60         EVPerr(EVP_F_EVP_MAC_CTX_DUP, ERR_R_MALLOC_FAILURE);
61         return NULL;
62     }
63
64     *dst = *src;
65
66     dst->data = src->meth->dup(src->data);
67     if (dst->data == NULL) {
68         EVP_MAC_CTX_free(dst);
69         return NULL;
70     }
71
72     return dst;
73 }
74
75 const EVP_MAC *EVP_MAC_CTX_mac(EVP_MAC_CTX *ctx)
76 {
77     return ctx->meth;
78 }
79
80 size_t EVP_MAC_size(EVP_MAC_CTX *ctx)
81 {
82     if (ctx->data != NULL)
83         return ctx->meth->size(ctx->data);
84     /* If the MAC hasn't been initialized yet, we return zero */
85     return 0;
86 }
87
88 int EVP_MAC_init(EVP_MAC_CTX *ctx)
89 {
90     return ctx->meth->init(ctx->data);
91 }
92
93 int EVP_MAC_update(EVP_MAC_CTX *ctx, const unsigned char *data, size_t datalen)
94 {
95     if (datalen == 0)
96         return 1;
97     return ctx->meth->update(ctx->data, data, datalen);
98 }
99
100 int EVP_MAC_final(EVP_MAC_CTX *ctx, unsigned char *out, size_t *poutlen)
101 {
102     int l = ctx->meth->size(ctx->data);
103
104     if (l < 0)
105         return 0;
106     if (poutlen != NULL)
107         *poutlen = l;
108     if (out == NULL)
109         return 1;
110     return ctx->meth->final(ctx->data, out);
111 }
112
113 int EVP_MAC_ctrl(EVP_MAC_CTX *ctx, int cmd, ...)
114 {
115     int ok = -1;
116     va_list args;
117
118     va_start(args, cmd);
119     ok = EVP_MAC_vctrl(ctx, cmd, args);
120     va_end(args);
121
122     if (ok == -2)
123         EVPerr(EVP_F_EVP_MAC_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
124
125     return ok;
126 }
127
128 int EVP_MAC_vctrl(EVP_MAC_CTX *ctx, int cmd, va_list args)
129 {
130     int ok = 1;
131
132     if (ctx == NULL || ctx->meth == NULL)
133         return -2;
134
135     switch (cmd) {
136 #if 0
137     case ...:
138         /* code */
139         ok = 1;
140         break;
141 #endif
142     default:
143         if (ctx->meth->ctrl != NULL)
144             ok = ctx->meth->ctrl(ctx->data, cmd, args);
145         else
146             ok = -2;
147         break;
148     }
149
150     return ok;
151 }
152
153 int EVP_MAC_ctrl_str(EVP_MAC_CTX *ctx, const char *type, const char *value)
154 {
155     int ok = 1;
156
157     if (ctx == NULL || ctx->meth == NULL || ctx->meth->ctrl_str == NULL) {
158         EVPerr(EVP_F_EVP_MAC_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED);
159         return -2;
160     }
161
162     ok = ctx->meth->ctrl_str(ctx->data, type, value);
163
164     if (ok == -2)
165         EVPerr(EVP_F_EVP_MAC_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED);
166     return ok;
167 }
168
169 int EVP_MAC_str2ctrl(EVP_MAC_CTX *ctx, int cmd, const char *value)
170 {
171     size_t len;
172
173     len = strlen(value);
174     if (len > INT_MAX)
175         return -1;
176     return EVP_MAC_ctrl(ctx, cmd, value, len);
177 }
178
179 int EVP_MAC_hex2ctrl(EVP_MAC_CTX *ctx, int cmd, const char *hex)
180 {
181     unsigned char *bin;
182     long binlen;
183     int rv = -1;
184
185     bin = OPENSSL_hexstr2buf(hex, &binlen);
186     if (bin == NULL)
187         return 0;
188     if (binlen <= INT_MAX)
189         rv = EVP_MAC_ctrl(ctx, cmd, bin, (size_t)binlen);
190     OPENSSL_free(bin);
191     return rv;
192 }
193
194 int EVP_MAC_nid(const EVP_MAC *mac)
195 {
196     return mac->type;
197 }