cregit-Linux how code gets into the kernel

Release 4.11 crypto/algif_hash.c

Directory: crypto
/*
 * algif_hash: User-space interface for hash algorithms
 *
 * This file provides the user-space API for hash algorithms.
 *
 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 */

#include <crypto/hash.h>
#include <crypto/if_alg.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/net.h>
#include <net/sock.h>


struct hash_ctx {
	
struct af_alg_sgl sgl;

	
u8 *result;

	
struct af_alg_completion completion;

	
unsigned int len;
	
bool more;

	
struct ahash_request req;
};


struct algif_hash_tfm {
	
struct crypto_ahash *hash;
	
bool has_key;
};


static int hash_alloc_result(struct sock *sk, struct hash_ctx *ctx) { unsigned ds; if (ctx->result) return 0; ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); ctx->result = sock_kmalloc(sk, ds, GFP_KERNEL); if (!ctx->result) return -ENOMEM; memset(ctx->result, 0, ds); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu79100.00%1100.00%
Total79100.00%1100.00%


static void hash_free_result(struct sock *sk, struct hash_ctx *ctx) { unsigned ds; if (!ctx->result) return; ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); sock_kzfree_s(sk, ctx->result, ds); ctx->result = NULL; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu57100.00%1100.00%
Total57100.00%1100.00%


static int hash_sendmsg(struct socket *sock, struct msghdr *msg, size_t ignored) { int limit = ALG_MAX_PAGES * PAGE_SIZE; struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct hash_ctx *ctx = ask->private; long copied = 0; int err; if (limit > sk->sk_sndbuf) limit = sk->sk_sndbuf; lock_sock(sk); if (!ctx->more) { if ((msg->msg_flags & MSG_MORE)) hash_free_result(sk, ctx); err = af_alg_wait_for_completion(crypto_ahash_init(&ctx->req), &ctx->completion); if (err) goto unlock; } ctx->more = 0; while (msg_data_left(msg)) { int len = msg_data_left(msg); if (len > limit) len = limit; len = af_alg_make_sg(&ctx->sgl, &msg->msg_iter, len); if (len < 0) { err = copied ? 0 : len; goto unlock; } ahash_request_set_crypt(&ctx->req, ctx->sgl.sg, NULL, len); err = af_alg_wait_for_completion(crypto_ahash_update(&ctx->req), &ctx->completion); af_alg_free_sg(&ctx->sgl); if (err) goto unlock; copied += len; iov_iter_advance(&msg->msg_iter, len); } err = 0; ctx->more = msg->msg_flags & MSG_MORE; if (!ctx->more) { err = hash_alloc_result(sk, ctx); if (err) goto unlock; ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0); err = af_alg_wait_for_completion(crypto_ahash_final(&ctx->req), &ctx->completion); } unlock: release_sock(sk); return err ?: copied; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu30887.50%350.00%
Al Viro3610.23%233.33%
Rui Y Wang82.27%116.67%
Total352100.00%6100.00%


static ssize_t hash_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 hash_ctx *ctx = ask->private; int err; if (flags & MSG_SENDPAGE_NOTLAST) flags |= MSG_MORE; lock_sock(sk); sg_init_table(ctx->sgl.sg, 1); sg_set_page(ctx->sgl.sg, page, size, offset); if (!(flags & MSG_MORE)) { err = hash_alloc_result(sk, ctx); if (err) goto unlock; } else if (!ctx->more) hash_free_result(sk, ctx); ahash_request_set_crypt(&ctx->req, ctx->sgl.sg, ctx->result, size); if (!(flags & MSG_MORE)) { if (ctx->more) err = crypto_ahash_finup(&ctx->req); else err = crypto_ahash_digest(&ctx->req); } else { if (!ctx->more) { err = crypto_ahash_init(&ctx->req); err = af_alg_wait_for_completion(err, &ctx->completion); if (err) goto unlock; } err = crypto_ahash_update(&ctx->req); } err = af_alg_wait_for_completion(err, &ctx->completion); if (err) goto unlock; ctx->more = flags & MSG_MORE; unlock: release_sock(sk); return err ?: size; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu26692.36%250.00%
Rui Y Wang124.17%125.00%
Shawn Landden103.47%125.00%
Total288100.00%4100.00%


