Root/target/linux/ubicom32/files/arch/ubicom32/crypto/md5_ubicom32.c

1/*
2 * arch/ubicom32/crypto/md5_ubicom32.c
3 * Ubicom32 implementation of the MD5 Secure Hash Algorithm
4 *
5 * (C) Copyright 2009, Ubicom, Inc.
6 *
7 * This file is part of the Ubicom32 Linux Kernel Port.
8 *
9 * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10 * it and/or modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation, either version 2 of the
12 * License, or (at your option) any later version.
13 *
14 * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with the Ubicom32 Linux Kernel Port. If not,
21 * see <http://www.gnu.org/licenses/>.
22 *
23 * Ubicom32 implementation derived from (with many thanks):
24 * arch/m68knommu
25 * arch/blackfin
26 * arch/parisc
27 */
28#include <linux/init.h>
29#include <linux/module.h>
30#include <linux/crypto.h>
31
32#include "crypto_ubicom32.h"
33
34#define MD5_DIGEST_SIZE 16
35#define MD5_BLOCK_SIZE 64
36#define MD5_HASH_WORDS 4
37
38extern void _md5_ip5k_init_digest(u32_t *digest);
39extern void _md5_ip5k_transform(u32_t *data_input);
40extern void _md5_ip5k_get_digest(u32_t *digest);
41
42struct ubicom32_md5_ctx {
43    u64 count; /* message length */
44    u32 state[MD5_HASH_WORDS];
45    u8 buf[2 * MD5_BLOCK_SIZE];
46};
47
48static void md5_init(struct crypto_tfm *tfm)
49{
50    struct ubicom32_md5_ctx *mctx = crypto_tfm_ctx(tfm);
51    mctx->state[0] = 0x01234567;
52    mctx->state[1] = 0x89abcdef;
53    mctx->state[2] = 0xfedcba98;
54    mctx->state[3] = 0x76543210;
55
56    mctx->count = 0;
57}
58
59static inline void _md5_process(u32 *digest, const u8 *data)
60{
61    _md5_ip5k_transform((u32 *)data);
62}
63
64static void md5_update(struct crypto_tfm *tfm, const u8 *data,
65            unsigned int len)
66{
67    struct ubicom32_md5_ctx *mctx = crypto_tfm_ctx(tfm);
68    int index, clen;
69
70    /* how much is already in the buffer? */
71    index = mctx->count & 0x3f;
72
73    mctx->count += len;
74
75    if (index + len < MD5_BLOCK_SIZE) {
76        goto store_only;
77    }
78
79    hw_crypto_lock();
80    hw_crypto_check();
81
82    /* init digest set ctrl register too */
83    _md5_ip5k_init_digest(mctx->state);
84
85    if (unlikely(index == 0 && SEC_ALIGNED(data))) {
86fast_process:
87        while (len >= MD5_BLOCK_SIZE) {
88            _md5_process(mctx->state, data);
89            data += MD5_BLOCK_SIZE;
90            len -= MD5_BLOCK_SIZE;
91        }
92        goto store;
93    }
94
95    /* process one stored block */
96    if (index) {
97        clen = MD5_BLOCK_SIZE - index;
98        memcpy(mctx->buf + index, data, clen);
99        _md5_process(mctx->state, mctx->buf);
100        data += clen;
101        len -= clen;
102        index = 0;
103    }
104
105    if (likely(SEC_ALIGNED(data))) {
106        goto fast_process;
107    }
108
109    /* process as many blocks as possible */
110    while (len >= MD5_BLOCK_SIZE) {
111        memcpy(mctx->buf, data, MD5_BLOCK_SIZE);
112        _md5_process(mctx->state, mctx->buf);
113        data += MD5_BLOCK_SIZE;
114        len -= MD5_BLOCK_SIZE;
115    }
116
117store:
118    _md5_ip5k_get_digest(mctx->state);
119    hw_crypto_unlock();
120
121store_only:
122    /* anything left? */
123    if (len)
124        memcpy(mctx->buf + index , data, len);
125}
126
127/* Add padding and return the message digest. */
128static void md5_final(struct crypto_tfm *tfm, u8 *out)
129{
130    struct ubicom32_md5_ctx *mctx = crypto_tfm_ctx(tfm);
131    u32 bits[2];
132    unsigned int index, end;
133
134    /* must perform manual padding */
135    index = mctx->count & 0x3f;
136    end = (index < 56) ? MD5_BLOCK_SIZE : (2 * MD5_BLOCK_SIZE);
137
138    /* start pad with 1 */
139    mctx->buf[index] = 0x80;
140
141    /* pad with zeros */
142    index++;
143    memset(mctx->buf + index, 0x00, end - index - 8);
144
145    /* append message length */
146    bits[0] = mctx->count << 3;
147    bits[1] = mctx->count >> 29;
148    __cpu_to_le32s(bits);
149    __cpu_to_le32s(bits + 1);
150
151    memcpy(mctx->buf + end - 8, &bits, sizeof(bits));
152
153    /* force to use the mctx->buf and ignore the partial buf */
154    mctx->count = mctx->count & ~0x3f;
155    md5_update(tfm, mctx->buf, end);
156
157    /* copy digest to out */
158    memcpy(out, mctx->state, MD5_DIGEST_SIZE);
159
160    /* wipe context */
161    memset(mctx, 0, sizeof *mctx);
162}
163
164static struct crypto_alg alg = {
165    .cra_name = "md5",
166    .cra_driver_name= "md5-ubicom32",
167    .cra_priority = CRYPTO_UBICOM32_PRIORITY,
168    .cra_flags = CRYPTO_ALG_TYPE_DIGEST,
169    .cra_blocksize = MD5_BLOCK_SIZE,
170    .cra_ctxsize = sizeof(struct ubicom32_md5_ctx),
171    .cra_module = THIS_MODULE,
172    .cra_list = LIST_HEAD_INIT(alg.cra_list),
173    .cra_u = {
174        .digest = {
175            .dia_digestsize = MD5_DIGEST_SIZE,
176            .dia_init = md5_init,
177            .dia_update = md5_update,
178            .dia_final = md5_final,
179        }
180    }
181};
182
183static int __init init(void)
184{
185    hw_crypto_init();
186    return crypto_register_alg(&alg);
187}
188
189static void __exit fini(void)
190{
191    crypto_unregister_alg(&alg);
192}
193
194module_init(init);
195module_exit(fini);
196
197MODULE_ALIAS("md5");
198
199MODULE_LICENSE("GPL");
200MODULE_DESCRIPTION("MD5 Secure Hash Algorithm");
201

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive