Blame view
crypto/af_alg.c
26.3 KB
2874c5fd2 treewide: Replace... |
1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
03c8efc1f crypto: af_alg - ... |
2 3 4 5 6 7 |
/* * af_alg: User-space algorithm interface * * This file provides the user-space API for algorithms. * * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au> |
03c8efc1f crypto: af_alg - ... |
8 |
*/ |
60063497a atomic: use <linu... |
9 |
#include <linux/atomic.h> |
03c8efc1f crypto: af_alg - ... |
10 11 12 13 14 15 16 17 |
#include <crypto/if_alg.h> #include <linux/crypto.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/list.h> #include <linux/module.h> #include <linux/net.h> #include <linux/rwsem.h> |
c195d66a8 crypto: af_alg - ... |
18 |
#include <linux/sched.h> |
2d97591ef crypto: af_alg - ... |
19 |
#include <linux/sched/signal.h> |
4c63f83c2 crypto: af_alg - ... |
20 |
#include <linux/security.h> |
03c8efc1f crypto: af_alg - ... |
21 22 23 24 25 |
struct alg_type_list { const struct af_alg_type *type; struct list_head list; }; |
068695245 crypto: af_alg - ... |
26 |
static atomic_long_t alg_memory_allocated; |
03c8efc1f crypto: af_alg - ... |
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
static struct proto alg_proto = { .name = "ALG", .owner = THIS_MODULE, .memory_allocated = &alg_memory_allocated, .obj_size = sizeof(struct alg_sock), }; static LIST_HEAD(alg_types); static DECLARE_RWSEM(alg_types_sem); static const struct af_alg_type *alg_get_type(const char *name) { const struct af_alg_type *type = ERR_PTR(-ENOENT); struct alg_type_list *node; down_read(&alg_types_sem); list_for_each_entry(node, &alg_types, list) { if (strcmp(node->type->name, name)) continue; if (try_module_get(node->type->owner)) type = node->type; break; } up_read(&alg_types_sem); return type; } int af_alg_register_type(const struct af_alg_type *type) { struct alg_type_list *node; int err = -EEXIST; down_write(&alg_types_sem); list_for_each_entry(node, &alg_types, list) { if (!strcmp(node->type->name, type->name)) goto unlock; } node = kmalloc(sizeof(*node), GFP_KERNEL); err = -ENOMEM; if (!node) goto unlock; type->ops->owner = THIS_MODULE; |
37766586c crypto: af_alg - ... |
74 75 |
if (type->ops_nokey) type->ops_nokey->owner = THIS_MODULE; |
03c8efc1f crypto: af_alg - ... |
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 |
node->type = type; list_add(&node->list, &alg_types); err = 0; unlock: up_write(&alg_types_sem); return err; } EXPORT_SYMBOL_GPL(af_alg_register_type); int af_alg_unregister_type(const struct af_alg_type *type) { struct alg_type_list *node; int err = -ENOENT; down_write(&alg_types_sem); list_for_each_entry(node, &alg_types, list) { if (strcmp(node->type->name, type->name)) continue; list_del(&node->list); kfree(node); err = 0; break; } up_write(&alg_types_sem); return err; } EXPORT_SYMBOL_GPL(af_alg_unregister_type); static void alg_do_release(const struct af_alg_type *type, void *private) { if (!type) return; type->release(private); module_put(type->owner); } int af_alg_release(struct socket *sock) { |
9060cb719 net: crypto set s... |
119 |
if (sock->sk) { |
03c8efc1f crypto: af_alg - ... |
120 |
sock_put(sock->sk); |
9060cb719 net: crypto set s... |
121 122 |
sock->sk = NULL; } |
03c8efc1f crypto: af_alg - ... |
123 124 125 |
return 0; } EXPORT_SYMBOL_GPL(af_alg_release); |
c840ac6af crypto: af_alg - ... |
126 127 128 |
void af_alg_release_parent(struct sock *sk) { struct alg_sock *ask = alg_sk(sk); |
34c86f4c4 crypto: af_alg - ... |
129 |
unsigned int nokey = atomic_read(&ask->nokey_refcnt); |
c840ac6af crypto: af_alg - ... |
130 131 132 |
sk = ask->parent; ask = alg_sk(sk); |
34c86f4c4 crypto: af_alg - ... |
133 134 |
if (nokey) atomic_dec(&ask->nokey_refcnt); |
c840ac6af crypto: af_alg - ... |
135 |
|
34c86f4c4 crypto: af_alg - ... |
136 |
if (atomic_dec_and_test(&ask->refcnt)) |
c840ac6af crypto: af_alg - ... |
137 138 139 |
sock_put(sk); } EXPORT_SYMBOL_GPL(af_alg_release_parent); |
03c8efc1f crypto: af_alg - ... |
140 141 |
static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) { |
bb30b8848 crypto: af_alg - ... |
142 |
const u32 allowed = CRYPTO_ALG_KERN_DRIVER_ONLY; |
03c8efc1f crypto: af_alg - ... |
143 144 |
struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); |
709b2d03b crypto: af_alg - ... |
145 |
struct sockaddr_alg_new *sa = (void *)uaddr; |
03c8efc1f crypto: af_alg - ... |
146 147 |
const struct af_alg_type *type; void *private; |
c840ac6af crypto: af_alg - ... |
148 |
int err; |
03c8efc1f crypto: af_alg - ... |
149 150 151 |
if (sock->state == SS_CONNECTED) return -EINVAL; |
709b2d03b crypto: af_alg - ... |
152 153 154 155 156 |
BUILD_BUG_ON(offsetof(struct sockaddr_alg_new, salg_name) != offsetof(struct sockaddr_alg, salg_name)); BUILD_BUG_ON(offsetof(struct sockaddr_alg, salg_name) != sizeof(*sa)); if (addr_len < sizeof(*sa) + 1) |
03c8efc1f crypto: af_alg - ... |
157 |
return -EINVAL; |
a466856e0 crypto: af_alg - ... |
158 159 160 |
/* If caller uses non-allowed flag, return error. */ if ((sa->salg_feat & ~allowed) || (sa->salg_mask & ~allowed)) return -EINVAL; |
03c8efc1f crypto: af_alg - ... |
161 |
sa->salg_type[sizeof(sa->salg_type) - 1] = 0; |
709b2d03b crypto: af_alg - ... |
162 |
sa->salg_name[addr_len - sizeof(*sa) - 1] = 0; |
03c8efc1f crypto: af_alg - ... |
163 164 |
type = alg_get_type(sa->salg_type); |
45586c707 treewide: remove ... |
165 |
if (PTR_ERR(type) == -ENOENT) { |
03c8efc1f crypto: af_alg - ... |
166 167 168 169 170 171 |
request_module("algif-%s", sa->salg_type); type = alg_get_type(sa->salg_type); } if (IS_ERR(type)) return PTR_ERR(type); |
bb30b8848 crypto: af_alg - ... |
172 |
private = type->bind(sa->salg_name, sa->salg_feat, sa->salg_mask); |
03c8efc1f crypto: af_alg - ... |
173 174 175 176 |
if (IS_ERR(private)) { module_put(type->owner); return PTR_ERR(private); } |
c840ac6af crypto: af_alg - ... |
177 |
err = -EBUSY; |
03c8efc1f crypto: af_alg - ... |
178 |
lock_sock(sk); |
34c86f4c4 crypto: af_alg - ... |
179 |
if (atomic_read(&ask->refcnt)) |
c840ac6af crypto: af_alg - ... |
180 |
goto unlock; |
03c8efc1f crypto: af_alg - ... |
181 182 183 |
swap(ask->type, type); swap(ask->private, private); |
c840ac6af crypto: af_alg - ... |
184 185 186 |
err = 0; unlock: |
03c8efc1f crypto: af_alg - ... |
187 188 189 |
release_sock(sk); alg_do_release(type, private); |
c840ac6af crypto: af_alg - ... |
190 |
return err; |
03c8efc1f crypto: af_alg - ... |
191 |
} |
a7b75c5a8 net: pass a sockp... |
192 |
static int alg_setkey(struct sock *sk, sockptr_t ukey, unsigned int keylen) |
03c8efc1f crypto: af_alg - ... |
193 194 195 196 197 198 199 200 201 202 203 |
{ struct alg_sock *ask = alg_sk(sk); const struct af_alg_type *type = ask->type; u8 *key; int err; key = sock_kmalloc(sk, keylen, GFP_KERNEL); if (!key) return -ENOMEM; err = -EFAULT; |
a7b75c5a8 net: pass a sockp... |
204 |
if (copy_from_sockptr(key, ukey, keylen)) |
03c8efc1f crypto: af_alg - ... |
205 206 207 208 209 |
goto out; err = type->setkey(ask->private, key, keylen); out: |
ad202c8c1 crypto: af_alg - ... |
210 |
sock_kzfree_s(sk, key, keylen); |
03c8efc1f crypto: af_alg - ... |
211 212 213 214 215 |
return err; } static int alg_setsockopt(struct socket *sock, int level, int optname, |
a7b75c5a8 net: pass a sockp... |
216 |
sockptr_t optval, unsigned int optlen) |
03c8efc1f crypto: af_alg - ... |
217 218 219 220 |
{ struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); const struct af_alg_type *type; |
c840ac6af crypto: af_alg - ... |
221 |
int err = -EBUSY; |
03c8efc1f crypto: af_alg - ... |
222 223 |
lock_sock(sk); |
34c86f4c4 crypto: af_alg - ... |
224 |
if (atomic_read(&ask->refcnt) != atomic_read(&ask->nokey_refcnt)) |
c840ac6af crypto: af_alg - ... |
225 |
goto unlock; |
03c8efc1f crypto: af_alg - ... |
226 |
type = ask->type; |
c840ac6af crypto: af_alg - ... |
227 |
err = -ENOPROTOOPT; |
03c8efc1f crypto: af_alg - ... |
228 229 230 231 232 233 234 235 236 237 238 |
if (level != SOL_ALG || !type) goto unlock; switch (optname) { case ALG_SET_KEY: if (sock->state == SS_CONNECTED) goto unlock; if (!type->setkey) goto unlock; err = alg_setkey(sk, optval, optlen); |
25fb8638e crypto: af_alg - ... |
239 240 241 242 243 244 245 |
break; case ALG_SET_AEAD_AUTHSIZE: if (sock->state == SS_CONNECTED) goto unlock; if (!type->setauthsize) goto unlock; err = type->setauthsize(ask->private, optlen); |
77ebdabe8 crypto: af_alg - ... |
246 247 248 249 250 251 252 253 |
break; case ALG_SET_DRBG_ENTROPY: if (sock->state == SS_CONNECTED) goto unlock; if (!type->setentropy) goto unlock; err = type->setentropy(ask->private, optval, optlen); |
03c8efc1f crypto: af_alg - ... |
254 255 256 257 258 259 260 |
} unlock: release_sock(sk); return err; } |
cdfbabfb2 net: Work around ... |
261 |
int af_alg_accept(struct sock *sk, struct socket *newsock, bool kern) |
03c8efc1f crypto: af_alg - ... |
262 263 264 265 |
{ struct alg_sock *ask = alg_sk(sk); const struct af_alg_type *type; struct sock *sk2; |
6a935170a crypto: af_alg - ... |
266 |
unsigned int nokey; |
03c8efc1f crypto: af_alg - ... |
267 268 269 270 271 272 273 274 |
int err; lock_sock(sk); type = ask->type; err = -EINVAL; if (!type) goto unlock; |
cdfbabfb2 net: Work around ... |
275 |
sk2 = sk_alloc(sock_net(sk), PF_ALG, GFP_KERNEL, &alg_proto, kern); |
03c8efc1f crypto: af_alg - ... |
276 277 278 279 280 |
err = -ENOMEM; if (!sk2) goto unlock; sock_init_data(newsock, sk2); |
2acce6aa9 Networking |
281 |
security_sock_graft(sk2, newsock); |
4c63f83c2 crypto: af_alg - ... |
282 |
security_sk_clone(sk, sk2); |
03c8efc1f crypto: af_alg - ... |
283 |
|
77ebdabe8 crypto: af_alg - ... |
284 285 286 287 288 |
/* * newsock->ops assigned here to allow type->accept call to override * them when required. */ newsock->ops = type->ops; |
03c8efc1f crypto: af_alg - ... |
289 |
err = type->accept(ask->private, sk2); |
37766586c crypto: af_alg - ... |
290 291 292 293 |
nokey = err == -ENOKEY; if (nokey && type->accept_nokey) err = type->accept_nokey(ask->private, sk2); |
a383292c8 crypto: af_alg - ... |
294 |
if (err) |
03c8efc1f crypto: af_alg - ... |
295 |
goto unlock; |
03c8efc1f crypto: af_alg - ... |
296 |
|
34c86f4c4 crypto: af_alg - ... |
297 |
if (atomic_inc_return_relaxed(&ask->refcnt) == 1) |
c840ac6af crypto: af_alg - ... |
298 |
sock_hold(sk); |
34c86f4c4 crypto: af_alg - ... |
299 300 301 302 |
if (nokey) { atomic_inc(&ask->nokey_refcnt); atomic_set(&alg_sk(sk2)->nokey_refcnt, 1); } |
03c8efc1f crypto: af_alg - ... |
303 304 |
alg_sk(sk2)->parent = sk; alg_sk(sk2)->type = type; |
03c8efc1f crypto: af_alg - ... |
305 |
newsock->state = SS_CONNECTED; |
37766586c crypto: af_alg - ... |
306 307 |
if (nokey) newsock->ops = type->ops_nokey; |
03c8efc1f crypto: af_alg - ... |
308 309 310 311 312 313 314 315 |
err = 0; unlock: release_sock(sk); return err; } EXPORT_SYMBOL_GPL(af_alg_accept); |
cdfbabfb2 net: Work around ... |
316 317 |
static int alg_accept(struct socket *sock, struct socket *newsock, int flags, bool kern) |
03c8efc1f crypto: af_alg - ... |
318 |
{ |
cdfbabfb2 net: Work around ... |
319 |
return af_alg_accept(sock->sk, newsock, kern); |
03c8efc1f crypto: af_alg - ... |
320 321 322 323 324 325 326 327 328 329 330 331 |
} static const struct proto_ops alg_proto_ops = { .family = PF_ALG, .owner = THIS_MODULE, .connect = sock_no_connect, .socketpair = sock_no_socketpair, .getname = sock_no_getname, .ioctl = sock_no_ioctl, .listen = sock_no_listen, .shutdown = sock_no_shutdown, |
03c8efc1f crypto: af_alg - ... |
332 333 334 335 |
.mmap = sock_no_mmap, .sendpage = sock_no_sendpage, .sendmsg = sock_no_sendmsg, .recvmsg = sock_no_recvmsg, |
03c8efc1f crypto: af_alg - ... |
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 |
.bind = alg_bind, .release = af_alg_release, .setsockopt = alg_setsockopt, .accept = alg_accept, }; static void alg_sock_destruct(struct sock *sk) { struct alg_sock *ask = alg_sk(sk); alg_do_release(ask->type, ask->private); } static int alg_create(struct net *net, struct socket *sock, int protocol, int kern) { struct sock *sk; int err; if (sock->type != SOCK_SEQPACKET) return -ESOCKTNOSUPPORT; if (protocol != 0) return -EPROTONOSUPPORT; err = -ENOMEM; |
11aa9c28b net: Pass kern fr... |
362 |
sk = sk_alloc(net, PF_ALG, GFP_KERNEL, &alg_proto, kern); |
03c8efc1f crypto: af_alg - ... |
363 364 365 366 367 |
if (!sk) goto out; sock->ops = &alg_proto_ops; sock_init_data(sock, sk); |
03c8efc1f crypto: af_alg - ... |
368 369 370 371 372 373 374 375 376 377 378 379 |
sk->sk_destruct = alg_sock_destruct; return 0; out: return err; } static const struct net_proto_family alg_family = { .family = PF_ALG, .create = alg_create, .owner = THIS_MODULE, }; |
1d10eb2f1 crypto: switch af... |
380 |
int af_alg_make_sg(struct af_alg_sgl *sgl, struct iov_iter *iter, int len) |
03c8efc1f crypto: af_alg - ... |
381 |
{ |
1d10eb2f1 crypto: switch af... |
382 383 384 |
size_t off; ssize_t n; int npages, i; |
03c8efc1f crypto: af_alg - ... |
385 |
|
1d10eb2f1 crypto: switch af... |
386 387 388 |
n = iov_iter_get_pages(iter, sgl->pages, len, ALG_MAX_PAGES, &off); if (n < 0) return n; |
03c8efc1f crypto: af_alg - ... |
389 |
|
9399f0c51 crypto: fix af_al... |
390 |
npages = (off + n + PAGE_SIZE - 1) >> PAGE_SHIFT; |
03c8efc1f crypto: af_alg - ... |
391 |
if (WARN_ON(npages == 0)) |
1d10eb2f1 crypto: switch af... |
392 |
return -EINVAL; |
66db37391 crypto: af_alg - ... |
393 394 |
/* Add one extra for linking */ sg_init_table(sgl->sg, npages + 1); |
03c8efc1f crypto: af_alg - ... |
395 |
|
1d10eb2f1 crypto: switch af... |
396 |
for (i = 0, len = n; i < npages; i++) { |
03c8efc1f crypto: af_alg - ... |
397 398 399 400 401 402 |
int plen = min_t(int, len, PAGE_SIZE - off); sg_set_page(sgl->sg + i, sgl->pages[i], plen, off); off = 0; len -= plen; |
03c8efc1f crypto: af_alg - ... |
403 |
} |
66db37391 crypto: af_alg - ... |
404 405 |
sg_mark_end(sgl->sg + npages - 1); sgl->npages = npages; |
1d10eb2f1 crypto: switch af... |
406 |
return n; |
03c8efc1f crypto: af_alg - ... |
407 408 |
} EXPORT_SYMBOL_GPL(af_alg_make_sg); |
466e07592 crypto: af_alg - ... |
409 410 |
static void af_alg_link_sg(struct af_alg_sgl *sgl_prev, struct af_alg_sgl *sgl_new) |
66db37391 crypto: af_alg - ... |
411 412 413 414 |
{ sg_unmark_end(sgl_prev->sg + sgl_prev->npages - 1); sg_chain(sgl_prev->sg, sgl_prev->npages + 1, sgl_new->sg); } |
66db37391 crypto: af_alg - ... |
415 |
|
03c8efc1f crypto: af_alg - ... |
416 417 418 |
void af_alg_free_sg(struct af_alg_sgl *sgl) { int i; |
66db37391 crypto: af_alg - ... |
419 |
for (i = 0; i < sgl->npages; i++) |
03c8efc1f crypto: af_alg - ... |
420 |
put_page(sgl->pages[i]); |
03c8efc1f crypto: af_alg - ... |
421 422 |
} EXPORT_SYMBOL_GPL(af_alg_free_sg); |
466e07592 crypto: af_alg - ... |
423 |
static int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con) |
03c8efc1f crypto: af_alg - ... |
424 425 |
{ struct cmsghdr *cmsg; |
f95b414ed net: introduce he... |
426 |
for_each_cmsghdr(cmsg, msg) { |
03c8efc1f crypto: af_alg - ... |
427 428 429 430 |
if (!CMSG_OK(msg, cmsg)) return -EINVAL; if (cmsg->cmsg_level != SOL_ALG) continue; |
267c4221f crypto: af_alg - ... |
431 |
switch (cmsg->cmsg_type) { |
03c8efc1f crypto: af_alg - ... |
432 433 434 435 436 437 438 439 440 441 442 443 444 445 |
case ALG_SET_IV: if (cmsg->cmsg_len < CMSG_LEN(sizeof(*con->iv))) return -EINVAL; con->iv = (void *)CMSG_DATA(cmsg); if (cmsg->cmsg_len < CMSG_LEN(con->iv->ivlen + sizeof(*con->iv))) return -EINVAL; break; case ALG_SET_OP: if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32))) return -EINVAL; con->op = *(u32 *)CMSG_DATA(cmsg); break; |
af8e80731 crypto: af_alg - ... |
446 447 448 449 450 |
case ALG_SET_AEAD_ASSOCLEN: if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32))) return -EINVAL; con->aead_assoclen = *(u32 *)CMSG_DATA(cmsg); break; |
03c8efc1f crypto: af_alg - ... |
451 452 453 454 455 456 457 |
default: return -EINVAL; } } return 0; } |
03c8efc1f crypto: af_alg - ... |
458 |
|
2d97591ef crypto: af_alg - ... |
459 460 461 462 463 464 |
/** * af_alg_alloc_tsgl - allocate the TX SGL * * @sk socket of connection to user space * @return: 0 upon success, < 0 upon error */ |
466e07592 crypto: af_alg - ... |
465 |
static int af_alg_alloc_tsgl(struct sock *sk) |
2d97591ef crypto: af_alg - ... |
466 467 468 469 470 471 472 473 474 475 476 |
{ struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_tsgl *sgl; struct scatterlist *sg = NULL; sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl, list); if (!list_empty(&ctx->tsgl_list)) sg = sgl->sg; if (!sg || sgl->cur >= MAX_SGL_ENTS) { |
0ed2dd03b treewide: Use str... |
477 478 |
sgl = sock_kmalloc(sk, struct_size(sgl, sg, (MAX_SGL_ENTS + 1)), |
2d97591ef crypto: af_alg - ... |
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 |
GFP_KERNEL); if (!sgl) return -ENOMEM; sg_init_table(sgl->sg, MAX_SGL_ENTS + 1); sgl->cur = 0; if (sg) sg_chain(sg, MAX_SGL_ENTS + 1, sgl->sg); list_add_tail(&sgl->list, &ctx->tsgl_list); } return 0; } |
2d97591ef crypto: af_alg - ... |
494 495 496 497 498 499 500 501 502 503 504 505 506 507 |
/** * aead_count_tsgl - Count number of TX SG entries * * The counting starts from the beginning of the SGL to @bytes. If * an offset is provided, the counting of the SG entries starts at the offset. * * @sk socket of connection to user space * @bytes Count the number of SG entries holding given number of bytes. * @offset Start the counting of SG entries from the given offset. * @return Number of TX SG entries found given the constraints */ unsigned int af_alg_count_tsgl(struct sock *sk, size_t bytes, size_t offset) { |
7c39edfb0 crypto: af_alg - ... |
508 509 510 |
const struct alg_sock *ask = alg_sk(sk); const struct af_alg_ctx *ctx = ask->private; const struct af_alg_tsgl *sgl; |
2d97591ef crypto: af_alg - ... |
511 512 513 514 515 |
unsigned int i; unsigned int sgl_count = 0; if (!bytes) return 0; |
7c39edfb0 crypto: af_alg - ... |
516 517 |
list_for_each_entry(sgl, &ctx->tsgl_list, list) { const struct scatterlist *sg = sgl->sg; |
2d97591ef crypto: af_alg - ... |
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 |
for (i = 0; i < sgl->cur; i++) { size_t bytes_count; /* Skip offset */ if (offset >= sg[i].length) { offset -= sg[i].length; bytes -= sg[i].length; continue; } bytes_count = sg[i].length - offset; offset = 0; sgl_count++; /* If we have seen requested number of bytes, stop */ if (bytes_count >= bytes) return sgl_count; bytes -= bytes_count; } } return sgl_count; } EXPORT_SYMBOL_GPL(af_alg_count_tsgl); /** * aead_pull_tsgl - Release the specified buffers from TX SGL * * If @dst is non-null, reassign the pages to dst. The caller must release * the pages. If @dst_offset is given only reassign the pages to @dst starting * at the @dst_offset (byte). The caller must ensure that @dst is large * enough (e.g. by using af_alg_count_tsgl with the same offset). * * @sk socket of connection to user space * @used Number of bytes to pull from TX SGL * @dst If non-NULL, buffer is reassigned to dst SGL instead of releasing. The * caller must release the buffers in dst. * @dst_offset Reassign the TX SGL from given offset. All buffers before * reaching the offset is released. */ void af_alg_pull_tsgl(struct sock *sk, size_t used, struct scatterlist *dst, size_t dst_offset) { struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_tsgl *sgl; struct scatterlist *sg; |
e117765a1 crypto: af_alg - ... |
568 |
unsigned int i, j = 0; |
2d97591ef crypto: af_alg - ... |
569 570 571 572 573 |
while (!list_empty(&ctx->tsgl_list)) { sgl = list_first_entry(&ctx->tsgl_list, struct af_alg_tsgl, list); sg = sgl->sg; |
e117765a1 crypto: af_alg - ... |
574 |
for (i = 0; i < sgl->cur; i++) { |
2d97591ef crypto: af_alg - ... |
575 576 577 578 579 580 581 582 583 584 585 586 587 588 |
size_t plen = min_t(size_t, used, sg[i].length); struct page *page = sg_page(sg + i); if (!page) continue; /* * Assumption: caller created af_alg_count_tsgl(len) * SG entries in dst. */ if (dst) { if (dst_offset >= plen) { /* discard page before offset */ dst_offset -= plen; |
2d97591ef crypto: af_alg - ... |
589 590 |
} else { /* reassign page to dst after offset */ |
2d45a7e89 crypto: af_alg - ... |
591 |
get_page(page); |
2d97591ef crypto: af_alg - ... |
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 |
sg_set_page(dst + j, page, plen - dst_offset, sg[i].offset + dst_offset); dst_offset = 0; j++; } } sg[i].length -= plen; sg[i].offset += plen; used -= plen; ctx->used -= plen; if (sg[i].length) return; |
2d45a7e89 crypto: af_alg - ... |
608 |
put_page(page); |
2d97591ef crypto: af_alg - ... |
609 610 611 612 |
sg_assign_page(sg + i, NULL); } list_del(&sgl->list); |
91e14842f crypto: af_alg - ... |
613 |
sock_kfree_s(sk, sgl, struct_size(sgl, sg, MAX_SGL_ENTS + 1)); |
2d97591ef crypto: af_alg - ... |
614 615 616 617 |
} if (!ctx->used) ctx->merge = 0; |
f3c802a1f crypto: algif_aea... |
618 |
ctx->init = ctx->more; |
2d97591ef crypto: af_alg - ... |
619 620 621 622 623 624 625 626 |
} EXPORT_SYMBOL_GPL(af_alg_pull_tsgl); /** * af_alg_free_areq_sgls - Release TX and RX SGLs of the request * * @areq Request holding the TX and RX SGL */ |
466e07592 crypto: af_alg - ... |
627 |
static void af_alg_free_areq_sgls(struct af_alg_async_req *areq) |
2d97591ef crypto: af_alg - ... |
628 629 630 631 632 633 634 635 636 637 |
{ struct sock *sk = areq->sk; struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_rsgl *rsgl, *tmp; struct scatterlist *tsgl; struct scatterlist *sg; unsigned int i; list_for_each_entry_safe(rsgl, tmp, &areq->rsgl_list, list) { |
af955bf15 crypto: af_alg - ... |
638 |
atomic_sub(rsgl->sg_num_bytes, &ctx->rcvused); |
2d97591ef crypto: af_alg - ... |
639 640 641 642 643 644 645 |
af_alg_free_sg(&rsgl->sgl); list_del(&rsgl->list); if (rsgl != &areq->first_rsgl) sock_kfree_s(sk, rsgl, sizeof(*rsgl)); } tsgl = areq->tsgl; |
887207ed9 crypto: af_alg - ... |
646 647 648 649 650 651 |
if (tsgl) { for_each_sg(tsgl, sg, areq->tsgl_entries, i) { if (!sg_page(sg)) continue; put_page(sg_page(sg)); } |
2d97591ef crypto: af_alg - ... |
652 |
|
2d97591ef crypto: af_alg - ... |
653 |
sock_kfree_s(sk, tsgl, areq->tsgl_entries * sizeof(*tsgl)); |
887207ed9 crypto: af_alg - ... |
654 |
} |
2d97591ef crypto: af_alg - ... |
655 |
} |
2d97591ef crypto: af_alg - ... |
656 657 658 659 660 661 662 663 |
/** * af_alg_wait_for_wmem - wait for availability of writable memory * * @sk socket of connection to user space * @flags If MSG_DONTWAIT is set, then only report if function would sleep * @return 0 when writable memory is available, < 0 upon error */ |
466e07592 crypto: af_alg - ... |
664 |
static int af_alg_wait_for_wmem(struct sock *sk, unsigned int flags) |
2d97591ef crypto: af_alg - ... |
665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 |
{ DEFINE_WAIT_FUNC(wait, woken_wake_function); int err = -ERESTARTSYS; long timeout; if (flags & MSG_DONTWAIT) return -EAGAIN; sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk); add_wait_queue(sk_sleep(sk), &wait); for (;;) { if (signal_pending(current)) break; timeout = MAX_SCHEDULE_TIMEOUT; if (sk_wait_event(sk, &timeout, af_alg_writable(sk), &wait)) { err = 0; break; } } remove_wait_queue(sk_sleep(sk), &wait); return err; } |
2d97591ef crypto: af_alg - ... |
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 |
/** * af_alg_wmem_wakeup - wakeup caller when writable memory is available * * @sk socket of connection to user space */ void af_alg_wmem_wakeup(struct sock *sk) { struct socket_wq *wq; if (!af_alg_writable(sk)) return; rcu_read_lock(); wq = rcu_dereference(sk->sk_wq); if (skwq_has_sleeper(wq)) |
a9a08845e vfs: do bulk POLL... |
705 706 707 |
wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLRDNORM | EPOLLRDBAND); |
2d97591ef crypto: af_alg - ... |
708 709 710 711 712 713 714 715 716 717 |
sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN); rcu_read_unlock(); } EXPORT_SYMBOL_GPL(af_alg_wmem_wakeup); /** * af_alg_wait_for_data - wait for availability of TX data * * @sk socket of connection to user space * @flags If MSG_DONTWAIT is set, then only report if function would sleep |
f3c802a1f crypto: algif_aea... |
718 |
* @min Set to minimum request size if partial requests are allowed. |
2d97591ef crypto: af_alg - ... |
719 720 |
* @return 0 when writable memory is available, < 0 upon error */ |
f3c802a1f crypto: algif_aea... |
721 |
int af_alg_wait_for_data(struct sock *sk, unsigned flags, unsigned min) |
2d97591ef crypto: af_alg - ... |
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 |
{ DEFINE_WAIT_FUNC(wait, woken_wake_function); struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; long timeout; int err = -ERESTARTSYS; if (flags & MSG_DONTWAIT) return -EAGAIN; sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk); add_wait_queue(sk_sleep(sk), &wait); for (;;) { if (signal_pending(current)) break; timeout = MAX_SCHEDULE_TIMEOUT; |
f3c802a1f crypto: algif_aea... |
739 740 741 |
if (sk_wait_event(sk, &timeout, ctx->init && (!ctx->more || (min && ctx->used >= min)), |
2d97591ef crypto: af_alg - ... |
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 |
&wait)) { err = 0; break; } } remove_wait_queue(sk_sleep(sk), &wait); sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk); return err; } EXPORT_SYMBOL_GPL(af_alg_wait_for_data); /** * af_alg_data_wakeup - wakeup caller when new data can be sent to kernel * * @sk socket of connection to user space */ |
466e07592 crypto: af_alg - ... |
760 |
static void af_alg_data_wakeup(struct sock *sk) |
2d97591ef crypto: af_alg - ... |
761 762 763 764 765 766 767 768 769 770 771 |
{ struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct socket_wq *wq; if (!ctx->used) return; rcu_read_lock(); wq = rcu_dereference(sk->sk_wq); if (skwq_has_sleeper(wq)) |
a9a08845e vfs: do bulk POLL... |
772 773 774 |
wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT | EPOLLRDNORM | EPOLLRDBAND); |
2d97591ef crypto: af_alg - ... |
775 776 777 |
sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT); rcu_read_unlock(); } |
2d97591ef crypto: af_alg - ... |
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 |
/** * af_alg_sendmsg - implementation of sendmsg system call handler * * The sendmsg system call handler obtains the user data and stores it * in ctx->tsgl_list. This implies allocation of the required numbers of * struct af_alg_tsgl. * * In addition, the ctx is filled with the information sent via CMSG. * * @sock socket of connection to user space * @msg message from user space * @size size of message from user space * @ivsize the size of the IV for the cipher operation to verify that the * user-space-provided IV has the right size * @return the number of copied data upon success, < 0 upon error */ int af_alg_sendmsg(struct socket *sock, struct msghdr *msg, size_t size, unsigned int ivsize) { struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_tsgl *sgl; struct af_alg_control con = {}; long copied = 0; |
fcb90d51c crypto: af_alg - ... |
804 805 |
bool enc = false; bool init = false; |
2d97591ef crypto: af_alg - ... |
806 807 808 809 810 811 |
int err = 0; if (msg->msg_controllen) { err = af_alg_cmsg_send(msg, &con); if (err) return err; |
fcb90d51c crypto: af_alg - ... |
812 |
init = true; |
2d97591ef crypto: af_alg - ... |
813 814 |
switch (con.op) { case ALG_OP_ENCRYPT: |
fcb90d51c crypto: af_alg - ... |
815 |
enc = true; |
2d97591ef crypto: af_alg - ... |
816 817 |
break; case ALG_OP_DECRYPT: |
fcb90d51c crypto: af_alg - ... |
818 |
enc = false; |
2d97591ef crypto: af_alg - ... |
819 820 821 822 823 824 825 826 827 828 |
break; default: return -EINVAL; } if (con.iv && con.iv->ivlen != ivsize) return -EINVAL; } lock_sock(sk); |
c195d66a8 crypto: af_alg - ... |
829 830 831 832 833 834 835 836 837 838 |
if (ctx->init && !ctx->more) { if (ctx->used) { err = -EINVAL; goto unlock; } pr_info_once( "%s sent an empty control message without MSG_MORE. ", current->comm); |
2d97591ef crypto: af_alg - ... |
839 |
} |
662bb52f5 crypto: af_alg - ... |
840 |
ctx->init = true; |
2d97591ef crypto: af_alg - ... |
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 |
if (init) { ctx->enc = enc; if (con.iv) memcpy(ctx->iv, con.iv->iv, ivsize); ctx->aead_assoclen = con.aead_assoclen; } while (size) { struct scatterlist *sg; size_t len = size; size_t plen; /* use the existing memory in an allocated page */ if (ctx->merge) { sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl, list); sg = sgl->sg + sgl->cur - 1; len = min_t(size_t, len, PAGE_SIZE - sg->offset - sg->length); err = memcpy_from_msg(page_address(sg_page(sg)) + sg->offset + sg->length, msg, len); if (err) goto unlock; sg->length += len; ctx->merge = (sg->offset + sg->length) & (PAGE_SIZE - 1); ctx->used += len; copied += len; size -= len; continue; } if (!af_alg_writable(sk)) { err = af_alg_wait_for_wmem(sk, msg->msg_flags); if (err) goto unlock; } /* allocate a new page */ len = min_t(unsigned long, len, af_alg_sndbuf(sk)); err = af_alg_alloc_tsgl(sk); if (err) goto unlock; sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl, list); sg = sgl->sg; if (sgl->cur) sg_unmark_end(sg + sgl->cur - 1); do { unsigned int i = sgl->cur; plen = min_t(size_t, len, PAGE_SIZE); sg_assign_page(sg + i, alloc_page(GFP_KERNEL)); if (!sg_page(sg + i)) { err = -ENOMEM; goto unlock; } err = memcpy_from_msg(page_address(sg_page(sg + i)), msg, plen); if (err) { __free_page(sg_page(sg + i)); sg_assign_page(sg + i, NULL); goto unlock; } sg[i].length = plen; len -= plen; ctx->used += plen; copied += plen; size -= plen; sgl->cur++; } while (len && sgl->cur < MAX_SGL_ENTS); if (!size) sg_mark_end(sg + sgl->cur - 1); ctx->merge = plen & (PAGE_SIZE - 1); } err = 0; ctx->more = msg->msg_flags & MSG_MORE; unlock: af_alg_data_wakeup(sk); release_sock(sk); return copied ?: err; } EXPORT_SYMBOL_GPL(af_alg_sendmsg); /** * af_alg_sendpage - sendpage system call handler * * This is a generic implementation of sendpage to fill ctx->tsgl_list. */ ssize_t af_alg_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags) { struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_tsgl *sgl; int err = -EINVAL; if (flags & MSG_SENDPAGE_NOTLAST) flags |= MSG_MORE; lock_sock(sk); if (!ctx->more && ctx->used) goto unlock; if (!size) goto done; if (!af_alg_writable(sk)) { err = af_alg_wait_for_wmem(sk, flags); if (err) goto unlock; } err = af_alg_alloc_tsgl(sk); if (err) goto unlock; ctx->merge = 0; sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl, list); if (sgl->cur) sg_unmark_end(sgl->sg + sgl->cur - 1); sg_mark_end(sgl->sg + sgl->cur); get_page(page); sg_set_page(sgl->sg + sgl->cur, page, size, offset); sgl->cur++; ctx->used += size; done: ctx->more = flags & MSG_MORE; unlock: af_alg_data_wakeup(sk); release_sock(sk); return err ?: size; } EXPORT_SYMBOL_GPL(af_alg_sendpage); /** |
7d2c3f54e crypto: af_alg - ... |
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 |
* af_alg_free_resources - release resources required for crypto request */ void af_alg_free_resources(struct af_alg_async_req *areq) { struct sock *sk = areq->sk; af_alg_free_areq_sgls(areq); sock_kfree_s(sk, areq, areq->areqlen); } EXPORT_SYMBOL_GPL(af_alg_free_resources); /** |
2d97591ef crypto: af_alg - ... |
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 |
* af_alg_async_cb - AIO callback handler * * This handler cleans up the struct af_alg_async_req upon completion of the * AIO operation. * * The number of bytes to be generated with the AIO operation must be set * in areq->outlen before the AIO callback handler is invoked. */ void af_alg_async_cb(struct crypto_async_request *_req, int err) { struct af_alg_async_req *areq = _req->data; struct sock *sk = areq->sk; struct kiocb *iocb = areq->iocb; unsigned int resultlen; |
2d97591ef crypto: af_alg - ... |
1028 1029 |
/* Buffer size written by crypto operation. */ resultlen = areq->outlen; |
7d2c3f54e crypto: af_alg - ... |
1030 1031 |
af_alg_free_resources(areq); sock_put(sk); |
2d97591ef crypto: af_alg - ... |
1032 |
|
64e7f852c crypto: af_alg - ... |
1033 |
iocb->ki_complete(iocb, err ? err : (int)resultlen, 0); |
2d97591ef crypto: af_alg - ... |
1034 1035 |
} EXPORT_SYMBOL_GPL(af_alg_async_cb); |
a11e1d432 Revert changes to... |
1036 1037 1038 1039 1040 |
/** * af_alg_poll - poll system call handler */ __poll_t af_alg_poll(struct file *file, struct socket *sock, poll_table *wait) |
2d97591ef crypto: af_alg - ... |
1041 1042 1043 1044 |
{ struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; |
a11e1d432 Revert changes to... |
1045 |
__poll_t mask; |
89ab066d4 Revert "net: simp... |
1046 |
sock_poll_wait(file, sock, wait); |
a11e1d432 Revert changes to... |
1047 |
mask = 0; |
2d97591ef crypto: af_alg - ... |
1048 1049 |
if (!ctx->more || ctx->used) |
a9a08845e vfs: do bulk POLL... |
1050 |
mask |= EPOLLIN | EPOLLRDNORM; |
2d97591ef crypto: af_alg - ... |
1051 1052 |
if (af_alg_writable(sk)) |
a9a08845e vfs: do bulk POLL... |
1053 |
mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND; |
2d97591ef crypto: af_alg - ... |
1054 1055 1056 |
return mask; } |
a11e1d432 Revert changes to... |
1057 |
EXPORT_SYMBOL_GPL(af_alg_poll); |
2d97591ef crypto: af_alg - ... |
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 |
/** * af_alg_alloc_areq - allocate struct af_alg_async_req * * @sk socket of connection to user space * @areqlen size of struct af_alg_async_req + crypto_*_reqsize * @return allocated data structure or ERR_PTR upon error */ struct af_alg_async_req *af_alg_alloc_areq(struct sock *sk, unsigned int areqlen) { struct af_alg_async_req *areq = sock_kmalloc(sk, areqlen, GFP_KERNEL); if (unlikely(!areq)) return ERR_PTR(-ENOMEM); areq->areqlen = areqlen; areq->sk = sk; areq->last_rsgl = NULL; INIT_LIST_HEAD(&areq->rsgl_list); areq->tsgl = NULL; areq->tsgl_entries = 0; return areq; } EXPORT_SYMBOL_GPL(af_alg_alloc_areq); /** * af_alg_get_rsgl - create the RX SGL for the output data from the crypto * operation * * @sk socket of connection to user space * @msg user space message * @flags flags used to invoke recvmsg with * @areq instance of the cryptographic request that will hold the RX SGL * @maxsize maximum number of bytes to be pulled from user space * @outlen number of bytes in the RX SGL * @return 0 on success, < 0 upon error */ int af_alg_get_rsgl(struct sock *sk, struct msghdr *msg, int flags, struct af_alg_async_req *areq, size_t maxsize, size_t *outlen) { struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; size_t len = 0; while (maxsize > len && msg_data_left(msg)) { struct af_alg_rsgl *rsgl; size_t seglen; int err; /* limit the amount of readable buffers */ if (!af_alg_readable(sk)) break; |
2d97591ef crypto: af_alg - ... |
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 |
seglen = min_t(size_t, (maxsize - len), msg_data_left(msg)); if (list_empty(&areq->rsgl_list)) { rsgl = &areq->first_rsgl; } else { rsgl = sock_kmalloc(sk, sizeof(*rsgl), GFP_KERNEL); if (unlikely(!rsgl)) return -ENOMEM; } rsgl->sgl.npages = 0; list_add_tail(&rsgl->list, &areq->rsgl_list); /* make one iovec available as scatterlist */ err = af_alg_make_sg(&rsgl->sgl, &msg->msg_iter, seglen); |
2546da992 crypto: af_alg - ... |
1129 1130 |
if (err < 0) { rsgl->sg_num_bytes = 0; |
2d97591ef crypto: af_alg - ... |
1131 |
return err; |
2546da992 crypto: af_alg - ... |
1132 |
} |
2d97591ef crypto: af_alg - ... |
1133 1134 1135 1136 1137 1138 1139 |
/* chain the new scatterlist with previous one */ if (areq->last_rsgl) af_alg_link_sg(&areq->last_rsgl->sgl, &rsgl->sgl); areq->last_rsgl = rsgl; len += err; |
af955bf15 crypto: af_alg - ... |
1140 |
atomic_add(err, &ctx->rcvused); |
2d97591ef crypto: af_alg - ... |
1141 1142 1143 1144 1145 1146 1147 1148 |
rsgl->sg_num_bytes = err; iov_iter_advance(&msg->msg_iter, err); } *outlen = len; return 0; } EXPORT_SYMBOL_GPL(af_alg_get_rsgl); |
03c8efc1f crypto: af_alg - ... |
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 |
static int __init af_alg_init(void) { int err = proto_register(&alg_proto, 0); if (err) goto out; err = sock_register(&alg_family); if (err != 0) goto out_unregister_proto; out: return err; out_unregister_proto: proto_unregister(&alg_proto); goto out; } static void __exit af_alg_exit(void) { sock_unregister(PF_ALG); proto_unregister(&alg_proto); } module_init(af_alg_init); module_exit(af_alg_exit); MODULE_LICENSE("GPL"); MODULE_ALIAS_NETPROTO(AF_ALG); |