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

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