~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/crypto/sha256_base.h

Version: ~ [ linux-5.18 ] ~ [ linux-5.17.9 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.41 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.117 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.195 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.244 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.280 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.315 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * sha256_base.h - core logic for SHA-256 implementations
  3  *
  4  * Copyright (C) 2015 Linaro Ltd <ard.biesheuvel@linaro.org>
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License version 2 as
  8  * published by the Free Software Foundation.
  9  */
 10 
 11 #include <crypto/internal/hash.h>
 12 #include <crypto/sha.h>
 13 #include <linux/crypto.h>
 14 #include <linux/module.h>
 15 
 16 #include <asm/unaligned.h>
 17 
 18 typedef void (sha256_block_fn)(struct sha256_state *sst, u8 const *src,
 19                                int blocks);
 20 
 21 static inline int sha224_base_init(struct shash_desc *desc)
 22 {
 23         struct sha256_state *sctx = shash_desc_ctx(desc);
 24 
 25         sctx->state[0] = SHA224_H0;
 26         sctx->state[1] = SHA224_H1;
 27         sctx->state[2] = SHA224_H2;
 28         sctx->state[3] = SHA224_H3;
 29         sctx->state[4] = SHA224_H4;
 30         sctx->state[5] = SHA224_H5;
 31         sctx->state[6] = SHA224_H6;
 32         sctx->state[7] = SHA224_H7;
 33         sctx->count = 0;
 34 
 35         return 0;
 36 }
 37 
 38 static inline int sha256_base_init(struct shash_desc *desc)
 39 {
 40         struct sha256_state *sctx = shash_desc_ctx(desc);
 41 
 42         sctx->state[0] = SHA256_H0;
 43         sctx->state[1] = SHA256_H1;
 44         sctx->state[2] = SHA256_H2;
 45         sctx->state[3] = SHA256_H3;
 46         sctx->state[4] = SHA256_H4;
 47         sctx->state[5] = SHA256_H5;
 48         sctx->state[6] = SHA256_H6;
 49         sctx->state[7] = SHA256_H7;
 50         sctx->count = 0;
 51 
 52         return 0;
 53 }
 54 
 55 static inline int sha256_base_do_update(struct shash_desc *desc,
 56                                         const u8 *data,
 57                                         unsigned int len,
 58                                         sha256_block_fn *block_fn)
 59 {
 60         struct sha256_state *sctx = shash_desc_ctx(desc);
 61         unsigned int partial = sctx->count % SHA256_BLOCK_SIZE;
 62 
 63         sctx->count += len;
 64 
 65         if (unlikely((partial + len) >= SHA256_BLOCK_SIZE)) {
 66                 int blocks;
 67 
 68                 if (partial) {
 69                         int p = SHA256_BLOCK_SIZE - partial;
 70 
 71                         memcpy(sctx->buf + partial, data, p);
 72                         data += p;
 73                         len -= p;
 74 
 75                         block_fn(sctx, sctx->buf, 1);
 76                 }
 77 
 78                 blocks = len / SHA256_BLOCK_SIZE;
 79                 len %= SHA256_BLOCK_SIZE;
 80 
 81                 if (blocks) {
 82                         block_fn(sctx, data, blocks);
 83                         data += blocks * SHA256_BLOCK_SIZE;
 84                 }
 85                 partial = 0;
 86         }
 87         if (len)
 88                 memcpy(sctx->buf + partial, data, len);
 89 
 90         return 0;
 91 }
 92 
 93 static inline int sha256_base_do_finalize(struct shash_desc *desc,
 94                                           sha256_block_fn *block_fn)
 95 {
 96         const int bit_offset = SHA256_BLOCK_SIZE - sizeof(__be64);
 97         struct sha256_state *sctx = shash_desc_ctx(desc);
 98         __be64 *bits = (__be64 *)(sctx->buf + bit_offset);
 99         unsigned int partial = sctx->count % SHA256_BLOCK_SIZE;
100 
101         sctx->buf[partial++] = 0x80;
102         if (partial > bit_offset) {
103                 memset(sctx->buf + partial, 0x0, SHA256_BLOCK_SIZE - partial);
104                 partial = 0;
105 
106                 block_fn(sctx, sctx->buf, 1);
107         }
108 
109         memset(sctx->buf + partial, 0x0, bit_offset - partial);
110         *bits = cpu_to_be64(sctx->count << 3);
111         block_fn(sctx, sctx->buf, 1);
112 
113         return 0;
114 }
115 
116 static inline int sha256_base_finish(struct shash_desc *desc, u8 *out)
117 {
118         unsigned int digest_size = crypto_shash_digestsize(desc->tfm);
119         struct sha256_state *sctx = shash_desc_ctx(desc);
120         __be32 *digest = (__be32 *)out;
121         int i;
122 
123         for (i = 0; digest_size > 0; i++, digest_size -= sizeof(__be32))
124                 put_unaligned_be32(sctx->state[i], digest++);
125 
126         *sctx = (struct sha256_state){};
127         return 0;
128 }
129 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp