1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Public Key Encryption
5 * Copyright (c) 2015, Intel Corporation
6 * Authors: Tadeusz Struk <tadeusz.struk@intel.com>
8 #include <crypto/internal/akcipher.h>
9 #include <linux/cryptouser.h>
10 #include <linux/errno.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/scatterlist.h>
14 #include <linux/seq_file.h>
15 #include <linux/slab.h>
16 #include <linux/string.h>
17 #include <net/netlink.h>
21 #define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000e
23 static int __maybe_unused
crypto_akcipher_report(
24 struct sk_buff
*skb
, struct crypto_alg
*alg
)
26 struct crypto_report_akcipher rakcipher
;
28 memset(&rakcipher
, 0, sizeof(rakcipher
));
30 strscpy(rakcipher
.type
, "akcipher", sizeof(rakcipher
.type
));
32 return nla_put(skb
, CRYPTOCFGA_REPORT_AKCIPHER
,
33 sizeof(rakcipher
), &rakcipher
);
36 static void crypto_akcipher_show(struct seq_file
*m
, struct crypto_alg
*alg
)
39 static void crypto_akcipher_show(struct seq_file
*m
, struct crypto_alg
*alg
)
41 seq_puts(m
, "type : akcipher\n");
44 static void crypto_akcipher_exit_tfm(struct crypto_tfm
*tfm
)
46 struct crypto_akcipher
*akcipher
= __crypto_akcipher_tfm(tfm
);
47 struct akcipher_alg
*alg
= crypto_akcipher_alg(akcipher
);
52 static int crypto_akcipher_init_tfm(struct crypto_tfm
*tfm
)
54 struct crypto_akcipher
*akcipher
= __crypto_akcipher_tfm(tfm
);
55 struct akcipher_alg
*alg
= crypto_akcipher_alg(akcipher
);
58 akcipher
->base
.exit
= crypto_akcipher_exit_tfm
;
61 return alg
->init(akcipher
);
66 static void crypto_akcipher_free_instance(struct crypto_instance
*inst
)
68 struct akcipher_instance
*akcipher
= akcipher_instance(inst
);
70 akcipher
->free(akcipher
);
73 static int __maybe_unused
crypto_akcipher_report_stat(
74 struct sk_buff
*skb
, struct crypto_alg
*alg
)
76 struct akcipher_alg
*akcipher
= __crypto_akcipher_alg(alg
);
77 struct crypto_istat_akcipher
*istat
;
78 struct crypto_stat_akcipher rakcipher
;
80 istat
= akcipher_get_stat(akcipher
);
82 memset(&rakcipher
, 0, sizeof(rakcipher
));
84 strscpy(rakcipher
.type
, "akcipher", sizeof(rakcipher
.type
));
85 rakcipher
.stat_encrypt_cnt
= atomic64_read(&istat
->encrypt_cnt
);
86 rakcipher
.stat_encrypt_tlen
= atomic64_read(&istat
->encrypt_tlen
);
87 rakcipher
.stat_decrypt_cnt
= atomic64_read(&istat
->decrypt_cnt
);
88 rakcipher
.stat_decrypt_tlen
= atomic64_read(&istat
->decrypt_tlen
);
89 rakcipher
.stat_sign_cnt
= atomic64_read(&istat
->sign_cnt
);
90 rakcipher
.stat_verify_cnt
= atomic64_read(&istat
->verify_cnt
);
91 rakcipher
.stat_err_cnt
= atomic64_read(&istat
->err_cnt
);
93 return nla_put(skb
, CRYPTOCFGA_STAT_AKCIPHER
,
94 sizeof(rakcipher
), &rakcipher
);
97 static const struct crypto_type crypto_akcipher_type
= {
98 .extsize
= crypto_alg_extsize
,
99 .init_tfm
= crypto_akcipher_init_tfm
,
100 .free
= crypto_akcipher_free_instance
,
101 #ifdef CONFIG_PROC_FS
102 .show
= crypto_akcipher_show
,
104 #if IS_ENABLED(CONFIG_CRYPTO_USER)
105 .report
= crypto_akcipher_report
,
107 #ifdef CONFIG_CRYPTO_STATS
108 .report_stat
= crypto_akcipher_report_stat
,
110 .maskclear
= ~CRYPTO_ALG_TYPE_MASK
,
111 .maskset
= CRYPTO_ALG_TYPE_AHASH_MASK
,
112 .type
= CRYPTO_ALG_TYPE_AKCIPHER
,
113 .tfmsize
= offsetof(struct crypto_akcipher
, base
),
116 int crypto_grab_akcipher(struct crypto_akcipher_spawn
*spawn
,
117 struct crypto_instance
*inst
,
118 const char *name
, u32 type
, u32 mask
)
120 spawn
->base
.frontend
= &crypto_akcipher_type
;
121 return crypto_grab_spawn(&spawn
->base
, inst
, name
, type
, mask
);
123 EXPORT_SYMBOL_GPL(crypto_grab_akcipher
);
125 struct crypto_akcipher
*crypto_alloc_akcipher(const char *alg_name
, u32 type
,
128 return crypto_alloc_tfm(alg_name
, &crypto_akcipher_type
, type
, mask
);
130 EXPORT_SYMBOL_GPL(crypto_alloc_akcipher
);
132 static void akcipher_prepare_alg(struct akcipher_alg
*alg
)
134 struct crypto_istat_akcipher
*istat
= akcipher_get_stat(alg
);
135 struct crypto_alg
*base
= &alg
->base
;
137 base
->cra_type
= &crypto_akcipher_type
;
138 base
->cra_flags
&= ~CRYPTO_ALG_TYPE_MASK
;
139 base
->cra_flags
|= CRYPTO_ALG_TYPE_AKCIPHER
;
141 if (IS_ENABLED(CONFIG_CRYPTO_STATS
))
142 memset(istat
, 0, sizeof(*istat
));
145 static int akcipher_default_op(struct akcipher_request
*req
)
150 static int akcipher_default_set_key(struct crypto_akcipher
*tfm
,
151 const void *key
, unsigned int keylen
)
156 int crypto_register_akcipher(struct akcipher_alg
*alg
)
158 struct crypto_alg
*base
= &alg
->base
;
161 alg
->sign
= akcipher_default_op
;
163 alg
->verify
= akcipher_default_op
;
165 alg
->encrypt
= akcipher_default_op
;
167 alg
->decrypt
= akcipher_default_op
;
168 if (!alg
->set_priv_key
)
169 alg
->set_priv_key
= akcipher_default_set_key
;
171 akcipher_prepare_alg(alg
);
172 return crypto_register_alg(base
);
174 EXPORT_SYMBOL_GPL(crypto_register_akcipher
);
176 void crypto_unregister_akcipher(struct akcipher_alg
*alg
)
178 crypto_unregister_alg(&alg
->base
);
180 EXPORT_SYMBOL_GPL(crypto_unregister_akcipher
);
182 int akcipher_register_instance(struct crypto_template
*tmpl
,
183 struct akcipher_instance
*inst
)
185 if (WARN_ON(!inst
->free
))
187 akcipher_prepare_alg(&inst
->alg
);
188 return crypto_register_instance(tmpl
, akcipher_crypto_instance(inst
));
190 EXPORT_SYMBOL_GPL(akcipher_register_instance
);
192 int crypto_akcipher_sync_prep(struct crypto_akcipher_sync_data
*data
)
194 unsigned int reqsize
= crypto_akcipher_reqsize(data
->tfm
);
195 struct akcipher_request
*req
;
196 struct scatterlist
*sg
;
202 mlen
= max(data
->slen
, data
->dlen
);
204 mlen
= data
->slen
+ data
->dlen
;
206 len
= sizeof(*req
) + reqsize
+ mlen
;
210 req
= kzalloc(len
, GFP_KERNEL
);
215 akcipher_request_set_tfm(req
, data
->tfm
);
217 buf
= (u8
*)(req
+ 1) + reqsize
;
219 memcpy(buf
, data
->src
, data
->slen
);
222 sg_init_one(sg
, buf
, mlen
);
223 akcipher_request_set_crypt(req
, sg
, data
->dst
? sg
: NULL
,
224 data
->slen
, data
->dlen
);
226 crypto_init_wait(&data
->cwait
);
227 akcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_SLEEP
,
228 crypto_req_done
, &data
->cwait
);
232 EXPORT_SYMBOL_GPL(crypto_akcipher_sync_prep
);
234 int crypto_akcipher_sync_post(struct crypto_akcipher_sync_data
*data
, int err
)
236 err
= crypto_wait_req(err
, &data
->cwait
);
238 memcpy(data
->dst
, data
->buf
, data
->dlen
);
239 data
->dlen
= data
->req
->dst_len
;
240 kfree_sensitive(data
->req
);
243 EXPORT_SYMBOL_GPL(crypto_akcipher_sync_post
);
245 int crypto_akcipher_sync_encrypt(struct crypto_akcipher
*tfm
,
246 const void *src
, unsigned int slen
,
247 void *dst
, unsigned int dlen
)
249 struct crypto_akcipher_sync_data data
= {
257 return crypto_akcipher_sync_prep(&data
) ?:
258 crypto_akcipher_sync_post(&data
,
259 crypto_akcipher_encrypt(data
.req
));
261 EXPORT_SYMBOL_GPL(crypto_akcipher_sync_encrypt
);
263 int crypto_akcipher_sync_decrypt(struct crypto_akcipher
*tfm
,
264 const void *src
, unsigned int slen
,
265 void *dst
, unsigned int dlen
)
267 struct crypto_akcipher_sync_data data
= {
275 return crypto_akcipher_sync_prep(&data
) ?:
276 crypto_akcipher_sync_post(&data
,
277 crypto_akcipher_decrypt(data
.req
)) ?:
280 EXPORT_SYMBOL_GPL(crypto_akcipher_sync_decrypt
);
282 static void crypto_exit_akcipher_ops_sig(struct crypto_tfm
*tfm
)
284 struct crypto_akcipher
**ctx
= crypto_tfm_ctx(tfm
);
286 crypto_free_akcipher(*ctx
);
289 int crypto_init_akcipher_ops_sig(struct crypto_tfm
*tfm
)
291 struct crypto_akcipher
**ctx
= crypto_tfm_ctx(tfm
);
292 struct crypto_alg
*calg
= tfm
->__crt_alg
;
293 struct crypto_akcipher
*akcipher
;
295 if (!crypto_mod_get(calg
))
298 akcipher
= crypto_create_tfm(calg
, &crypto_akcipher_type
);
299 if (IS_ERR(akcipher
)) {
300 crypto_mod_put(calg
);
301 return PTR_ERR(akcipher
);
305 tfm
->exit
= crypto_exit_akcipher_ops_sig
;
309 EXPORT_SYMBOL_GPL(crypto_init_akcipher_ops_sig
);
311 MODULE_LICENSE("GPL");
312 MODULE_DESCRIPTION("Generic public key cipher type");