Blame view
crypto/algif_aead.c
15.6 KB
2874c5fd2 treewide: Replace... |
1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
400c40cf7 crypto: algif - a... |
2 3 4 5 6 7 8 |
/* * algif_aead: User-space interface for AEAD algorithms * * Copyright (C) 2014, Stephan Mueller <smueller@chronox.de> * * This file provides the user-space API for AEAD ciphers. * |
d887c52d6 crypto: algif_aea... |
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
* The following concept of the memory management is used: * * The kernel maintains two SGLs, the TX SGL and the RX SGL. The TX SGL is * filled by user space with the data submitted via sendpage/sendmsg. Filling * up the TX SGL does not cause a crypto operation -- the data will only be * tracked by the kernel. Upon receipt of one recvmsg call, the caller must * provide a buffer which is tracked with the RX SGL. * * During the processing of the recvmsg operation, the cipher request is * allocated and prepared. As part of the recvmsg operation, the processed * TX buffers are extracted from the TX SGL into a separate SGL. * * After the completion of the crypto operation, the RX SGL and the cipher * request is released. The extracted TX SGL parts are released together with * the RX SGL release. |
400c40cf7 crypto: algif - a... |
24 |
*/ |
83094e5e9 crypto: af_alg - ... |
25 |
#include <crypto/internal/aead.h> |
400c40cf7 crypto: algif - a... |
26 27 |
#include <crypto/scatterwalk.h> #include <crypto/if_alg.h> |
72548b093 crypto: algif_aea... |
28 29 |
#include <crypto/skcipher.h> #include <crypto/null.h> |
400c40cf7 crypto: algif - a... |
30 31 32 33 34 35 36 |
#include <linux/init.h> #include <linux/list.h> #include <linux/kernel.h> #include <linux/mm.h> #include <linux/module.h> #include <linux/net.h> #include <net/sock.h> |
2a2a251f1 crypto: algif_aea... |
37 38 |
struct aead_tfm { struct crypto_aead *aead; |
8d6053984 crypto: null - Re... |
39 |
struct crypto_sync_skcipher *null_tfm; |
2a2a251f1 crypto: algif_aea... |
40 |
}; |
d887c52d6 crypto: algif_aea... |
41 42 43 44 45 |
static inline bool aead_sufficient_data(struct sock *sk) { struct alg_sock *ask = alg_sk(sk); struct sock *psk = ask->parent; struct alg_sock *pask = alg_sk(psk); |
2d97591ef crypto: af_alg - ... |
46 |
struct af_alg_ctx *ctx = ask->private; |
d887c52d6 crypto: algif_aea... |
47 48 49 |
struct aead_tfm *aeadc = pask->private; struct crypto_aead *tfm = aeadc->aead; unsigned int as = crypto_aead_authsize(tfm); |
400c40cf7 crypto: algif - a... |
50 |
|
0c1e16cd1 crypto: algif_aea... |
51 52 53 54 55 |
/* * The minimum amount of memory needed for an AEAD cipher is * the AAD and in case of decryption the tag. */ return ctx->used >= ctx->aead_assoclen + (ctx->enc ? 0 : as); |
400c40cf7 crypto: algif - a... |
56 |
} |
eccd02f32 crypto: fix mis-m... |
57 |
static int aead_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) |
400c40cf7 crypto: algif - a... |
58 59 60 |
{ struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); |
d887c52d6 crypto: algif_aea... |
61 62 |
struct sock *psk = ask->parent; struct alg_sock *pask = alg_sk(psk); |
d887c52d6 crypto: algif_aea... |
63 64 65 |
struct aead_tfm *aeadc = pask->private; struct crypto_aead *tfm = aeadc->aead; unsigned int ivsize = crypto_aead_ivsize(tfm); |
400c40cf7 crypto: algif - a... |
66 |
|
2d97591ef crypto: af_alg - ... |
67 |
return af_alg_sendmsg(sock, msg, size, ivsize); |
83094e5e9 crypto: af_alg - ... |
68 |
} |
8d6053984 crypto: null - Re... |
69 |
static int crypto_aead_copy_sgl(struct crypto_sync_skcipher *null_tfm, |
72548b093 crypto: algif_aea... |
70 71 72 |
struct scatterlist *src, struct scatterlist *dst, unsigned int len) { |
8d6053984 crypto: null - Re... |
73 |
SYNC_SKCIPHER_REQUEST_ON_STACK(skreq, null_tfm); |
72548b093 crypto: algif_aea... |
74 |
|
8d6053984 crypto: null - Re... |
75 |
skcipher_request_set_sync_tfm(skreq, null_tfm); |
cbdad1f24 crypto: algif_aea... |
76 |
skcipher_request_set_callback(skreq, CRYPTO_TFM_REQ_MAY_SLEEP, |
72548b093 crypto: algif_aea... |
77 78 79 80 81 |
NULL, NULL); skcipher_request_set_crypt(skreq, src, dst, len, NULL); return crypto_skcipher_encrypt(skreq); } |
d887c52d6 crypto: algif_aea... |
82 83 |
static int _aead_recvmsg(struct socket *sock, struct msghdr *msg, size_t ignored, int flags) |
400c40cf7 crypto: algif - a... |
84 85 86 |
{ struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); |
d887c52d6 crypto: algif_aea... |
87 88 |
struct sock *psk = ask->parent; struct alg_sock *pask = alg_sk(psk); |
2d97591ef crypto: af_alg - ... |
89 |
struct af_alg_ctx *ctx = ask->private; |
d887c52d6 crypto: algif_aea... |
90 91 |
struct aead_tfm *aeadc = pask->private; struct crypto_aead *tfm = aeadc->aead; |
8d6053984 crypto: null - Re... |
92 |
struct crypto_sync_skcipher *null_tfm = aeadc->null_tfm; |
8e1fa89aa crypto: algif_aea... |
93 |
unsigned int i, as = crypto_aead_authsize(tfm); |
2d97591ef crypto: af_alg - ... |
94 |
struct af_alg_async_req *areq; |
8e1fa89aa crypto: algif_aea... |
95 96 |
struct af_alg_tsgl *tsgl, *tmp; struct scatterlist *rsgl_src, *tsgl_src = NULL; |
d887c52d6 crypto: algif_aea... |
97 98 99 100 101 |
int err = 0; size_t used = 0; /* [in] TX bufs to be en/decrypted */ size_t outlen = 0; /* [out] RX bufs produced by kernel */ size_t usedpages = 0; /* [in] RX bufs to be used from user */ size_t processed = 0; /* [in] TX bufs to be consumed */ |
400c40cf7 crypto: algif - a... |
102 |
|
f3c802a1f crypto: algif_aea... |
103 104 |
if (!ctx->init || ctx->more) { err = af_alg_wait_for_data(sk, flags, 0); |
11edb5559 crypto: af_alg - ... |
105 106 107 |
if (err) return err; } |
400c40cf7 crypto: algif - a... |
108 |
/* |
d887c52d6 crypto: algif_aea... |
109 110 |
* Data length provided by caller via sendmsg/sendpage that has not * yet been processed. |
400c40cf7 crypto: algif - a... |
111 |
*/ |
400c40cf7 crypto: algif - a... |
112 113 114 115 |
used = ctx->used; /* * Make sure sufficient data is present -- note, the same check is |
4eb57bcd4 crypto: algif_aea... |
116 |
* also present in sendmsg/sendpage. The checks in sendpage/sendmsg |
400c40cf7 crypto: algif - a... |
117 118 119 120 121 122 |
* shall provide an information to the data sender that something is * wrong, but they are irrelevant to maintain the kernel integrity. * We need this check here too in case user space decides to not honor * the error message in sendmsg/sendpage and still call recvmsg. This * check here protects the kernel integrity. */ |
d887c52d6 crypto: algif_aea... |
123 124 |
if (!aead_sufficient_data(sk)) return -EINVAL; |
400c40cf7 crypto: algif - a... |
125 |
|
0c1e16cd1 crypto: algif_aea... |
126 127 128 129 130 131 132 133 134 135 136 137 |
/* * Calculate the minimum output buffer size holding the result of the * cipher operation. When encrypting data, the receiving buffer is * larger by the tag length compared to the input buffer as the * encryption operation generates the tag. For decryption, the input * buffer provides the tag which is consumed resulting in only the * plaintext without a buffer for the tag returned to the caller. */ if (ctx->enc) outlen = used + as; else outlen = used - as; |
19fa77522 crypto: algif_aea... |
138 |
|
400c40cf7 crypto: algif - a... |
139 140 141 142 |
/* * The cipher operation input data is reduced by the associated data * length as this data is processed separately later on. */ |
0c1e16cd1 crypto: algif_aea... |
143 |
used -= ctx->aead_assoclen; |
400c40cf7 crypto: algif - a... |
144 |
|
d887c52d6 crypto: algif_aea... |
145 |
/* Allocate cipher request for current operation. */ |
2d97591ef crypto: af_alg - ... |
146 147 148 149 |
areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) + crypto_aead_reqsize(tfm)); if (IS_ERR(areq)) return PTR_ERR(areq); |
d887c52d6 crypto: algif_aea... |
150 151 |
/* convert iovecs of output buffers into RX SGL */ |
2d97591ef crypto: af_alg - ... |
152 153 154 |
err = af_alg_get_rsgl(sk, msg, flags, areq, outlen, &usedpages); if (err) goto free; |
400c40cf7 crypto: algif - a... |
155 |
|
d887c52d6 crypto: algif_aea... |
156 157 158 159 160 161 162 |
/* * Ensure output buffer is sufficiently large. If the caller provides * less buffer space, only use the relative required input size. This * allows AIO operation where the caller sent all data to be processed * and the AIO operation performs the operation on the different chunks * of the input data. */ |
0c1e16cd1 crypto: algif_aea... |
163 |
if (usedpages < outlen) { |
d887c52d6 crypto: algif_aea... |
164 |
size_t less = outlen - usedpages; |
400c40cf7 crypto: algif - a... |
165 |
|
d887c52d6 crypto: algif_aea... |
166 167 168 169 170 171 172 |
if (used < less) { err = -EINVAL; goto free; } used -= less; outlen -= less; } |
400c40cf7 crypto: algif - a... |
173 |
|
72548b093 crypto: algif_aea... |
174 |
processed = used + ctx->aead_assoclen; |
8e1fa89aa crypto: algif_aea... |
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 |
list_for_each_entry_safe(tsgl, tmp, &ctx->tsgl_list, list) { for (i = 0; i < tsgl->cur; i++) { struct scatterlist *process_sg = tsgl->sg + i; if (!(process_sg->length) || !sg_page(process_sg)) continue; tsgl_src = process_sg; break; } if (tsgl_src) break; } if (processed && !tsgl_src) { err = -EFAULT; goto free; } |
72548b093 crypto: algif_aea... |
191 |
|
d887c52d6 crypto: algif_aea... |
192 |
/* |
72548b093 crypto: algif_aea... |
193 194 195 196 197 198 199 200 201 202 |
* Copy of AAD from source to destination * * The AAD is copied to the destination buffer without change. Even * when user space uses an in-place cipher operation, the kernel * will copy the data as it does not see whether such in-place operation * is initiated. * * To ensure efficiency, the following implementation ensure that the * ciphers are invoked to perform a crypto operation in-place. This * is achieved by memory management specified as follows. |
d887c52d6 crypto: algif_aea... |
203 |
*/ |
72548b093 crypto: algif_aea... |
204 205 |
/* Use the RX SGL as source (and destination) for crypto op. */ |
8e1fa89aa crypto: algif_aea... |
206 |
rsgl_src = areq->first_rsgl.sgl.sg; |
72548b093 crypto: algif_aea... |
207 208 209 210 211 212 |
if (ctx->enc) { /* * Encryption operation - The in-place cipher operation is * achieved by the following operation: * |
75d11e753 crypto: algif_aea... |
213 |
* TX SGL: AAD || PT |
72548b093 crypto: algif_aea... |
214 215 216 |
* | | * | copy | * v v |
75d11e753 crypto: algif_aea... |
217 |
* RX SGL: AAD || PT || Tag |
72548b093 crypto: algif_aea... |
218 |
*/ |
8e1fa89aa crypto: algif_aea... |
219 |
err = crypto_aead_copy_sgl(null_tfm, tsgl_src, |
72548b093 crypto: algif_aea... |
220 221 222 |
areq->first_rsgl.sgl.sg, processed); if (err) goto free; |
2d97591ef crypto: af_alg - ... |
223 |
af_alg_pull_tsgl(sk, processed, NULL, 0); |
72548b093 crypto: algif_aea... |
224 225 226 227 228 229 230 231 232 233 234 235 236 |
} else { /* * Decryption operation - To achieve an in-place cipher * operation, the following SGL structure is used: * * TX SGL: AAD || CT || Tag * | | ^ * | copy | | Create SGL link. * v v | * RX SGL: AAD || CT ----+ */ /* Copy AAD || CT to RX SGL buffer for in-place operation. */ |
8e1fa89aa crypto: algif_aea... |
237 |
err = crypto_aead_copy_sgl(null_tfm, tsgl_src, |
72548b093 crypto: algif_aea... |
238 239 240 241 242 |
areq->first_rsgl.sgl.sg, outlen); if (err) goto free; /* Create TX SGL for tag and chain it to RX SGL. */ |
2d97591ef crypto: af_alg - ... |
243 244 |
areq->tsgl_entries = af_alg_count_tsgl(sk, processed, processed - as); |
72548b093 crypto: algif_aea... |
245 246 |
if (!areq->tsgl_entries) areq->tsgl_entries = 1; |
76e43e37a treewide: Use arr... |
247 248 |
areq->tsgl = sock_kmalloc(sk, array_size(sizeof(*areq->tsgl), areq->tsgl_entries), |
72548b093 crypto: algif_aea... |
249 250 251 252 253 254 255 256 |
GFP_KERNEL); if (!areq->tsgl) { err = -ENOMEM; goto free; } sg_init_table(areq->tsgl, areq->tsgl_entries); /* Release TX SGL, except for tag data and reassign tag data. */ |
2d97591ef crypto: af_alg - ... |
257 |
af_alg_pull_tsgl(sk, processed, areq->tsgl, processed - as); |
72548b093 crypto: algif_aea... |
258 259 |
/* chain the areq TX SGL holding the tag with RX SGL */ |
2d97591ef crypto: af_alg - ... |
260 |
if (usedpages) { |
72548b093 crypto: algif_aea... |
261 |
/* RX SGL present */ |
2d97591ef crypto: af_alg - ... |
262 |
struct af_alg_sgl *sgl_prev = &areq->last_rsgl->sgl; |
72548b093 crypto: algif_aea... |
263 264 265 266 267 268 |
sg_unmark_end(sgl_prev->sg + sgl_prev->npages - 1); sg_chain(sgl_prev->sg, sgl_prev->npages + 1, areq->tsgl); } else /* no RX SGL present (e.g. authentication only) */ |
8e1fa89aa crypto: algif_aea... |
269 |
rsgl_src = areq->tsgl; |
d887c52d6 crypto: algif_aea... |
270 |
} |
d887c52d6 crypto: algif_aea... |
271 272 |
/* Initialize the crypto operation */ |
8e1fa89aa crypto: algif_aea... |
273 |
aead_request_set_crypt(&areq->cra_u.aead_req, rsgl_src, |
d887c52d6 crypto: algif_aea... |
274 |
areq->first_rsgl.sgl.sg, used, ctx->iv); |
2d97591ef crypto: af_alg - ... |
275 276 |
aead_request_set_ad(&areq->cra_u.aead_req, ctx->aead_assoclen); aead_request_set_tfm(&areq->cra_u.aead_req, tfm); |
d887c52d6 crypto: algif_aea... |
277 278 279 |
if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) { /* AIO operation */ |
7d2c3f54e crypto: af_alg - ... |
280 |
sock_hold(sk); |
d887c52d6 crypto: algif_aea... |
281 |
areq->iocb = msg->msg_iocb; |
d53c51357 crypto: af_alg - ... |
282 283 284 |
/* Remember output size that will be generated. */ areq->outlen = outlen; |
2d97591ef crypto: af_alg - ... |
285 |
aead_request_set_callback(&areq->cra_u.aead_req, |
cbdad1f24 crypto: algif_aea... |
286 |
CRYPTO_TFM_REQ_MAY_SLEEP, |
2d97591ef crypto: af_alg - ... |
287 288 289 |
af_alg_async_cb, areq); err = ctx->enc ? crypto_aead_encrypt(&areq->cra_u.aead_req) : crypto_aead_decrypt(&areq->cra_u.aead_req); |
7d2c3f54e crypto: af_alg - ... |
290 291 |
/* AIO operation in progress */ |
cbdad1f24 crypto: algif_aea... |
292 |
if (err == -EINPROGRESS) |
7d2c3f54e crypto: af_alg - ... |
293 |
return -EIOCBQUEUED; |
7d2c3f54e crypto: af_alg - ... |
294 295 |
sock_put(sk); |
d887c52d6 crypto: algif_aea... |
296 297 |
} else { /* Synchronous operation */ |
2d97591ef crypto: af_alg - ... |
298 |
aead_request_set_callback(&areq->cra_u.aead_req, |
cbdad1f24 crypto: algif_aea... |
299 |
CRYPTO_TFM_REQ_MAY_SLEEP | |
d887c52d6 crypto: algif_aea... |
300 |
CRYPTO_TFM_REQ_MAY_BACKLOG, |
2c3f8b162 crypto: algif - m... |
301 302 |
crypto_req_done, &ctx->wait); err = crypto_wait_req(ctx->enc ? |
2d97591ef crypto: af_alg - ... |
303 304 |
crypto_aead_encrypt(&areq->cra_u.aead_req) : crypto_aead_decrypt(&areq->cra_u.aead_req), |
2c3f8b162 crypto: algif - m... |
305 |
&ctx->wait); |
400c40cf7 crypto: algif - a... |
306 |
} |
d887c52d6 crypto: algif_aea... |
307 308 |
free: |
7d2c3f54e crypto: af_alg - ... |
309 |
af_alg_free_resources(areq); |
400c40cf7 crypto: algif - a... |
310 311 312 |
return err ? err : outlen; } |
d887c52d6 crypto: algif_aea... |
313 314 |
static int aead_recvmsg(struct socket *sock, struct msghdr *msg, size_t ignored, int flags) |
83094e5e9 crypto: af_alg - ... |
315 |
{ |
d887c52d6 crypto: algif_aea... |
316 317 318 319 320 321 322 323 324 325 326 327 |
struct sock *sk = sock->sk; int ret = 0; lock_sock(sk); while (msg_data_left(msg)) { int err = _aead_recvmsg(sock, msg, ignored, flags); /* * This error covers -EIOCBQUEUED which implies that we can * only handle one AIO request. If the caller wants to have * multiple AIO requests in parallel, he must make multiple * separate AIO calls. |
5703c826b crypto: algif - r... |
328 329 |
* * Also return the error if no data has been processed so far. |
d887c52d6 crypto: algif_aea... |
330 331 |
*/ if (err <= 0) { |
5703c826b crypto: algif - r... |
332 |
if (err == -EIOCBQUEUED || err == -EBADMSG || !ret) |
d887c52d6 crypto: algif_aea... |
333 334 335 336 337 338 339 340 |
ret = err; goto out; } ret += err; } out: |
2d97591ef crypto: af_alg - ... |
341 |
af_alg_wmem_wakeup(sk); |
d887c52d6 crypto: algif_aea... |
342 343 |
release_sock(sk); return ret; |
83094e5e9 crypto: af_alg - ... |
344 |
} |
400c40cf7 crypto: algif - a... |
345 346 347 348 349 350 351 352 353 |
static struct proto_ops algif_aead_ops = { .family = PF_ALG, .connect = sock_no_connect, .socketpair = sock_no_socketpair, .getname = sock_no_getname, .ioctl = sock_no_ioctl, .listen = sock_no_listen, .shutdown = sock_no_shutdown, |
400c40cf7 crypto: algif - a... |
354 355 356 |
.mmap = sock_no_mmap, .bind = sock_no_bind, .accept = sock_no_accept, |
400c40cf7 crypto: algif - a... |
357 358 359 |
.release = af_alg_release, .sendmsg = aead_sendmsg, |
2d97591ef crypto: af_alg - ... |
360 |
.sendpage = af_alg_sendpage, |
400c40cf7 crypto: algif - a... |
361 |
.recvmsg = aead_recvmsg, |
a11e1d432 Revert changes to... |
362 |
.poll = af_alg_poll, |
400c40cf7 crypto: algif - a... |
363 |
}; |
2a2a251f1 crypto: algif_aea... |
364 365 366 367 368 369 370 371 372 373 |
static int aead_check_key(struct socket *sock) { int err = 0; struct sock *psk; struct alg_sock *pask; struct aead_tfm *tfm; struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); lock_sock(sk); |
34c86f4c4 crypto: af_alg - ... |
374 |
if (!atomic_read(&ask->nokey_refcnt)) |
2a2a251f1 crypto: algif_aea... |
375 376 377 378 379 380 381 382 |
goto unlock_child; psk = ask->parent; pask = alg_sk(ask->parent); tfm = pask->private; err = -ENOKEY; lock_sock_nested(psk, SINGLE_DEPTH_NESTING); |
dc26c17f7 crypto: aead - pr... |
383 |
if (crypto_aead_get_flags(tfm->aead) & CRYPTO_TFM_NEED_KEY) |
2a2a251f1 crypto: algif_aea... |
384 |
goto unlock; |
34c86f4c4 crypto: af_alg - ... |
385 386 |
atomic_dec(&pask->nokey_refcnt); atomic_set(&ask->nokey_refcnt, 0); |
2a2a251f1 crypto: algif_aea... |
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 |
err = 0; unlock: release_sock(psk); unlock_child: release_sock(sk); return err; } static int aead_sendmsg_nokey(struct socket *sock, struct msghdr *msg, size_t size) { int err; err = aead_check_key(sock); if (err) return err; return aead_sendmsg(sock, msg, size); } static ssize_t aead_sendpage_nokey(struct socket *sock, struct page *page, int offset, size_t size, int flags) { int err; err = aead_check_key(sock); if (err) return err; |
2d97591ef crypto: af_alg - ... |
418 |
return af_alg_sendpage(sock, page, offset, size, flags); |
2a2a251f1 crypto: algif_aea... |
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 |
} static int aead_recvmsg_nokey(struct socket *sock, struct msghdr *msg, size_t ignored, int flags) { int err; err = aead_check_key(sock); if (err) return err; return aead_recvmsg(sock, msg, ignored, flags); } static struct proto_ops algif_aead_ops_nokey = { .family = PF_ALG, .connect = sock_no_connect, .socketpair = sock_no_socketpair, .getname = sock_no_getname, .ioctl = sock_no_ioctl, .listen = sock_no_listen, .shutdown = sock_no_shutdown, |
2a2a251f1 crypto: algif_aea... |
442 443 444 |
.mmap = sock_no_mmap, .bind = sock_no_bind, .accept = sock_no_accept, |
2a2a251f1 crypto: algif_aea... |
445 446 447 448 449 |
.release = af_alg_release, .sendmsg = aead_sendmsg_nokey, .sendpage = aead_sendpage_nokey, .recvmsg = aead_recvmsg_nokey, |
a11e1d432 Revert changes to... |
450 |
.poll = af_alg_poll, |
2a2a251f1 crypto: algif_aea... |
451 |
}; |
400c40cf7 crypto: algif - a... |
452 453 |
static void *aead_bind(const char *name, u32 type, u32 mask) { |
2a2a251f1 crypto: algif_aea... |
454 455 |
struct aead_tfm *tfm; struct crypto_aead *aead; |
8d6053984 crypto: null - Re... |
456 |
struct crypto_sync_skcipher *null_tfm; |
2a2a251f1 crypto: algif_aea... |
457 458 459 460 461 462 463 464 465 466 |
tfm = kzalloc(sizeof(*tfm), GFP_KERNEL); if (!tfm) return ERR_PTR(-ENOMEM); aead = crypto_alloc_aead(name, type, mask); if (IS_ERR(aead)) { kfree(tfm); return ERR_CAST(aead); } |
3a2d4fb51 crypto: null - Ge... |
467 |
null_tfm = crypto_get_default_null_skcipher(); |
72548b093 crypto: algif_aea... |
468 469 470 471 472 |
if (IS_ERR(null_tfm)) { crypto_free_aead(aead); kfree(tfm); return ERR_CAST(null_tfm); } |
2a2a251f1 crypto: algif_aea... |
473 |
tfm->aead = aead; |
72548b093 crypto: algif_aea... |
474 |
tfm->null_tfm = null_tfm; |
2a2a251f1 crypto: algif_aea... |
475 476 |
return tfm; |
400c40cf7 crypto: algif - a... |
477 478 479 480 |
} static void aead_release(void *private) { |
2a2a251f1 crypto: algif_aea... |
481 482 483 |
struct aead_tfm *tfm = private; crypto_free_aead(tfm->aead); |
3a2d4fb51 crypto: null - Ge... |
484 |
crypto_put_default_null_skcipher(); |
2a2a251f1 crypto: algif_aea... |
485 |
kfree(tfm); |
400c40cf7 crypto: algif - a... |
486 487 488 489 |
} static int aead_setauthsize(void *private, unsigned int authsize) { |
2a2a251f1 crypto: algif_aea... |
490 491 492 |
struct aead_tfm *tfm = private; return crypto_aead_setauthsize(tfm->aead, authsize); |
400c40cf7 crypto: algif - a... |
493 494 495 496 |
} static int aead_setkey(void *private, const u8 *key, unsigned int keylen) { |
2a2a251f1 crypto: algif_aea... |
497 |
struct aead_tfm *tfm = private; |
2a2a251f1 crypto: algif_aea... |
498 |
|
dc26c17f7 crypto: aead - pr... |
499 |
return crypto_aead_setkey(tfm->aead, key, keylen); |
400c40cf7 crypto: algif - a... |
500 501 502 503 504 |
} static void aead_sock_destruct(struct sock *sk) { struct alg_sock *ask = alg_sk(sk); |
2d97591ef crypto: af_alg - ... |
505 |
struct af_alg_ctx *ctx = ask->private; |
d887c52d6 crypto: algif_aea... |
506 507 508 509 510 |
struct sock *psk = ask->parent; struct alg_sock *pask = alg_sk(psk); struct aead_tfm *aeadc = pask->private; struct crypto_aead *tfm = aeadc->aead; unsigned int ivlen = crypto_aead_ivsize(tfm); |
400c40cf7 crypto: algif - a... |
511 |
|
2d97591ef crypto: af_alg - ... |
512 |
af_alg_pull_tsgl(sk, ctx->used, NULL, 0); |
400c40cf7 crypto: algif - a... |
513 514 515 516 |
sock_kzfree_s(sk, ctx->iv, ivlen); sock_kfree_s(sk, ctx, ctx->len); af_alg_release_parent(sk); } |
2a2a251f1 crypto: algif_aea... |
517 |
static int aead_accept_parent_nokey(void *private, struct sock *sk) |
400c40cf7 crypto: algif - a... |
518 |
{ |
2d97591ef crypto: af_alg - ... |
519 |
struct af_alg_ctx *ctx; |
400c40cf7 crypto: algif - a... |
520 |
struct alg_sock *ask = alg_sk(sk); |
2a2a251f1 crypto: algif_aea... |
521 522 |
struct aead_tfm *tfm = private; struct crypto_aead *aead = tfm->aead; |
d887c52d6 crypto: algif_aea... |
523 |
unsigned int len = sizeof(*ctx); |
2a2a251f1 crypto: algif_aea... |
524 |
unsigned int ivlen = crypto_aead_ivsize(aead); |
400c40cf7 crypto: algif - a... |
525 526 527 528 529 530 531 532 533 534 535 536 |
ctx = sock_kmalloc(sk, len, GFP_KERNEL); if (!ctx) return -ENOMEM; memset(ctx, 0, len); ctx->iv = sock_kmalloc(sk, ivlen, GFP_KERNEL); if (!ctx->iv) { sock_kfree_s(sk, ctx, len); return -ENOMEM; } memset(ctx->iv, 0, ivlen); |
d887c52d6 crypto: algif_aea... |
537 |
INIT_LIST_HEAD(&ctx->tsgl_list); |
400c40cf7 crypto: algif - a... |
538 |
ctx->len = len; |
2c3f8b162 crypto: algif - m... |
539 |
crypto_init_wait(&ctx->wait); |
400c40cf7 crypto: algif - a... |
540 541 |
ask->private = ctx; |
400c40cf7 crypto: algif - a... |
542 543 544 545 |
sk->sk_destruct = aead_sock_destruct; return 0; } |
2a2a251f1 crypto: algif_aea... |
546 547 548 |
static int aead_accept_parent(void *private, struct sock *sk) { struct aead_tfm *tfm = private; |
dc26c17f7 crypto: aead - pr... |
549 |
if (crypto_aead_get_flags(tfm->aead) & CRYPTO_TFM_NEED_KEY) |
2a2a251f1 crypto: algif_aea... |
550 551 552 553 |
return -ENOKEY; return aead_accept_parent_nokey(private, sk); } |
400c40cf7 crypto: algif - a... |
554 555 556 557 558 559 |
static const struct af_alg_type algif_type_aead = { .bind = aead_bind, .release = aead_release, .setkey = aead_setkey, .setauthsize = aead_setauthsize, .accept = aead_accept_parent, |
2a2a251f1 crypto: algif_aea... |
560 |
.accept_nokey = aead_accept_parent_nokey, |
400c40cf7 crypto: algif - a... |
561 |
.ops = &algif_aead_ops, |
2a2a251f1 crypto: algif_aea... |
562 |
.ops_nokey = &algif_aead_ops_nokey, |
400c40cf7 crypto: algif - a... |
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 |
.name = "aead", .owner = THIS_MODULE }; static int __init algif_aead_init(void) { return af_alg_register_type(&algif_type_aead); } static void __exit algif_aead_exit(void) { int err = af_alg_unregister_type(&algif_type_aead); BUG_ON(err); } module_init(algif_aead_init); module_exit(algif_aead_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Stephan Mueller <smueller@chronox.de>"); MODULE_DESCRIPTION("AEAD kernel crypto API user space interface"); |