static int hash_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, int flags) { struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct hash_ctx *ctx = ask->private; unsigned ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)); bool result; int err; if (len > ds) len = ds; else if (len < ds) msg->msg_flags |= MSG_TRUNC; lock_sock(sk); result = ctx->result; err = hash_alloc_result(sk, ctx); if (err) goto unlock; ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0); if (!result && !ctx->more) { err = af_alg_wait_for_completion( crypto_ahash_init(&ctx->req), &ctx->completion); if (err) goto unlock; } if (!result || ctx->more) { ctx->more = 0; err = af_alg_wait_for_completion(crypto_ahash_final(&ctx->req), &ctx->completion); if (err) goto unlock; } err = memcpy_to_msg(msg, ctx->result, len); unlock: hash_free_result(sk, ctx); release_sock(sk); return err ?: len; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu24799.60%480.00%
Al Viro10.40%120.00%
Total248100.00%5100.00%


static int hash_accept(struct socket *sock, struct socket *newsock, int flags, bool kern) { struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct hash_ctx *ctx = ask->private; struct ahash_request *req = &ctx->req; char state[crypto_ahash_statesize(crypto_ahash_reqtfm(req)) ? : 1]; struct sock *sk2; struct alg_sock *ask2; struct hash_ctx *ctx2; bool more; int err; lock_sock(sk); more = ctx->more; err = more ? crypto_ahash_export(req, state) : 0; release_sock(sk); if (err) return err; err = af_alg_accept(ask->parent, newsock, kern); if (err) return err; sk2 = newsock->sk; ask2 = alg_sk(sk2); ctx2 = ask2->private; ctx2->more = more; if (!more) return err; err = crypto_ahash_import(&ctx2->req, state); if (err) { sock_orphan(sk2); sock_put(sk2); } return err; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu20896.30%250.00%
David Howells52.31%125.00%
Jiri Slaby31.39%125.00%
Total216100.00%4100.00%

static struct proto_ops algif_hash_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, .getsockopt = sock_no_getsockopt, .mmap = sock_no_mmap, .bind = sock_no_bind, .setsockopt = sock_no_setsockopt, .poll = sock_no_poll, .release = af_alg_release, .sendmsg = hash_sendmsg, .sendpage = hash_sendpage, .recvmsg = hash_recvmsg, .accept = hash_accept, };
static int hash_check_key(struct socket *sock) { int err = 0; struct sock *psk; struct alg_sock *pask; struct algif_hash_tfm *tfm; struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); lock_sock(sk); if (ask->refcnt) goto unlock_child; psk = ask->parent; pask = alg_sk(ask->parent); tfm = pask->private; err = -ENOKEY; lock_sock_nested(psk, SINGLE_DEPTH_NESTING); if (!tfm->has_key) goto unlock; if (!pask->refcnt++) sock_hold(psk); ask->refcnt = 1; sock_put(psk); err = 0; unlock: release_sock(psk); unlock_child: release_sock(sk); return err; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu152100.00%3100.00%
Total152100.00%3100.00%


static int hash_sendmsg_nokey(struct socket *sock, struct msghdr *msg, size_t size) { int err; err = hash_check_key(sock); if (err) return err; return hash_sendmsg(sock, msg, size); }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu46100.00%2100.00%
Total46100.00%2100.00%


static ssize_t hash_sendpage_nokey(struct socket *sock, struct page *page, int offset, size_t size, int flags) { int err; err = hash_check_key(sock); if (err) return err; return hash_sendpage(sock, page, offset, size, flags); }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu56100.00%1100.00%
Total56100.00%1100.00%


static int hash_recvmsg_nokey(struct socket *sock, struct msghdr *msg, size_t ignored, int flags) { int err; err = hash_check_key(sock); if (err) return err; return hash_recvmsg(sock, msg, ignored, flags); }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu51100.00%1100.00%
Total51100.00%1100.00%


static int hash_accept_nokey(struct socket *sock, struct socket *newsock, int flags, bool kern) { int err; err = hash_check_key(sock); if (err) return err; return hash_accept(sock, newsock, flags, kern); }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu4690.20%150.00%
David Howells59.80%150.00%
Total51100.00%2100.00%

static struct proto_ops algif_hash_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, .getsockopt = sock_no_getsockopt, .mmap = sock_no_mmap, .bind = sock_no_bind, .setsockopt = sock_no_setsockopt, .poll = sock_no_poll, .release = af_alg_release, .sendmsg = hash_sendmsg_nokey, .sendpage = hash_sendpage_nokey, .recvmsg = hash_recvmsg_nokey, .accept = hash_accept_nokey, };
static void *hash_bind(const char *name, u32 type, u32 mask) { struct algif_hash_tfm *tfm; struct crypto_ahash *hash; tfm = kzalloc(sizeof(*tfm), GFP_KERNEL); if (!tfm) return ERR_PTR(-ENOMEM); hash = crypto_alloc_ahash(name, type, mask); if (IS_ERR(hash)) { kfree(tfm); return ERR_CAST(hash); } tfm->hash = hash; return tfm; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu93100.00%1100.00%
Total93100.00%1100.00%


static void hash_release(void *private) { struct algif_hash_tfm *tfm = private; crypto_free_ahash(tfm->hash); kfree(tfm); }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu29100.00%1100.00%
Total29100.00%1100.00%


static int hash_setkey(void *private, const u8 *key, unsigned int keylen) { struct algif_hash_tfm *tfm = private; int err; err = crypto_ahash_setkey(tfm->hash, key, keylen); tfm->has_key = !err; return err; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu52100.00%1100.00%
Total52100.00%1100.00%


static void hash_sock_destruct(struct sock *sk) { struct alg_sock *ask = alg_sk(sk); struct hash_ctx *ctx = ask->private; hash_free_result(sk, ctx); sock_kfree_s(sk, ctx, ctx->len); af_alg_release_parent(sk); }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu53100.00%3100.00%
Total53100.00%3100.00%


static int hash_accept_parent_nokey(void *private, struct sock *sk) { struct hash_ctx *ctx; struct alg_sock *ask = alg_sk(sk); struct algif_hash_tfm *tfm = private; struct crypto_ahash *hash = tfm->hash; unsigned len = sizeof(*ctx) + crypto_ahash_reqsize(hash); ctx = sock_kmalloc(sk, len, GFP_KERNEL); if (!ctx) return -ENOMEM; ctx->result = NULL; ctx->len = len; ctx->more = 0; af_alg_init_completion(&ctx->completion); ask->private = ctx; ahash_request_set_tfm(&ctx->req, hash); ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG, af_alg_complete, &ctx->completion); sk->sk_destruct = hash_sock_destruct; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu148100.00%4100.00%
Total148100.00%4100.00%


static int hash_accept_parent(void *private, struct sock *sk) { struct algif_hash_tfm *tfm = private; if (!tfm->has_key && crypto_ahash_has_setkey(tfm->hash)) return -ENOKEY; return hash_accept_parent_nokey(private, sk); }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu48100.00%1100.00%
Total48100.00%1100.00%

static const struct af_alg_type algif_type_hash = { .bind = hash_bind, .release = hash_release, .setkey = hash_setkey, .accept = hash_accept_parent, .accept_nokey = hash_accept_parent_nokey, .ops = &algif_hash_ops, .ops_nokey = &algif_hash_ops_nokey, .name = "hash", .owner = THIS_MODULE };
static int __init algif_hash_init(void) { return af_alg_register_type(&algif_type_hash); }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu16100.00%1100.00%
Total16100.00%1100.00%


static void __exit algif_hash_exit(void) { int err = af_alg_unregister_type(&algif_type_hash); BUG_ON(err); }

Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu23100.00%1100.00%
Total23100.00%1100.00%

module_init(algif_hash_init); module_exit(algif_hash_exit); MODULE_LICENSE("GPL");

Overall Contributors

PersonTokensPropCommitsCommitProp
Herbert Xu229896.64%956.25%
Al Viro371.56%318.75%
Rui Y Wang200.84%16.25%
David Howells100.42%16.25%
Shawn Landden100.42%16.25%
Jiri Slaby30.13%16.25%
Total2378100.00%16100.00%
Directory: crypto
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.