← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to crypto/crypto_null.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/crypto_null.c
 
1
/*
 
2
 * Cryptographic API.
 
3
 *
 
4
 * Null algorithms, aka Much Ado About Nothing.
 
5
 *
 
6
 * These are needed for IPsec, and may be useful in general for
 
7
 * testing & debugging.
 
8
 *
 
9
 * The null cipher is compliant with RFC2410.
 
10
 *
 
11
 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
 
12
 *
 
13
 * This program is free software; you can redistribute it and/or modify
 
14
 * it under the terms of the GNU General Public License as published by
 
15
 * the Free Software Foundation; either version 2 of the License, or
 
16
 * (at your option) any later version.
 
17
 *
 
18
 */
 
19
 
 
20
#include <crypto/internal/hash.h>
 
21
#include <crypto/internal/skcipher.h>
 
22
#include <linux/init.h>
 
23
#include <linux/module.h>
 
24
#include <linux/mm.h>
 
25
#include <linux/string.h>
 
26
 
 
27
#define NULL_KEY_SIZE           0
 
28
#define NULL_BLOCK_SIZE         1
 
29
#define NULL_DIGEST_SIZE        0
 
30
#define NULL_IV_SIZE            0
 
31
 
 
32
static int null_compress(struct crypto_tfm *tfm, const u8 *src,
 
33
                         unsigned int slen, u8 *dst, unsigned int *dlen)
 
34
{
 
35
        if (slen > *dlen)
 
36
                return -EINVAL;
 
37
        memcpy(dst, src, slen);
 
38
        *dlen = slen;
 
39
        return 0;
 
40
}
 
41
 
 
42
static int null_init(struct shash_desc *desc)
 
43
{
 
44
        return 0;
 
45
}
 
46
 
 
47
static int null_update(struct shash_desc *desc, const u8 *data,
 
48
                       unsigned int len)
 
49
{
 
50
        return 0;
 
51
}
 
52
 
 
53
static int null_final(struct shash_desc *desc, u8 *out)
 
54
{
 
55
        return 0;
 
56
}
 
57
 
 
58
static int null_digest(struct shash_desc *desc, const u8 *data,
 
59
                       unsigned int len, u8 *out)
 
60
{
 
61
        return 0;
 
62
}
 
63
 
 
64
static int null_hash_setkey(struct crypto_shash *tfm, const u8 *key,
 
65
                            unsigned int keylen)
 
66
{ return 0; }
 
67
 
 
68
static int null_setkey(struct crypto_tfm *tfm, const u8 *key,
 
69
                       unsigned int keylen)
 
70
{ return 0; }
 
71
 
 
72
static void null_crypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 
73
{
 
74
        memcpy(dst, src, NULL_BLOCK_SIZE);
 
75
}
 
76
 
 
77
static int skcipher_null_crypt(struct blkcipher_desc *desc,
 
78
                               struct scatterlist *dst,
 
79
                               struct scatterlist *src, unsigned int nbytes)
 
80
{
 
81
        struct blkcipher_walk walk;
 
82
        int err;
 
83
 
 
84
        blkcipher_walk_init(&walk, dst, src, nbytes);
 
85
        err = blkcipher_walk_virt(desc, &walk);
 
86
 
 
87
        while (walk.nbytes) {
 
88
                if (walk.src.virt.addr != walk.dst.virt.addr)
 
89
                        memcpy(walk.dst.virt.addr, walk.src.virt.addr,
 
90
                               walk.nbytes);
 
91
                err = blkcipher_walk_done(desc, &walk, 0);
 
92
        }
 
93
 
 
94
        return err;
 
95
}
 
96
 
 
97
static struct crypto_alg compress_null = {
 
98
        .cra_name               =       "compress_null",
 
99
        .cra_flags              =       CRYPTO_ALG_TYPE_COMPRESS,
 
100
        .cra_blocksize          =       NULL_BLOCK_SIZE,
 
101
        .cra_ctxsize            =       0,
 
102
        .cra_module             =       THIS_MODULE,
 
103
        .cra_list               =       LIST_HEAD_INIT(compress_null.cra_list),
 
104
        .cra_u                  =       { .compress = {
 
105
        .coa_compress           =       null_compress,
 
106
        .coa_decompress         =       null_compress } }
 
107
};
 
