1/*
2 * Copyright 2020-2022 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 "internal/deprecated.h"
11
12#include <openssl/crypto.h>
13#include <openssl/evp.h>
14#include <openssl/core_dispatch.h>
15#include <openssl/core_names.h>
16#include <openssl/params.h>
17#include <openssl/err.h>
18#include <openssl/proverr.h>
19#include "crypto/sm2.h"
20#include "prov/provider_ctx.h"
21#include "prov/implementations.h"
22#include "prov/provider_util.h"
23
24static OSSL_FUNC_asym_cipher_newctx_fn sm2_newctx;
25static OSSL_FUNC_asym_cipher_encrypt_init_fn sm2_init;
26static OSSL_FUNC_asym_cipher_encrypt_fn sm2_asym_encrypt;
27static OSSL_FUNC_asym_cipher_decrypt_init_fn sm2_init;
28static OSSL_FUNC_asym_cipher_decrypt_fn sm2_asym_decrypt;
29static OSSL_FUNC_asym_cipher_freectx_fn sm2_freectx;
30static OSSL_FUNC_asym_cipher_dupctx_fn sm2_dupctx;
31static OSSL_FUNC_asym_cipher_get_ctx_params_fn sm2_get_ctx_params;
32static OSSL_FUNC_asym_cipher_gettable_ctx_params_fn sm2_gettable_ctx_params;
33static OSSL_FUNC_asym_cipher_set_ctx_params_fn sm2_set_ctx_params;
34static OSSL_FUNC_asym_cipher_settable_ctx_params_fn sm2_settable_ctx_params;
35
36/*
37 * What's passed as an actual key is defined by the KEYMGMT interface.
38 * We happen to know that our KEYMGMT simply passes EC_KEY structures, so
39 * we use that here too.
40 */
41
42typedef struct {
43    OSSL_LIB_CTX *libctx;
44    EC_KEY *key;
45    PROV_DIGEST md;
46} PROV_SM2_CTX;
47
48static void *sm2_newctx(void *provctx)
49{
50    PROV_SM2_CTX *psm2ctx =  OPENSSL_zalloc(sizeof(PROV_SM2_CTX));
51
52    if (psm2ctx == NULL)
53        return NULL;
54    psm2ctx->libctx = PROV_LIBCTX_OF(provctx);
55
56    return psm2ctx;
57}
58
59static int sm2_init(void *vpsm2ctx, void *vkey, const OSSL_PARAM params[])
60{
61    PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
62
63    if (psm2ctx == NULL || vkey == NULL || !EC_KEY_up_ref(vkey))
64        return 0;
65    EC_KEY_free(psm2ctx->key);
66    psm2ctx->key = vkey;
67
68    return sm2_set_ctx_params(psm2ctx, params);
69}
70
71static const EVP_MD *sm2_get_md(PROV_SM2_CTX *psm2ctx)
72{
73    const EVP_MD *md = ossl_prov_digest_md(&psm2ctx->md);
74
75    if (md == NULL)
76        md = ossl_prov_digest_fetch(&psm2ctx->md, psm2ctx->libctx, "SM3", NULL);
77
78    return md;
79}
80
81static int sm2_asym_encrypt(void *vpsm2ctx, unsigned char *out, size_t *outlen,
82                            size_t outsize, const unsigned char *in,
83                            size_t inlen)
84{
85    PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
86    const EVP_MD *md = sm2_get_md(psm2ctx);
87
88    if (md == NULL)
89        return 0;
90
91    if (out == NULL) {
92        if (!ossl_sm2_ciphertext_size(psm2ctx->key, md, inlen, outlen)) {
93            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY);
94            return 0;
95        }
96        return 1;
97    }
98
99    return ossl_sm2_encrypt(psm2ctx->key, md, in, inlen, out, outlen);
100}
101
102static int sm2_asym_decrypt(void *vpsm2ctx, unsigned char *out, size_t *outlen,
103                            size_t outsize, const unsigned char *in,
104                            size_t inlen)
105{
106    PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
107    const EVP_MD *md = sm2_get_md(psm2ctx);
108
109    if (md == NULL)
110        return 0;
111
112    if (out == NULL) {
113        if (!ossl_sm2_plaintext_size(in, inlen, outlen))
114            return 0;
115        return 1;
116    }
117
118    return ossl_sm2_decrypt(psm2ctx->key, md, in, inlen, out, outlen);
119}
120
121static void sm2_freectx(void *vpsm2ctx)
122{
123    PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
124
125    EC_KEY_free(psm2ctx->key);
126    ossl_prov_digest_reset(&psm2ctx->md);
127
128    OPENSSL_free(psm2ctx);
129}
130
131static void *sm2_dupctx(void *vpsm2ctx)
132{
133    PROV_SM2_CTX *srcctx = (PROV_SM2_CTX *)vpsm2ctx;
134    PROV_SM2_CTX *dstctx;
135
136    dstctx = OPENSSL_zalloc(sizeof(*srcctx));
137    if (dstctx == NULL)
138        return NULL;
139
140    *dstctx = *srcctx;
141    memset(&dstctx->md, 0, sizeof(dstctx->md));
142
143    if (dstctx->key != NULL && !EC_KEY_up_ref(dstctx->key)) {
144        OPENSSL_free(dstctx);
145        return NULL;
146    }
147
148    if (!ossl_prov_digest_copy(&dstctx->md, &srcctx->md)) {
149        sm2_freectx(dstctx);
150        return NULL;
151    }
152
153    return dstctx;
154}
155
156static int sm2_get_ctx_params(void *vpsm2ctx, OSSL_PARAM *params)
157{
158    PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
159    OSSL_PARAM *p;
160
161    if (vpsm2ctx == NULL)
162        return 0;
163
164    p = OSSL_PARAM_locate(params, OSSL_ASYM_CIPHER_PARAM_DIGEST);
165    if (p != NULL) {
166        const EVP_MD *md = ossl_prov_digest_md(&psm2ctx->md);
167
168        if (!OSSL_PARAM_set_utf8_string(p, md == NULL ? ""
169                                                      : EVP_MD_get0_name(md)))
170            return 0;
171    }
172
173    return 1;
174}
175
176static const OSSL_PARAM known_gettable_ctx_params[] = {
177    OSSL_PARAM_utf8_string(OSSL_ASYM_CIPHER_PARAM_DIGEST, NULL, 0),
178    OSSL_PARAM_END
179};
180
181static const OSSL_PARAM *sm2_gettable_ctx_params(ossl_unused void *vpsm2ctx,
182                                                 ossl_unused void *provctx)
183{
184    return known_gettable_ctx_params;
185}
186
187static int sm2_set_ctx_params(void *vpsm2ctx, const OSSL_PARAM params[])
188{
189    PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
190
191    if (psm2ctx == NULL)
192        return 0;
193    if (params == NULL)
194        return 1;
195
196    if (!ossl_prov_digest_load_from_params(&psm2ctx->md, params,
197                                           psm2ctx->libctx))
198        return 0;
199
200    return 1;
201}
202
203static const OSSL_PARAM known_settable_ctx_params[] = {
204    OSSL_PARAM_utf8_string(OSSL_ASYM_CIPHER_PARAM_DIGEST, NULL, 0),
205    OSSL_PARAM_utf8_string(OSSL_ASYM_CIPHER_PARAM_PROPERTIES, NULL, 0),
206    OSSL_PARAM_utf8_string(OSSL_ASYM_CIPHER_PARAM_ENGINE, NULL, 0),
207    OSSL_PARAM_END
208};
209
210static const OSSL_PARAM *sm2_settable_ctx_params(ossl_unused void *vpsm2ctx,
211                                                 ossl_unused void *provctx)
212{
213    return known_settable_ctx_params;
214}
215
216const OSSL_DISPATCH ossl_sm2_asym_cipher_functions[] = {
217    { OSSL_FUNC_ASYM_CIPHER_NEWCTX, (void (*)(void))sm2_newctx },
218    { OSSL_FUNC_ASYM_CIPHER_ENCRYPT_INIT, (void (*)(void))sm2_init },
219    { OSSL_FUNC_ASYM_CIPHER_ENCRYPT, (void (*)(void))sm2_asym_encrypt },
220    { OSSL_FUNC_ASYM_CIPHER_DECRYPT_INIT, (void (*)(void))sm2_init },
221    { OSSL_FUNC_ASYM_CIPHER_DECRYPT, (void (*)(void))sm2_asym_decrypt },
222    { OSSL_FUNC_ASYM_CIPHER_FREECTX, (void (*)(void))sm2_freectx },
223    { OSSL_FUNC_ASYM_CIPHER_DUPCTX, (void (*)(void))sm2_dupctx },
224    { OSSL_FUNC_ASYM_CIPHER_GET_CTX_PARAMS,
225      (void (*)(void))sm2_get_ctx_params },
226    { OSSL_FUNC_ASYM_CIPHER_GETTABLE_CTX_PARAMS,
227      (void (*)(void))sm2_gettable_ctx_params },
228    { OSSL_FUNC_ASYM_CIPHER_SET_CTX_PARAMS,
229      (void (*)(void))sm2_set_ctx_params },
230    { OSSL_FUNC_ASYM_CIPHER_SETTABLE_CTX_PARAMS,
231      (void (*)(void))sm2_settable_ctx_params },
232    { 0, NULL }
233};
234