Coverage Report

Created: 2023-06-08 06:41

/src/openssl111/crypto/poly1305/poly1305_pmeth.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 2007-2018 The OpenSSL Project Authors. All Rights Reserved.
3
 *
4
 * Licensed under the OpenSSL license (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 <stdio.h>
11
#include "internal/cryptlib.h"
12
#include <openssl/x509.h>
13
#include <openssl/x509v3.h>
14
#include <openssl/evp.h>
15
#include <openssl/err.h>
16
#include "crypto/poly1305.h"
17
#include "poly1305_local.h"
18
#include "crypto/evp.h"
19
20
/* POLY1305 pkey context structure */
21
22
typedef struct {
23
    ASN1_OCTET_STRING ktmp;     /* Temp storage for key */
24
    POLY1305 ctx;
25
} POLY1305_PKEY_CTX;
26
27
static int pkey_poly1305_init(EVP_PKEY_CTX *ctx)
28
0
{
29
0
    POLY1305_PKEY_CTX *pctx;
30
31
0
    if ((pctx = OPENSSL_zalloc(sizeof(*pctx))) == NULL) {
32
0
        CRYPTOerr(CRYPTO_F_PKEY_POLY1305_INIT, ERR_R_MALLOC_FAILURE);
33
0
        return 0;
34
0
    }
35
0
    pctx->ktmp.type = V_ASN1_OCTET_STRING;
36
37
0
    EVP_PKEY_CTX_set_data(ctx, pctx);
38
0
    EVP_PKEY_CTX_set0_keygen_info(ctx, NULL, 0);
39
0
    return 1;
40
0
}
41
42
static void pkey_poly1305_cleanup(EVP_PKEY_CTX *ctx)
43
0
{
44
0
    POLY1305_PKEY_CTX *pctx = EVP_PKEY_CTX_get_data(ctx);
45
46
0
    if (pctx != NULL) {
47
0
        OPENSSL_clear_free(pctx->ktmp.data, pctx->ktmp.length);
48
0
        OPENSSL_clear_free(pctx, sizeof(*pctx));
49
0
        EVP_PKEY_CTX_set_data(ctx, NULL);
50
0
    }
51
0
}
52
53
static int pkey_poly1305_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
54
0
{
55
0
    POLY1305_PKEY_CTX *sctx, *dctx;
56
57
    /* allocate memory for dst->data and a new POLY1305_CTX in dst->data->ctx */
58
0
    if (!pkey_poly1305_init(dst))
59
0
        return 0;
60
0
    sctx = EVP_PKEY_CTX_get_data(src);
61
0
    dctx = EVP_PKEY_CTX_get_data(dst);
62
0
    if (ASN1_STRING_get0_data(&sctx->ktmp) != NULL &&
63
0
        !ASN1_STRING_copy(&dctx->ktmp, &sctx->ktmp)) {
64
        /* cleanup and free the POLY1305_PKEY_CTX in dst->data */
65
0
        pkey_poly1305_cleanup(dst);
66
0
        return 0;
67
0
    }
68
0
    memcpy(&dctx->ctx, &sctx->ctx, sizeof(POLY1305));
69
0
    return 1;
70
0
}
71
72
static int pkey_poly1305_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
73
0
{
74
0
    ASN1_OCTET_STRING *key;
75
0
    POLY1305_PKEY_CTX *pctx = EVP_PKEY_CTX_get_data(ctx);
76
77
0
    if (ASN1_STRING_get0_data(&pctx->ktmp) == NULL)
78
0
        return 0;
79
0
    key = ASN1_OCTET_STRING_dup(&pctx->ktmp);
80
0
    if (key == NULL)
81
0
        return 0;
82
0
    return EVP_PKEY_assign_POLY1305(pkey, key);
83
0
}
84
85
static int int_update(EVP_MD_CTX *ctx, const void *data, size_t count)
86
0
{
87
0
    POLY1305_PKEY_CTX *pctx = EVP_PKEY_CTX_get_data(EVP_MD_CTX_pkey_ctx(ctx));
88
89
0
    Poly1305_Update(&pctx->ctx, data, count);
90
0
    return 1;
91
0
}
92
93
static int poly1305_signctx_init(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx)
94
0
{
95
0
    POLY1305_PKEY_CTX *pctx = ctx->data;
96
0
    ASN1_OCTET_STRING *key = (ASN1_OCTET_STRING *)ctx->pkey->pkey.ptr;
97
98
0
    if (key->length != POLY1305_KEY_SIZE)
99
0
        return 0;
100
0
    EVP_MD_CTX_set_flags(mctx, EVP_MD_CTX_FLAG_NO_INIT);
101
0
    EVP_MD_CTX_set_update_fn(mctx, int_update);
102
0
    Poly1305_Init(&pctx->ctx, key->data);
103
0
    return 1;
104
0
}
105
static int poly1305_signctx(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
106
                            EVP_MD_CTX *mctx)
107
0
{
108
0
    POLY1305_PKEY_CTX *pctx = ctx->data;
109
110
0
    *siglen = POLY1305_DIGEST_SIZE;
111
0
    if (sig != NULL)
112
0
        Poly1305_Final(&pctx->ctx, sig);
113
0
    return 1;
114
0
}
115
116
static int pkey_poly1305_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
117
0
{
118
0
    POLY1305_PKEY_CTX *pctx = EVP_PKEY_CTX_get_data(ctx);
119
0
    const unsigned char *key;
120
0
    size_t len;
121
122
0
    switch (type) {
123
124
0
    case EVP_PKEY_CTRL_MD:
125
        /* ignore */
126
0
        break;
127
128
0
    case EVP_PKEY_CTRL_SET_MAC_KEY:
129
0
    case EVP_PKEY_CTRL_DIGESTINIT:
130
0
        if (type == EVP_PKEY_CTRL_SET_MAC_KEY) {
131
            /* user explicitly setting the key */
132
0
            key = p2;
133
0
            len = p1;
134
0
        } else {
135
            /* user indirectly setting the key via EVP_DigestSignInit */
136
0
            key = EVP_PKEY_get0_poly1305(EVP_PKEY_CTX_get0_pkey(ctx), &len);
137
0
        }
138
0
        if (key == NULL || len != POLY1305_KEY_SIZE ||
139
0
            !ASN1_OCTET_STRING_set(&pctx->ktmp, key, len))
140
0
            return 0;
141
0
        Poly1305_Init(&pctx->ctx, ASN1_STRING_get0_data(&pctx->ktmp));
142
0
        break;
143
144
0
    default:
145
0
        return -2;
146
147
0
    }
148
0
    return 1;
149
0
}
150
151
static int pkey_poly1305_ctrl_str(EVP_PKEY_CTX *ctx,
152
                                  const char *type, const char *value)
153
0
{
154
0
    if (value == NULL)
155
0
        return 0;
156
0
    if (strcmp(type, "key") == 0)
157
0
        return EVP_PKEY_CTX_str2ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, value);
158
0
    if (strcmp(type, "hexkey") == 0)
159
0
        return EVP_PKEY_CTX_hex2ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, value);
160
0
    return -2;
161
0
}
162
163
const EVP_PKEY_METHOD poly1305_pkey_meth = {
164
    EVP_PKEY_POLY1305,
165
    EVP_PKEY_FLAG_SIGCTX_CUSTOM, /* we don't deal with a separate MD */
166
    pkey_poly1305_init,
167
    pkey_poly1305_copy,
168
    pkey_poly1305_cleanup,
169
170
    0, 0,
171
172
    0,
173
    pkey_poly1305_keygen,
174
175
    0, 0,
176
177
    0, 0,
178
179
    0, 0,
180
181
    poly1305_signctx_init,
182
    poly1305_signctx,
183
184
    0, 0,
185
186
    0, 0,
187
188
    0, 0,
189
190
    0, 0,
191
192
    pkey_poly1305_ctrl,
193
    pkey_poly1305_ctrl_str
194
};