108
 
 
109
static struct shash_alg digest_null = {
 
110
        .digestsize             =       NULL_DIGEST_SIZE,
 
111
        .setkey                 =       null_hash_setkey,
 
112
        .init                   =       null_init,
 
113
        .update                 =       null_update,
 
114
        .finup                  =       null_digest,
 
115
        .digest                 =       null_digest,
 
116
        .final                  =       null_final,
 
117
        .base                   =       {
 
118
                .cra_name               =       "digest_null",
 
119
                .cra_flags              =       CRYPTO_ALG_TYPE_SHASH,
 
120
                .cra_blocksize          =       NULL_BLOCK_SIZE,
 
121
                .cra_module             =       THIS_MODULE,
 
122
        }
 
123
};
 
124
 
 
125
static struct crypto_alg cipher_null = {
 
126
        .cra_name               =       "cipher_null",
 
127
        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 
128
        .cra_blocksize          =       NULL_BLOCK_SIZE,
 
129
        .cra_ctxsize            =       0,
 
130
        .cra_module             =       THIS_MODULE,
 
131
        .cra_list               =       LIST_HEAD_INIT(cipher_null.cra_list),
 
132
        .cra_u                  =       { .cipher = {
 
133
        .cia_min_keysize        =       NULL_KEY_SIZE,
 
134
        .cia_max_keysize        =       NULL_KEY_SIZE,
 
135
        .cia_setkey             =       null_setkey,
 
136
        .cia_encrypt            =       null_crypt,
 
137
        .cia_decrypt            =       null_crypt } }
 
138
};
 
139
 
 
140
static struct crypto_alg skcipher_null = {
 
141
        .cra_name               =       "ecb(cipher_null)",
 
142
        .cra_driver_name        =       "ecb-cipher_null",
 
143
        .cra_priority           =       100,
 
144
        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
 
145
        .cra_blocksize          =       NULL_BLOCK_SIZE,
 
146
        .cra_type               =       &crypto_blkcipher_type,
 
147
        .cra_ctxsize            =       0,
 
148
        .cra_module             =       THIS_MODULE,
 
149
        .cra_list               =       LIST_HEAD_INIT(skcipher_null.cra_list),
 
150
        .cra_u                  =       { .blkcipher = {
 
151
        .min_keysize            =       NULL_KEY_SIZE,
 
152
        .max_keysize            =       NULL_KEY_SIZE,
 
153
        .ivsize                 =       NULL_IV_SIZE,
 
154
        .setkey                 =       null_setkey,
 
155
        .encrypt                =       skcipher_null_crypt,
 
156
        .decrypt                =       skcipher_null_crypt } }
 
157
};
 
158
 
 
159
MODULE_ALIAS("compress_null");
 
160
MODULE_ALIAS("digest_null");
 
161
MODULE_ALIAS("cipher_null");
 
162
 
 
163
static int __init crypto_null_mod_init(void)
 
164
{
 
165
        int ret = 0;
 
166
 
 
167
        ret = crypto_register_alg(&cipher_null);
 
168
        if (ret < 0)
 
169
                goto out;
 
170
 
 
171
        ret = crypto_register_alg(&skcipher_null);
 
172
        if (ret < 0)
 
173
                goto out_unregister_cipher;
 
174
 
 
175
        ret = crypto_register_shash(&digest_null);
 
176
        if (ret < 0)
 
177
                goto out_unregister_skcipher;
 
178
 
 
179
        ret = crypto_register_alg(&compress_null);
 
180
        if (ret < 0)
 
181
                goto out_unregister_digest;
 
182
 
 
183
out:
 
184
        return ret;
 
185
 
 
186
out_unregister_digest:
 
187
        crypto_unregister_shash(&digest_null);
 
188
out_unregister_skcipher:
 
189
        crypto_unregister_alg(&skcipher_null);
 
190
out_unregister_cipher:
 
191
        crypto_unregister_alg(&cipher_null);
 
192
        goto out;
 
193
}
 
194
 
 
195
static void __exit crypto_null_mod_fini(void)
 
196
{
 
197
        crypto_unregister_alg(&compress_null);
 
198
        crypto_unregister_shash(&digest_null);
 
199
        crypto_unregister_alg(&skcipher_null);
 
200
        crypto_unregister_alg(&cipher_null);
 
201
}
 
202
 
 
203
module_init(crypto_null_mod_init);
 
204
module_exit(crypto_null_mod_fini);
 
205
 
 
206
MODULE_LICENSE("GPL");
 
207
MODULE_DESCRIPTION("Null Cryptographic Algorithms");