LXR linux/arch/powerpc/crypto/md5-glue.c

   1/*
   2 * Glue code for MD5 implementation for PPC assembler
   3 *
   4 * Based on generic implementation.
   5 *
   6 * Copyright (c) 2015 Markus Stockhausen <stockhausen@collogia.de>
   7 *
   8 * This program is free software; you can redistribute it and/or modify it
   9 * under the terms of the GNU General Public License as published by the Free
  10 * Software Foundation; either version 2 of the License, or (at your option)
  11 * any later version.
  12 *
  13 */
  14
  15#include <crypto/internal/hash.h>
  16#include <linux/init.h>
  17#include <linux/module.h>
  18#include <linux/mm.h>
  19#include <linux/cryptohash.h>
  20#include <linux/types.h>
  21#include <crypto/md5.h>
  22#include <asm/byteorder.h>
  23
  24extern void ppc_md5_transform(u32 *state, const u8 *src, u32 blocks);
  25
  26static inline void ppc_md5_clear_context(struct md5_state *sctx)
  27{
  28        int count = sizeof(struct md5_state) >> 2;
  29        u32 *ptr = (u32 *)sctx;
  30
  31        /* make sure we can clear the fast way */
  32        BUILD_BUG_ON(sizeof(struct md5_state) % 4);
  33        do { *ptr++ = 0; } while (--count);
  34}
  35
  36static int ppc_md5_init(struct shash_desc *desc)
  37{
  38        struct md5_state *sctx = shash_desc_ctx(desc);
  39
  40        sctx->hash[0] = MD5_H0;
  41        sctx->hash[1] = MD5_H1;
  42        sctx->hash[2] = MD5_H2;
  43        sctx->hash[3] = MD5_H3;
  44        sctx->byte_count = 0;
  45
  46        return 0;
  47}
  48
  49static int ppc_md5_update(struct shash_desc *desc, const u8 *data,
  50                        unsigned int len)
  51{
  52        struct md5_state *sctx = shash_desc_ctx(desc);
  53        const unsigned int offset = sctx->byte_count & 0x3f;
  54        unsigned int avail = 64 - offset;
  55        const u8 *src = data;
  56
  57        sctx->byte_count += len;
  58
  59        if (avail > len) {
  60                memcpy((char *)sctx->block + offset, src, len);
  61                return 0;
  62        }
  63
  64        if (offset) {
  65                memcpy((char *)sctx->block + offset, src, avail);
  66                ppc_md5_transform(sctx->hash, (const u8 *)sctx->block, 1);
  67                len -= avail;
  68                src += avail;
  69        }
  70
  71        if (len > 63) {
  72                ppc_md5_transform(sctx->hash, src, len >> 6);
  73                src += len & ~0x3f;
  74                len &= 0x3f;
  75        }
  76
  77        memcpy((char *)sctx->block, src, len);
  78        return 0;
  79}
  80
  81static int ppc_md5_final(struct shash_desc *desc, u8 *out)
  82{
  83        struct md5_state *sctx = shash_desc_ctx(desc);
  84        const unsigned int offset = sctx->byte_count & 0x3f;
  85        const u8 *src = (const u8 *)sctx->block;
  86        u8 *p = (u8 *)src + offset;
  87        int padlen = 55 - offset;
  88        __le64 *pbits = (__le64 *)((char *)sctx->block + 56);
  89        __le32 *dst = (__le32 *)out;
  90
  91        *p++ = 0x80;
  92
  93        if (padlen < 0) {
  94                memset(p, 0x00, padlen + sizeof (u64));
  95                ppc_md5_transform(sctx->hash, src, 1);
  96                p = (char *)sctx->block;
  97                padlen = 56;
  98        }
  99
 100        memset(p, 0, padlen);
 101        *pbits = cpu_to_le64(sctx->byte_count << 3);
 102        ppc_md5_transform(sctx->hash, src, 1);
 103
 104        dst[0] = cpu_to_le32(sctx->hash[0]);
 105        dst[1] = cpu_to_le32(sctx->hash[1]);
 106        dst[2] = cpu_to_le32(sctx->hash[2]);
 107        dst[3] = cpu_to_le32(sctx->hash[3]);
 108
 109        ppc_md5_clear_context(sctx);
 110        return 0;
 111}
 112
 113static int ppc_md5_export(struct shash_desc *desc, void *out)
 114{
 115        struct md5_state *sctx = shash_desc_ctx(desc);
 116
 117        memcpy(out, sctx, sizeof(*sctx));
 118        return 0;
 119}
 120
 121static int ppc_md5_import(struct shash_desc *desc, const void *in)
 122{
 123        struct md5_state *sctx = shash_desc_ctx(desc);
 124
 125        memcpy(sctx, in, sizeof(*sctx));
 126        return 0;
 127}
 128
 129static struct shash_alg alg = {
 130        .digestsize     =       MD5_DIGEST_SIZE,
 131        .init           =       ppc_md5_init,
 132        .update         =       ppc_md5_update,
 133        .final          =       ppc_md5_final,
 134        .export         =       ppc_md5_export,
 135        .import         =       ppc_md5_import,
 136        .descsize       =       sizeof(struct md5_state),
 137        .statesize      =       sizeof(struct md5_state),
 138        .base           =       {
 139                .cra_name       =       "md5",
 140                .cra_driver_name=       "md5-ppc",
 141                .cra_priority   =       200,
 142                .cra_blocksize  =       MD5_HMAC_BLOCK_SIZE,
 143                .cra_module     =       THIS_MODULE,
 144        }
 145};
 146
 147static int __init ppc_md5_mod_init(void)
 148{
 149        return crypto_register_shash(&alg);
 150}
 151
 152static void __exit ppc_md5_mod_fini(void)
 153{
 154        crypto_unregister_shash(&alg);
 155}
 156
 157module_init(ppc_md5_mod_init);
 158module_exit(ppc_md5_mod_fini);
 159
 160MODULE_LICENSE("GPL");
 161MODULE_DESCRIPTION("MD5 Secure Hash Algorithm, PPC assembler");
 162
 163MODULE_ALIAS_CRYPTO("md5");
 164MODULE_ALIAS_CRYPTO("md5-ppc");
 165