1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * algif_hash: User-space interface for hash algorithms 4 * 5 * This file provides the user-space API for hash algorithms. 6 * 7 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au> 8 */ 9 10 #include <crypto/hash.h> 11 #include <crypto/if_alg.h> 12 #include <linux/init.h> 13 #include <linux/kernel.h> 14 #include <linux/mm.h> 15 #include <linux/module.h> 16 #include <linux/net.h> 17 #include <net/sock.h> 18 19 static const struct af_alg_allowlist_entry hash_allowlist[] = { 20 { "cmac(aes)", true }, /* iwd, bluez */ 21 { "hmac(md5)", true }, /* iwd */ 22 { "hmac(sha1)", true }, /* iwd */ 23 { "hmac(sha224)", true }, /* iwd */ 24 { "hmac(sha256)", true }, /* iwd */ 25 { "hmac(sha384)", true }, /* iwd */ 26 { "hmac(sha512)", true }, /* iwd, sha512hmac */ 27 { "md4", true }, /* iwd */ 28 { "md5", true }, /* iwd */ 29 { "sha1", false }, /* iwd, iproute2 < 7.0 */ 30 { "sha224", true }, /* iwd */ 31 { "sha256", true }, /* iwd */ 32 { "sha384", true }, /* iwd */ 33 { "sha512", true }, /* iwd */ 34 {}, 35 }; 36 37 struct hash_ctx { 38 struct af_alg_sgl sgl; 39 40 u8 *result; 41 42 struct crypto_wait wait; 43 44 unsigned int len; 45 bool more; 46 47 struct ahash_request req; 48 }; 49 50 static int hash_alloc_result(struct sock *sk, struct hash_ctx *ctx) 51 { 52 unsigned ds; 53 54 if (ctx->result) 55 return 0; 56 57 ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); 58 59 ctx->result = sock_kmalloc(sk, ds, GFP_KERNEL); 60 if (!ctx->result) 61 return -ENOMEM; 62 63 memset(ctx->result, 0, ds); 64 65 return 0; 66 } 67 68 static void hash_free_result(struct sock *sk, struct hash_ctx *ctx) 69 { 70 unsigned ds; 71 72 if (!ctx->result) 73 return; 74 75 ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); 76 77 sock_kzfree_s(sk, ctx->result, ds); 78 ctx->result = NULL; 79 } 80 81 static int hash_sendmsg(struct socket *sock, struct msghdr *msg, 82 size_t ignored) 83 { 84 struct sock *sk = sock->sk; 85 struct alg_sock *ask = alg_sk(sk); 86 struct hash_ctx *ctx = ask->private; 87 ssize_t copied = 0; 88 size_t len, max_pages, npages; 89 bool continuing, need_init = false; 90 int err; 91 92 max_pages = min_t(size_t, ALG_MAX_PAGES, 93 DIV_ROUND_UP(sk->sk_sndbuf, PAGE_SIZE)); 94 95 lock_sock(sk); 96 continuing = ctx->more; 97 98 if (!continuing) { 99 /* Discard a previous request that wasn't marked MSG_MORE. */ 100 hash_free_result(sk, ctx); 101 if (!msg_data_left(msg)) 102 goto done; /* Zero-length; don't start new req */ 103 need_init = true; 104 } else if (!msg_data_left(msg)) { 105 /* 106 * No data - finalise the prev req if MSG_MORE so any error 107 * comes out here. 108 */ 109 if (!(msg->msg_flags & MSG_MORE)) { 110 err = hash_alloc_result(sk, ctx); 111 if (err) 112 goto unlock_free_result; 113 ahash_request_set_crypt(&ctx->req, NULL, 114 ctx->result, 0); 115 err = crypto_wait_req(crypto_ahash_final(&ctx->req), 116 &ctx->wait); 117 if (err) 118 goto unlock_free_result; 119 } 120 goto done_more; 121 } 122 123 while (msg_data_left(msg)) { 124 ctx->sgl.sgt.sgl = ctx->sgl.sgl; 125 ctx->sgl.sgt.nents = 0; 126 ctx->sgl.sgt.orig_nents = 0; 127 128 err = -EIO; 129 npages = iov_iter_npages(&msg->msg_iter, max_pages); 130 if (npages == 0) 131 goto unlock_free; 132 133 sg_init_table(ctx->sgl.sgl, npages); 134 135 ctx->sgl.need_unpin = iov_iter_extract_will_pin(&msg->msg_iter); 136 137 err = extract_iter_to_sg(&msg->msg_iter, LONG_MAX, 138 &ctx->sgl.sgt, npages, 0); 139 if (err < 0) 140 goto unlock_free; 141 len = err; 142 sg_mark_end(ctx->sgl.sgt.sgl + ctx->sgl.sgt.nents - 1); 143 144 if (!msg_data_left(msg)) { 145 err = hash_alloc_result(sk, ctx); 146 if (err) 147 goto unlock_free; 148 } 149 150 ahash_request_set_crypt(&ctx->req, ctx->sgl.sgt.sgl, 151 ctx->result, len); 152 153 if (!msg_data_left(msg) && !continuing && 154 !(msg->msg_flags & MSG_MORE)) { 155 err = crypto_ahash_digest(&ctx->req); 156 } else { 157 if (need_init) { 158 err = crypto_wait_req( 159 crypto_ahash_init(&ctx->req), 160 &ctx->wait); 161 if (err) 162 goto unlock_free; 163 need_init = false; 164 } 165 166 if (msg_data_left(msg) || (msg->msg_flags & MSG_MORE)) 167 err = crypto_ahash_update(&ctx->req); 168 else 169 err = crypto_ahash_finup(&ctx->req); 170 continuing = true; 171 } 172 173 err = crypto_wait_req(err, &ctx->wait); 174 if (err) 175 goto unlock_free; 176 177 copied += len; 178 af_alg_free_sg(&ctx->sgl); 179 } 180 181 done_more: 182 ctx->more = msg->msg_flags & MSG_MORE; 183 done: 184 err = 0; 185 unlock: 186 release_sock(sk); 187 return copied ?: err; 188 189 unlock_free: 190 af_alg_free_sg(&ctx->sgl); 191 unlock_free_result: 192 hash_free_result(sk, ctx); 193 ctx->more = false; 194 goto unlock; 195 } 196 197 static int hash_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, 198 int flags) 199 { 200 struct sock *sk = sock->sk; 201 struct alg_sock *ask = alg_sk(sk); 202 struct hash_ctx *ctx = ask->private; 203 unsigned ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); 204 bool result; 205 int err; 206 207 if (len > ds) 208 len = ds; 209 else if (len < ds) 210 msg->msg_flags |= MSG_TRUNC; 211 212 lock_sock(sk); 213 result = ctx->result; 214 err = hash_alloc_result(sk, ctx); 215 if (err) 216 goto unlock; 217 218 ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0); 219 220 if (!result && !ctx->more) { 221 err = crypto_wait_req(crypto_ahash_init(&ctx->req), 222 &ctx->wait); 223 if (err) 224 goto unlock; 225 } 226 227 if (!result || ctx->more) { 228 ctx->more = false; 229 err = crypto_wait_req(crypto_ahash_final(&ctx->req), 230 &ctx->wait); 231 if (err) 232 goto unlock; 233 } 234 235 err = memcpy_to_msg(msg, ctx->result, len); 236 237 unlock: 238 hash_free_result(sk, ctx); 239 release_sock(sk); 240 241 return err ?: len; 242 } 243 244 static int hash_accept(struct socket *sock, struct socket *newsock, 245 struct proto_accept_arg *arg) 246 { 247 struct sock *sk = sock->sk; 248 struct alg_sock *ask = alg_sk(sk); 249 struct hash_ctx *ctx = ask->private; 250 struct ahash_request *req = &ctx->req; 251 struct crypto_ahash *tfm; 252 struct sock *sk2; 253 struct alg_sock *ask2; 254 struct hash_ctx *ctx2; 255 char *state; 256 bool more; 257 int err; 258 259 tfm = crypto_ahash_reqtfm(req); 260 state = kmalloc(crypto_ahash_statesize(tfm), GFP_KERNEL); 261 err = -ENOMEM; 262 if (!state) 263 goto out; 264 265 lock_sock(sk); 266 more = ctx->more; 267 err = more ? crypto_ahash_export(req, state) : 0; 268 release_sock(sk); 269 270 if (err) 271 goto out_free_state; 272 273 err = af_alg_accept(ask->parent, newsock, arg); 274 if (err) 275 goto out_free_state; 276 277 sk2 = newsock->sk; 278 ask2 = alg_sk(sk2); 279 ctx2 = ask2->private; 280 ctx2->more = more; 281 282 if (!more) 283 goto out_free_state; 284 285 err = crypto_ahash_import(&ctx2->req, state); 286 287 out_free_state: 288 kfree_sensitive(state); 289 290 out: 291 return err; 292 } 293 294 static struct proto_ops algif_hash_ops = { 295 .family = PF_ALG, 296 297 .connect = sock_no_connect, 298 .socketpair = sock_no_socketpair, 299 .getname = sock_no_getname, 300 .ioctl = sock_no_ioctl, 301 .listen = sock_no_listen, 302 .shutdown = sock_no_shutdown, 303 .mmap = sock_no_mmap, 304 .bind = sock_no_bind, 305 306 .release = af_alg_release, 307 .sendmsg = hash_sendmsg, 308 .recvmsg = hash_recvmsg, 309 .accept = hash_accept, 310 }; 311 312 static int hash_check_key(struct socket *sock) 313 { 314 int err = 0; 315 struct sock *psk; 316 struct alg_sock *pask; 317 struct crypto_ahash *tfm; 318 struct sock *sk = sock->sk; 319 struct alg_sock *ask = alg_sk(sk); 320 321 lock_sock(sk); 322 if (!atomic_read(&ask->nokey_refcnt)) 323 goto unlock_child; 324 325 psk = ask->parent; 326 pask = alg_sk(ask->parent); 327 tfm = pask->private; 328 329 err = -ENOKEY; 330 lock_sock_nested(psk, SINGLE_DEPTH_NESTING); 331 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) 332 goto unlock; 333 334 atomic_dec(&pask->nokey_refcnt); 335 atomic_set(&ask->nokey_refcnt, 0); 336 337 err = 0; 338 339 unlock: 340 release_sock(psk); 341 unlock_child: 342 release_sock(sk); 343 344 return err; 345 } 346 347 static int hash_sendmsg_nokey(struct socket *sock, struct msghdr *msg, 348 size_t size) 349 { 350 int err; 351 352 err = hash_check_key(sock); 353 if (err) 354 return err; 355 356 return hash_sendmsg(sock, msg, size); 357 } 358 359 static int hash_recvmsg_nokey(struct socket *sock, struct msghdr *msg, 360 size_t ignored, int flags) 361 { 362 int err; 363 364 err = hash_check_key(sock); 365 if (err) 366 return err; 367 368 return hash_recvmsg(sock, msg, ignored, flags); 369 } 370 371 static int hash_accept_nokey(struct socket *sock, struct socket *newsock, 372 struct proto_accept_arg *arg) 373 { 374 int err; 375 376 err = hash_check_key(sock); 377 if (err) 378 return err; 379 380 return hash_accept(sock, newsock, arg); 381 } 382 383 static struct proto_ops algif_hash_ops_nokey = { 384 .family = PF_ALG, 385 386 .connect = sock_no_connect, 387 .socketpair = sock_no_socketpair, 388 .getname = sock_no_getname, 389 .ioctl = sock_no_ioctl, 390 .listen = sock_no_listen, 391 .shutdown = sock_no_shutdown, 392 .mmap = sock_no_mmap, 393 .bind = sock_no_bind, 394 395 .release = af_alg_release, 396 .sendmsg = hash_sendmsg_nokey, 397 .recvmsg = hash_recvmsg_nokey, 398 .accept = hash_accept_nokey, 399 }; 400 401 static void *hash_bind(const char *name) 402 { 403 int err; 404 405 err = af_alg_check_restriction(name, hash_allowlist); 406 if (err) 407 return ERR_PTR(err); 408 409 return crypto_alloc_ahash(name, 0, AF_ALG_CRYPTOAPI_MASK); 410 } 411 412 static void hash_release(void *private) 413 { 414 crypto_free_ahash(private); 415 } 416 417 static int hash_setkey(void *private, const u8 *key, unsigned int keylen) 418 { 419 return crypto_ahash_setkey(private, key, keylen); 420 } 421 422 static void hash_sock_destruct(struct sock *sk) 423 { 424 struct alg_sock *ask = alg_sk(sk); 425 struct hash_ctx *ctx = ask->private; 426 427 hash_free_result(sk, ctx); 428 sock_kfree_s(sk, ctx, ctx->len); 429 af_alg_release_parent(sk); 430 } 431 432 static int hash_accept_parent_nokey(void *private, struct sock *sk) 433 { 434 struct crypto_ahash *tfm = private; 435 struct alg_sock *ask = alg_sk(sk); 436 struct hash_ctx *ctx; 437 unsigned int len = sizeof(*ctx) + crypto_ahash_reqsize(tfm); 438 439 ctx = sock_kmalloc(sk, len, GFP_KERNEL); 440 if (!ctx) 441 return -ENOMEM; 442 443 memset(ctx, 0, len); 444 ctx->len = len; 445 crypto_init_wait(&ctx->wait); 446 447 ask->private = ctx; 448 449 ahash_request_set_tfm(&ctx->req, tfm); 450 ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG, 451 crypto_req_done, &ctx->wait); 452 453 sk->sk_destruct = hash_sock_destruct; 454 455 return 0; 456 } 457 458 static int hash_accept_parent(void *private, struct sock *sk) 459 { 460 struct crypto_ahash *tfm = private; 461 462 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) 463 return -ENOKEY; 464 465 return hash_accept_parent_nokey(private, sk); 466 } 467 468 static const struct af_alg_type algif_type_hash = { 469 .bind = hash_bind, 470 .release = hash_release, 471 .setkey = hash_setkey, 472 .accept = hash_accept_parent, 473 .accept_nokey = hash_accept_parent_nokey, 474 .ops = &algif_hash_ops, 475 .ops_nokey = &algif_hash_ops_nokey, 476 .name = "hash", 477 .owner = THIS_MODULE 478 }; 479 480 static int __init algif_hash_init(void) 481 { 482 return af_alg_register_type(&algif_type_hash); 483 } 484 485 static void __exit algif_hash_exit(void) 486 { 487 int err = af_alg_unregister_type(&algif_type_hash); 488 BUG_ON(err); 489 } 490 491 module_init(algif_hash_init); 492 module_exit(algif_hash_exit); 493 MODULE_DESCRIPTION("Userspace interface for hash algorithms"); 494 MODULE_LICENSE("GPL"); 495