sha1_generic.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*
    2  * Cryptographic API.
    3  *
    4  * SHA1 Secure Hash Algorithm.
    5  *
    6  * Derived from cryptoapi implementation, adapted for in-place
    7  * scatterlist interface.
    8  *
    9  * Copyright (c) Alan Smithee.
   10  * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
   11  * Copyright (c) Jean-Francois Dive <jef@linuxbe.org>
   12  *
   13  * This program is free software; you can redistribute it and/or modify it
   14  * under the terms of the GNU General Public License as published by the Free
   15  * Software Foundation; either version 2 of the License, or (at your option)
   16  * any later version.
   17  *
   18  */
   19 #include <crypto/internal/hash.h>
   20 #include <linux/init.h>
   21 #include <linux/module.h>
   22 #include <linux/mm.h>
   23 #include <linux/cryptohash.h>
   24 #include <linux/types.h>
   25 #include <crypto/sha.h>
   26 #include <asm/byteorder.h>
   27 
   28 static int sha1_init(struct shash_desc *desc)
   29 {
   30         struct sha1_state *sctx = shash_desc_ctx(desc);
   31 
   32         *sctx = (struct sha1_state){
   33                 .state = { SHA1_H0, SHA1_H1, SHA1_H2, SHA1_H3, SHA1_H4 },
   34         };
   35 
   36         return 0;
   37 }
   38 
   39 int crypto_sha1_update(struct shash_desc *desc, const u8 *data,
   40                         unsigned int len)
   41 {
   42         struct sha1_state *sctx = shash_desc_ctx(desc);
   43         unsigned int partial, done;
   44         const u8 *src;
   45 
   46         partial = sctx->count % SHA1_BLOCK_SIZE;
   47         sctx->count += len;
   48         done = 0;
   49         src = data;
   50 
   51         if ((partial + len) >= SHA1_BLOCK_SIZE) {
   52                 u32 temp[SHA_WORKSPACE_WORDS];
   53 
   54                 if (partial) {
   55                         done = -partial;
   56                         memcpy(sctx->buffer + partial, data,
   57                                done + SHA1_BLOCK_SIZE);
   58                         src = sctx->buffer;
   59                 }
   60 
   61                 do {
   62                         sha_transform(sctx->state, src, temp);
   63                         done += SHA1_BLOCK_SIZE;
   64                         src = data + done;
   65                 } while (done + SHA1_BLOCK_SIZE <= len);
   66 
   67                 memset(temp, 0, sizeof(temp));
   68                 partial = 0;
   69         }
   70         memcpy(sctx->buffer + partial, src, len - done);
   71 
   72         return 0;
   73 }
   74 EXPORT_SYMBOL(crypto_sha1_update);
   75 
   76 
   77 /* Add padding and return the message digest. */
   78 static int sha1_final(struct shash_desc *desc, u8 *out)
   79 {
   80         struct sha1_state *sctx = shash_desc_ctx(desc);
   81         __be32 *dst = (__be32 *)out;
   82         u32 i, index, padlen;
   83         __be64 bits;
   84         static const u8 padding[64] = { 0x80, };
   85 
   86         bits = cpu_to_be64(sctx->count << 3);
   87 
   88         /* Pad out to 56 mod 64 */
   89         index = sctx->count & 0x3f;
   90         padlen = (index < 56) ? (56 - index) : ((64+56) - index);
   91         crypto_sha1_update(desc, padding, padlen);
   92 
   93         /* Append length */
   94         crypto_sha1_update(desc, (const u8 *)&bits, sizeof(bits));
   95 
   96         /* Store state in digest */
   97         for (i = 0; i < 5; i++)
   98                 dst[i] = cpu_to_be32(sctx->state[i]);
   99 
  100         /* Wipe context */
  101         memset(sctx, 0, sizeof *sctx);
  102 
  103         return 0;
  104 }
  105 
  106 static int sha1_export(struct shash_desc *desc, void *out)
  107 {
  108         struct sha1_state *sctx = shash_desc_ctx(desc);
  109 
  110         memcpy(out, sctx, sizeof(*sctx));
  111         return 0;
  112 }
  113 
  114 static int sha1_import(struct shash_desc *desc, const void *in)
  115 {
  116         struct sha1_state *sctx = shash_desc_ctx(desc);
  117 
  118         memcpy(sctx, in, sizeof(*sctx));
  119         return 0;
  120 }
  121 
  122 static struct shash_alg alg = {
  123         .digestsize     =       SHA1_DIGEST_SIZE,
  124         .init           =       sha1_init,
  125         .update         =       crypto_sha1_update,
  126         .final          =       sha1_final,
  127         .export         =       sha1_export,
  128         .import         =       sha1_import,
  129         .descsize       =       sizeof(struct sha1_state),
  130         .statesize      =       sizeof(struct sha1_state),
  131         .base           =       {
  132                 .cra_name       =       "sha1",
  133                 .cra_driver_name=       "sha1-generic",
  134                 .cra_flags      =       CRYPTO_ALG_TYPE_SHASH,
  135                 .cra_blocksize  =       SHA1_BLOCK_SIZE,
  136                 .cra_module     =       THIS_MODULE,
  137         }
  138 };
  139 
  140 static int __init sha1_generic_mod_init(void)
  141 {
  142         return crypto_register_shash(&alg);
  143 }
  144 
  145 static void __exit sha1_generic_mod_fini(void)
  146 {
  147         crypto_unregister_shash(&alg);
  148 }
  149 
  150 module_init(sha1_generic_mod_init);
  151 module_exit(sha1_generic_mod_fini);
  152 
  153 MODULE_LICENSE("GPL");
  154 MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm");
  155 
  156 MODULE_ALIAS("sha1");

Cache object: 6018c32f1a3651547b1c6d584ad387e2

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/crypto/sha1_generic.c

FreeBSD/Linux Kernel Cross Reference
sys/crypto/sha1_generic.c