powerpc/crypto/md5-glue.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Glue code for MD5 implementation for PPC assembler
0004  *
0005  * Based on generic implementation.
0006  *
0007  * Copyright (c) 2015 Markus Stockhausen <stockhausen@collogia.de>
0008  */
0009
0010 #include <crypto/internal/hash.h>
0011 #include <linux/init.h>
0012 #include <linux/module.h>
0013 #include <linux/mm.h>
0014 #include <linux/types.h>
0015 #include <crypto/md5.h>
0016 #include <asm/byteorder.h>
0017
0018 extern void ppc_md5_transform(u32 *state, const u8 *src, u32 blocks);
0019
0020 static inline void ppc_md5_clear_context(struct md5_state *sctx)
0021 {
0022     int count = sizeof(struct md5_state) >> 2;
0023     u32 *ptr = (u32 *)sctx;
0024
0025     /* make sure we can clear the fast way */
0026     BUILD_BUG_ON(sizeof(struct md5_state) % 4);
0027     do { *ptr++ = 0; } while (--count);
0028 }
0029
0030 static int ppc_md5_init(struct shash_desc *desc)
0031 {
0032     struct md5_state *sctx = shash_desc_ctx(desc);
0033
0034     sctx->hash[0] = MD5_H0;
0035     sctx->hash[1] = MD5_H1;
0036     sctx->hash[2] = MD5_H2;
0037     sctx->hash[3] = MD5_H3;
0038     sctx->byte_count = 0;
0039
0040     return 0;
0041 }
0042
0043 static int ppc_md5_update(struct shash_desc *desc, const u8 *data,
0044             unsigned int len)
0045 {
0046     struct md5_state *sctx = shash_desc_ctx(desc);
0047     const unsigned int offset = sctx->byte_count & 0x3f;
0048     unsigned int avail = 64 - offset;
0049     const u8 *src = data;
0050
0051     sctx->byte_count += len;
0052
0053     if (avail > len) {
0054         memcpy((char *)sctx->block + offset, src, len);
0055         return 0;
0056     }
0057
0058     if (offset) {
0059         memcpy((char *)sctx->block + offset, src, avail);
0060         ppc_md5_transform(sctx->hash, (const u8 *)sctx->block, 1);
0061         len -= avail;
0062         src += avail;
0063     }
0064
0065     if (len > 63) {
0066         ppc_md5_transform(sctx->hash, src, len >> 6);
0067         src += len & ~0x3f;
0068         len &= 0x3f;
0069     }
0070
0071     memcpy((char *)sctx->block, src, len);
0072     return 0;
0073 }
0074
0075 static int ppc_md5_final(struct shash_desc *desc, u8 *out)
0076 {
0077     struct md5_state *sctx = shash_desc_ctx(desc);
0078     const unsigned int offset = sctx->byte_count & 0x3f;
0079     const u8 *src = (const u8 *)sctx->block;
0080     u8 *p = (u8 *)src + offset;
0081     int padlen = 55 - offset;
0082     __le64 *pbits = (__le64 *)((char *)sctx->block + 56);
0083     __le32 *dst = (__le32 *)out;
0084
0085     *p++ = 0x80;
0086
0087     if (padlen < 0) {
0088         memset(p, 0x00, padlen + sizeof (u64));
0089         ppc_md5_transform(sctx->hash, src, 1);
0090         p = (char *)sctx->block;
0091         padlen = 56;
0092     }
0093
0094     memset(p, 0, padlen);
0095     *pbits = cpu_to_le64(sctx->byte_count << 3);
0096     ppc_md5_transform(sctx->hash, src, 1);
0097
0098     dst[0] = cpu_to_le32(sctx->hash[0]);
0099     dst[1] = cpu_to_le32(sctx->hash[1]);
0100     dst[2] = cpu_to_le32(sctx->hash[2]);
0101     dst[3] = cpu_to_le32(sctx->hash[3]);
0102
0103     ppc_md5_clear_context(sctx);
0104     return 0;
0105 }
0106
0107 static int ppc_md5_export(struct shash_desc *desc, void *out)
0108 {
0109     struct md5_state *sctx = shash_desc_ctx(desc);
0110
0111     memcpy(out, sctx, sizeof(*sctx));
0112     return 0;
0113 }
0114
0115 static int ppc_md5_import(struct shash_desc *desc, const void *in)
0116 {
0117     struct md5_state *sctx = shash_desc_ctx(desc);
0118
0119     memcpy(sctx, in, sizeof(*sctx));
0120     return 0;
0121 }
0122
0123 static struct shash_alg alg = {
0124     .digestsize =   MD5_DIGEST_SIZE,
0125     .init       =   ppc_md5_init,
0126     .update     =   ppc_md5_update,
0127     .final      =   ppc_md5_final,
0128     .export     =   ppc_md5_export,
0129     .import     =   ppc_md5_import,
0130     .descsize   =   sizeof(struct md5_state),
0131     .statesize  =   sizeof(struct md5_state),
0132     .base       =   {
0133         .cra_name   =   "md5",
0134         .cra_driver_name=   "md5-ppc",
0135         .cra_priority   =   200,
0136         .cra_blocksize  =   MD5_HMAC_BLOCK_SIZE,
0137         .cra_module =   THIS_MODULE,
0138     }
0139 };
0140
0141 static int __init ppc_md5_mod_init(void)
0142 {
0143     return crypto_register_shash(&alg);
0144 }
0145
0146 static void __exit ppc_md5_mod_fini(void)
0147 {
0148     crypto_unregister_shash(&alg);
0149 }
0150
0151 module_init(ppc_md5_mod_init);
0152 module_exit(ppc_md5_mod_fini);
0153
0154 MODULE_LICENSE("GPL");
0155 MODULE_DESCRIPTION("MD5 Secure Hash Algorithm, PPC assembler");
0156
0157 MODULE_ALIAS_CRYPTO("md5");
0158 MODULE_ALIAS_CRYPTO("md5-ppc");