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

TOMOYO Linux Cross Reference
Linux/arch/mips/cavium-octeon/crypto/octeon-sha1.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Cryptographic API.
  3  *
  4  * SHA1 Secure Hash Algorithm.
  5  *
  6  * Adapted for OCTEON by Aaro Koskinen <aaro.koskinen@iki.fi>.
  7  *
  8  * Based on crypto/sha1_generic.c, which is:
  9  *
 10  * Copyright (c) Alan Smithee.
 11  * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
 12  * Copyright (c) Jean-Francois Dive <jef@linuxbe.org>
 13  *
 14  * This program is free software; you can redistribute it and/or modify it
 15  * under the terms of the GNU General Public License as published by the Free
 16  * Software Foundation; either version 2 of the License, or (at your option)
 17  * any later version.
 18  */
 19 
 20 #include <linux/mm.h>
 21 #include <crypto/sha.h>
 22 #include <linux/init.h>
 23 #include <linux/types.h>
 24 #include <linux/module.h>
 25 #include <asm/byteorder.h>
 26 #include <asm/octeon/octeon.h>
 27 #include <crypto/internal/hash.h>
 28 
 29 #include "octeon-crypto.h"
 30 
 31 /*
 32  * We pass everything as 64-bit. OCTEON can handle misaligned data.
 33  */
 34 
 35 static void octeon_sha1_store_hash(struct sha1_state *sctx)
 36 {
 37         u64 *hash = (u64 *)sctx->state;
 38         union {
 39                 u32 word[2];
 40                 u64 dword;
 41         } hash_tail = { { sctx->state[4], } };
 42 
 43         write_octeon_64bit_hash_dword(hash[0], 0);
 44         write_octeon_64bit_hash_dword(hash[1], 1);
 45         write_octeon_64bit_hash_dword(hash_tail.dword, 2);
 46         memzero_explicit(&hash_tail.word[0], sizeof(hash_tail.word[0]));
 47 }
 48 
 49 static void octeon_sha1_read_hash(struct sha1_state *sctx)
 50 {
 51         u64 *hash = (u64 *)sctx->state;
 52         union {
 53                 u32 word[2];
 54                 u64 dword;
 55         } hash_tail;
 56 
 57         hash[0]         = read_octeon_64bit_hash_dword(0);
 58         hash[1]         = read_octeon_64bit_hash_dword(1);
 59         hash_tail.dword = read_octeon_64bit_hash_dword(2);
 60         sctx->state[4]  = hash_tail.word[0];
 61         memzero_explicit(&hash_tail.dword, sizeof(hash_tail.dword));
 62 }
 63 
 64 static void octeon_sha1_transform(const void *_block)
 65 {
 66         const u64 *block = _block;
 67 
 68         write_octeon_64bit_block_dword(block[0], 0);
 69         write_octeon_64bit_block_dword(block[1], 1);
 70         write_octeon_64bit_block_dword(block[2], 2);
 71         write_octeon_64bit_block_dword(block[3], 3);
 72         write_octeon_64bit_block_dword(block[4], 4);
 73         write_octeon_64bit_block_dword(block[5], 5);
 74         write_octeon_64bit_block_dword(block[6], 6);
 75         octeon_sha1_start(block[7]);
 76 }
 77 
 78 static int octeon_sha1_init(struct shash_desc *desc)
 79 {
 80         struct sha1_state *sctx = shash_desc_ctx(desc);
 81 
 82         sctx->state[0] = SHA1_H0;
 83         sctx->state[1] = SHA1_H1;
 84         sctx->state[2] = SHA1_H2;
 85         sctx->state[3] = SHA1_H3;
 86         sctx->state[4] = SHA1_H4;
 87         sctx->count = 0;
 88 
 89         return 0;
 90 }
 91 
 92 static void __octeon_sha1_update(struct sha1_state *sctx, const u8 *data,
 93                                  unsigned int len)
 94 {
 95         unsigned int partial;
 96         unsigned int done;
 97         const u8 *src;
 98 
 99         partial = sctx->count % SHA1_BLOCK_SIZE;
100         sctx->count += len;
101         done = 0;
102         src = data;
103 
104         if ((partial + len) >= SHA1_BLOCK_SIZE) {
105                 if (partial) {
106                         done = -partial;
107                         memcpy(sctx->buffer + partial, data,
108                                done + SHA1_BLOCK_SIZE);
109                         src = sctx->buffer;
110                 }
111 
112                 do {
113                         octeon_sha1_transform(src);
114                         done += SHA1_BLOCK_SIZE;
115                         src = data + done;
116                 } while (done + SHA1_BLOCK_SIZE <= len);
117 
118                 partial = 0;
119         }
120         memcpy(sctx->buffer + partial, src, len - done);
121 }
122 
123 static int octeon_sha1_update(struct shash_desc *desc, const u8 *data,
124                         unsigned int len)
125 {
126         struct sha1_state *sctx = shash_desc_ctx(desc);
127         struct octeon_cop2_state state;
128         unsigned long flags;
129 
130         /*
131          * Small updates never reach the crypto engine, so the generic sha1 is
132          * faster because of the heavyweight octeon_crypto_enable() /
133          * octeon_crypto_disable().
134          */
135         if ((sctx->count % SHA1_BLOCK_SIZE) + len < SHA1_BLOCK_SIZE)
136                 return crypto_sha1_update(desc, data, len);
137 
138         flags = octeon_crypto_enable(&state);
139         octeon_sha1_store_hash(sctx);
140 
141         __octeon_sha1_update(sctx, data, len);
142 
143         octeon_sha1_read_hash(sctx);
144         octeon_crypto_disable(&state, flags);
145 
146         return 0;
147 }
148 
149 static int octeon_sha1_final(struct shash_desc *desc, u8 *out)
150 {
151         struct sha1_state *sctx = shash_desc_ctx(desc);
152         static const u8 padding[64] = { 0x80, };
153         struct octeon_cop2_state state;
154         __be32 *dst = (__be32 *)out;
155         unsigned int pad_len;
156         unsigned long flags;
157         unsigned int index;
158         __be64 bits;
159         int i;
160 
161         /* Save number of bits. */
162         bits = cpu_to_be64(sctx->count << 3);
163 
164         /* Pad out to 56 mod 64. */
165         index = sctx->count & 0x3f;
166         pad_len = (index < 56) ? (56 - index) : ((64+56) - index);
167 
168         flags = octeon_crypto_enable(&state);
169         octeon_sha1_store_hash(sctx);
170 
171         __octeon_sha1_update(sctx, padding, pad_len);
172 
173         /* Append length (before padding). */
174         __octeon_sha1_update(sctx, (const u8 *)&bits, sizeof(bits));
175 
176         octeon_sha1_read_hash(sctx);
177         octeon_crypto_disable(&state, flags);
178 
179         /* Store state in digest */
180         for (i = 0; i < 5; i++)
181                 dst[i] = cpu_to_be32(sctx->state[i]);
182 
183         /* Zeroize sensitive information. */
184         memset(sctx, 0, sizeof(*sctx));
185 
186         return 0;
187 }
188 
189 static int octeon_sha1_export(struct shash_desc *desc, void *out)
190 {
191         struct sha1_state *sctx = shash_desc_ctx(desc);
192 
193         memcpy(out, sctx, sizeof(*sctx));
194         return 0;
195 }
196 
197 static int octeon_sha1_import(struct shash_desc *desc, const void *in)
198 {
199         struct sha1_state *sctx = shash_desc_ctx(desc);
200 
201         memcpy(sctx, in, sizeof(*sctx));
202         return 0;
203 }
204 
205 static struct shash_alg octeon_sha1_alg = {
206         .digestsize     =       SHA1_DIGEST_SIZE,
207         .init           =       octeon_sha1_init,
208         .update         =       octeon_sha1_update,
209         .final          =       octeon_sha1_final,
210         .export         =       octeon_sha1_export,
211         .import         =       octeon_sha1_import,
212         .descsize       =       sizeof(struct sha1_state),
213         .statesize      =       sizeof(struct sha1_state),
214         .base           =       {
215                 .cra_name       =       "sha1",
216                 .cra_driver_name=       "octeon-sha1",
217                 .cra_priority   =       OCTEON_CR_OPCODE_PRIORITY,
218                 .cra_flags      =       CRYPTO_ALG_TYPE_SHASH,
219                 .cra_blocksize  =       SHA1_BLOCK_SIZE,
220                 .cra_module     =       THIS_MODULE,
221         }
222 };
223 
224 static int __init octeon_sha1_mod_init(void)
225 {
226         if (!octeon_has_crypto())
227                 return -ENOTSUPP;
228         return crypto_register_shash(&octeon_sha1_alg);
229 }
230 
231 static void __exit octeon_sha1_mod_fini(void)
232 {
233         crypto_unregister_shash(&octeon_sha1_alg);
234 }
235 
236 module_init(octeon_sha1_mod_init);
237 module_exit(octeon_sha1_mod_fini);
238 
239 MODULE_LICENSE("GPL");
240 MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm (OCTEON)");
241 MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");
242 

~ [ 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