1 /* 2 * af_alg: User-space algorithm interface 3 * 4 * This file provides the user-space API for algorithms. 5 * 6 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the Free 10 * Software Foundation; either version 2 of the License, or (at your option) 11 * any later version. 12 * 13 */ 14 15 #include <linux/atomic.h> 16 #include <crypto/if_alg.h> 17 #include <linux/crypto.h> 18 #include <linux/init.h> 19 #include <linux/kernel.h> 20 #include <linux/list.h> 21 #include <linux/module.h> 22 #include <linux/net.h> 23 #include <linux/rwsem.h> 24 #include <linux/security.h> 25 26 struct alg_type_list { 27 const struct af_alg_type *type; 28 struct list_head list; 29 }; 30 31 static atomic_long_t alg_memory_allocated; 32 33 static struct proto alg_proto = { 34 .name = "ALG", 35 .owner = THIS_MODULE, 36 .memory_allocated = &alg_memory_allocated, 37 .obj_size = sizeof(struct alg_sock), 38 }; 39 40 static LIST_HEAD(alg_types); 41 static DECLARE_RWSEM(alg_types_sem); 42 43 static const struct af_alg_type *alg_get_type(const char *name) 44 { 45 const struct af_alg_type *type = ERR_PTR(-ENOENT); 46 struct alg_type_list *node; 47 48 down_read(&alg_types_sem); 49 list_for_each_entry(node, &alg_types, list) { 50 if (strcmp(node->type->name, name)) 51 continue; 52 53 if (try_module_get(node->type->owner)) 54 type = node->type; 55 break; 56 } 57 up_read(&alg_types_sem); 58 59 return type; 60 } 61 62 int af_alg_register_type(const struct af_alg_type *type) 63 { 64 struct alg_type_list *node; 65 int err = -EEXIST; 66 67 down_write(&alg_types_sem); 68 list_for_each_entry(node, &alg_types, list) { 69 if (!strcmp(node->type->name, type->name)) 70 goto unlock; 71 } 72 73 node = kmalloc(sizeof(*node), GFP_KERNEL); 74 err = -ENOMEM; 75 if (!node) 76 goto unlock; 77 78 type->ops->owner = THIS_MODULE; 79 node->type = type; 80 list_add(&node->list, &alg_types); 81 err = 0; 82 83 unlock: 84 up_write(&alg_types_sem); 85 86 return err; 87 } 88 EXPORT_SYMBOL_GPL(af_alg_register_type); 89 90 int af_alg_unregister_type(const struct af_alg_type *type) 91 { 92 struct alg_type_list *node; 93 int err = -ENOENT; 94 95 down_write(&alg_types_sem); 96 list_for_each_entry(node, &alg_types, list) { 97 if (strcmp(node->type->name, type->name)) 98 continue; 99 100 list_del(&node->list); 101 kfree(node); 102 err = 0; 103 break; 104 } 105 up_write(&alg_types_sem); 106 107 return err; 108 } 109 EXPORT_SYMBOL_GPL(af_alg_unregister_type); 110 111 static void alg_do_release(const struct af_alg_type *type, void *private) 112 { 113 if (!type) 114 return; 115 116 type->release(private); 117 module_put(type->owner); 118 } 119 120 int af_alg_release(struct socket *sock) 121 { 122 if (sock->sk) 123 sock_put(sock->sk); 124 return 0; 125 } 126 EXPORT_SYMBOL_GPL(af_alg_release); 127 128 static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 129 { 130 struct sock *sk = sock->sk; 131 struct alg_sock *ask = alg_sk(sk); 132 struct sockaddr_alg *sa = (void *)uaddr; 133 const struct af_alg_type *type; 134 void *private; 135 136 if (sock->state == SS_CONNECTED) 137 return -EINVAL; 138 139 if (addr_len != sizeof(*sa)) 140 return -EINVAL; 141 142 sa->salg_type[sizeof(sa->salg_type) - 1] = 0; 143 sa->salg_name[sizeof(sa->salg_name) - 1] = 0; 144 145 type = alg_get_type(sa->salg_type); 146 if (IS_ERR(type) && PTR_ERR(type) == -ENOENT) { 147 request_module("algif-%s", sa->salg_type); 148 type = alg_get_type(sa->salg_type); 149 } 150 151 if (IS_ERR(type)) 152 return PTR_ERR(type); 153 154 private = type->bind(sa->salg_name, sa->salg_feat, sa->salg_mask); 155 if (IS_ERR(private)) { 156 module_put(type->owner); 157 return PTR_ERR(private); 158 } 159 160 lock_sock(sk); 161 162 swap(ask->type, type); 163 swap(ask->private, private); 164 165 release_sock(sk); 166 167 alg_do_release(type, private); 168 169 return 0; 170 } 171 172 static int alg_setkey(struct sock *sk, char __user *ukey, 173 unsigned int keylen) 174 { 175 struct alg_sock *ask = alg_sk(sk); 176 const struct af_alg_type *type = ask->type; 177 u8 *key; 178 int err; 179 180 key = sock_kmalloc(sk, keylen, GFP_KERNEL); 181 if (!key) 182 return -ENOMEM; 183 184 err = -EFAULT; 185 if (copy_from_user(key, ukey, keylen)) 186 goto out; 187 188 err = type->setkey(ask->private, key, keylen); 189 190 out: 191 sock_kzfree_s(sk, key, keylen); 192 193 return err; 194 } 195 196 static int alg_setsockopt(struct socket *sock, int level, int optname, 197 char __user *optval, unsigned int optlen) 198 { 199 struct sock *sk = sock->sk; 200 struct alg_sock *ask = alg_sk(sk); 201 const struct af_alg_type *type; 202 int err = -ENOPROTOOPT; 203 204 lock_sock(sk); 205 type = ask->type; 206 207 if (level != SOL_ALG || !type) 208 goto unlock; 209 210 switch (optname) { 211 case ALG_SET_KEY: 212 if (sock->state == SS_CONNECTED) 213 goto unlock; 214 if (!type->setkey) 215 goto unlock; 216 217 err = alg_setkey(sk, optval, optlen); 218 break; 219 case ALG_SET_AEAD_AUTHSIZE: 220 if (sock->state == SS_CONNECTED) 221 goto unlock; 222 if (!type->setauthsize) 223 goto unlock; 224 err = type->setauthsize(ask->private, optlen); 225 } 226 227 unlock: 228 release_sock(sk); 229 230 return err; 231 } 232 233 int af_alg_accept(struct sock *sk, struct socket *newsock) 234 { 235 struct alg_sock *ask = alg_sk(sk); 236 const struct af_alg_type *type; 237 struct sock *sk2; 238 int err; 239 240 lock_sock(sk); 241 type = ask->type; 242 243 err = -EINVAL; 244 if (!type) 245 goto unlock; 246 247 sk2 = sk_alloc(sock_net(sk), PF_ALG, GFP_KERNEL, &alg_proto); 248 err = -ENOMEM; 249 if (!sk2) 250 goto unlock; 251 252 sock_init_data(newsock, sk2); 253 sock_graft(sk2, newsock); 254 security_sk_clone(sk, sk2); 255 256 err = type->accept(ask->private, sk2); 257 if (err) { 258 sk_free(sk2); 259 goto unlock; 260 } 261 262 sk2->sk_family = PF_ALG; 263 264 sock_hold(sk); 265 alg_sk(sk2)->parent = sk; 266 alg_sk(sk2)->type = type; 267 268 newsock->ops = type->ops; 269 newsock->state = SS_CONNECTED; 270 271 err = 0; 272 273 unlock: 274 release_sock(sk); 275 276 return err; 277 } 278 EXPORT_SYMBOL_GPL(af_alg_accept); 279 280 static int alg_accept(struct socket *sock, struct socket *newsock, int flags) 281 { 282 return af_alg_accept(sock->sk, newsock); 283 } 284 285 static const struct proto_ops alg_proto_ops = { 286 .family = PF_ALG, 287 .owner = THIS_MODULE, 288 289 .connect = sock_no_connect, 290 .socketpair = sock_no_socketpair, 291 .getname = sock_no_getname, 292 .ioctl = sock_no_ioctl, 293 .listen = sock_no_listen, 294 .shutdown = sock_no_shutdown, 295 .getsockopt = sock_no_getsockopt, 296 .mmap = sock_no_mmap, 297 .sendpage = sock_no_sendpage, 298 .sendmsg = sock_no_sendmsg, 299 .recvmsg = sock_no_recvmsg, 300 .poll = sock_no_poll, 301 302 .bind = alg_bind, 303 .release = af_alg_release, 304 .setsockopt = alg_setsockopt, 305 .accept = alg_accept, 306 }; 307 308 static void alg_sock_destruct(struct sock *sk) 309 { 310 struct alg_sock *ask = alg_sk(sk); 311 312 alg_do_release(ask->type, ask->private); 313 } 314 315 static int alg_create(struct net *net, struct socket *sock, int protocol, 316 int kern) 317 { 318 struct sock *sk; 319 int err; 320 321 if (sock->type != SOCK_SEQPACKET) 322 return -ESOCKTNOSUPPORT; 323 if (protocol != 0) 324 return -EPROTONOSUPPORT; 325 326 err = -ENOMEM; 327 sk = sk_alloc(net, PF_ALG, GFP_KERNEL, &alg_proto); 328 if (!sk) 329 goto out; 330 331 sock->ops = &alg_proto_ops; 332 sock_init_data(sock, sk); 333 334 sk->sk_family = PF_ALG; 335 sk->sk_destruct = alg_sock_destruct; 336 337 return 0; 338 out: 339 return err; 340 } 341 342 static const struct net_proto_family alg_family = { 343 .family = PF_ALG, 344 .create = alg_create, 345 .owner = THIS_MODULE, 346 }; 347 348 int af_alg_make_sg(struct af_alg_sgl *sgl, struct iov_iter *iter, int len) 349 { 350 size_t off; 351 ssize_t n; 352 int npages, i; 353 354 n = iov_iter_get_pages(iter, sgl->pages, len, ALG_MAX_PAGES, &off); 355 if (n < 0) 356 return n; 357 358 npages = (off + n + PAGE_SIZE - 1) >> PAGE_SHIFT; 359 if (WARN_ON(npages == 0)) 360 return -EINVAL; 361 /* Add one extra for linking */ 362 sg_init_table(sgl->sg, npages + 1); 363 364 for (i = 0, len = n; i < npages; i++) { 365 int plen = min_t(int, len, PAGE_SIZE - off); 366 367 sg_set_page(sgl->sg + i, sgl->pages[i], plen, off); 368 369 off = 0; 370 len -= plen; 371 } 372 sg_mark_end(sgl->sg + npages - 1); 373 sgl->npages = npages; 374 375 return n; 376 } 377 EXPORT_SYMBOL_GPL(af_alg_make_sg); 378 379 void af_alg_link_sg(struct af_alg_sgl *sgl_prev, struct af_alg_sgl *sgl_new) 380 { 381 sg_unmark_end(sgl_prev->sg + sgl_prev->npages - 1); 382 sg_chain(sgl_prev->sg, sgl_prev->npages + 1, sgl_new->sg); 383 } 384 EXPORT_SYMBOL_GPL(af_alg_link_sg); 385 386 void af_alg_free_sg(struct af_alg_sgl *sgl) 387 { 388 int i; 389 390 for (i = 0; i < sgl->npages; i++) 391 put_page(sgl->pages[i]); 392 } 393 EXPORT_SYMBOL_GPL(af_alg_free_sg); 394 395 int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con) 396 { 397 struct cmsghdr *cmsg; 398 399 for_each_cmsghdr(cmsg, msg) { 400 if (!CMSG_OK(msg, cmsg)) 401 return -EINVAL; 402 if (cmsg->cmsg_level != SOL_ALG) 403 continue; 404 405 switch (cmsg->cmsg_type) { 406 case ALG_SET_IV: 407 if (cmsg->cmsg_len < CMSG_LEN(sizeof(*con->iv))) 408 return -EINVAL; 409 con->iv = (void *)CMSG_DATA(cmsg); 410 if (cmsg->cmsg_len < CMSG_LEN(con->iv->ivlen + 411 sizeof(*con->iv))) 412 return -EINVAL; 413 break; 414 415 case ALG_SET_OP: 416 if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32))) 417 return -EINVAL; 418 con->op = *(u32 *)CMSG_DATA(cmsg); 419 break; 420 421 case ALG_SET_AEAD_ASSOCLEN: 422 if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32))) 423 return -EINVAL; 424 con->aead_assoclen = *(u32 *)CMSG_DATA(cmsg); 425 break; 426 427 default: 428 return -EINVAL; 429 } 430 } 431 432 return 0; 433 } 434 EXPORT_SYMBOL_GPL(af_alg_cmsg_send); 435 436 int af_alg_wait_for_completion(int err, struct af_alg_completion *completion) 437 { 438 switch (err) { 439 case -EINPROGRESS: 440 case -EBUSY: 441 wait_for_completion(&completion->completion); 442 reinit_completion(&completion->completion); 443 err = completion->err; 444 break; 445 }; 446 447 return err; 448 } 449 EXPORT_SYMBOL_GPL(af_alg_wait_for_completion); 450 451 void af_alg_complete(struct crypto_async_request *req, int err) 452 { 453 struct af_alg_completion *completion = req->data; 454 455 if (err == -EINPROGRESS) 456 return; 457 458 completion->err = err; 459 complete(&completion->completion); 460 } 461 EXPORT_SYMBOL_GPL(af_alg_complete); 462 463 static int __init af_alg_init(void) 464 { 465 int err = proto_register(&alg_proto, 0); 466 467 if (err) 468 goto out; 469 470 err = sock_register(&alg_family); 471 if (err != 0) 472 goto out_unregister_proto; 473 474 out: 475 return err; 476 477 out_unregister_proto: 478 proto_unregister(&alg_proto); 479 goto out; 480 } 481 482 static void __exit af_alg_exit(void) 483 { 484 sock_unregister(PF_ALG); 485 proto_unregister(&alg_proto); 486 } 487 488 module_init(af_alg_init); 489 module_exit(af_alg_exit); 490 MODULE_LICENSE("GPL"); 491 MODULE_ALIAS_NETPROTO(AF_ALG); 492