URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [crypto/] [crypto_null.c] - Blame information for rev 86

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * Cryptographic API.
 *
 * Null algorithms, aka Much Ado About Nothing.
 *
 * These are needed for IPsec, and may be useful in general for
 * testing & debugging.
 *
 * The null cipher is compliant with RFC2410.
 *
 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/crypto.h>
#include <linux/string.h>
 
#define NULL_KEY_SIZE           0
#define NULL_BLOCK_SIZE         1
#define NULL_DIGEST_SIZE        0
 
static int null_compress(struct crypto_tfm *tfm, const u8 *src,
                         unsigned int slen, u8 *dst, unsigned int *dlen)
{
        if (slen > *dlen)
                return -EINVAL;
        memcpy(dst, src, slen);
        *dlen = slen;
        return 0;
}
 
static void null_init(struct crypto_tfm *tfm)
{ }
 
static void null_update(struct crypto_tfm *tfm, const u8 *data,
                        unsigned int len)
{ }
 
static void null_final(struct crypto_tfm *tfm, u8 *out)
{ }
 
static int null_setkey(struct crypto_tfm *tfm, const u8 *key,
                       unsigned int keylen)
{ return 0; }
 
static void null_crypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
        memcpy(dst, src, NULL_BLOCK_SIZE);
}
 
static struct crypto_alg compress_null = {
        .cra_name               =       "compress_null",
        .cra_flags              =       CRYPTO_ALG_TYPE_COMPRESS,
        .cra_blocksize          =       NULL_BLOCK_SIZE,
        .cra_ctxsize            =       0,
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(compress_null.cra_list),
        .cra_u                  =       { .compress = {
        .coa_compress           =       null_compress,
        .coa_decompress         =       null_compress } }
};
 
static struct crypto_alg digest_null = {
        .cra_name               =       "digest_null",
        .cra_flags              =       CRYPTO_ALG_TYPE_DIGEST,
        .cra_blocksize          =       NULL_BLOCK_SIZE,
        .cra_ctxsize            =       0,
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(digest_null.cra_list),
        .cra_u                  =       { .digest = {
        .dia_digestsize         =       NULL_DIGEST_SIZE,
        .dia_init               =       null_init,
        .dia_update             =       null_update,
        .dia_final              =       null_final } }
};
 
static struct crypto_alg cipher_null = {
        .cra_name               =       "cipher_null",
        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
        .cra_blocksize          =       NULL_BLOCK_SIZE,
        .cra_ctxsize            =       0,
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(cipher_null.cra_list),
        .cra_u                  =       { .cipher = {
        .cia_min_keysize        =       NULL_KEY_SIZE,
        .cia_max_keysize        =       NULL_KEY_SIZE,
        .cia_setkey             =       null_setkey,
        .cia_encrypt            =       null_crypt,
        .cia_decrypt            =       null_crypt } }
};
 
MODULE_ALIAS("compress_null");
MODULE_ALIAS("digest_null");
MODULE_ALIAS("cipher_null");
 
static int __init init(void)
{
        int ret = 0;
 
        ret = crypto_register_alg(&cipher_null);
        if (ret < 0)
                goto out;
 
        ret = crypto_register_alg(&digest_null);
        if (ret < 0) {
                crypto_unregister_alg(&cipher_null);
                goto out;
        }
 
        ret = crypto_register_alg(&compress_null);
        if (ret < 0) {
                crypto_unregister_alg(&digest_null);
                crypto_unregister_alg(&cipher_null);
                goto out;
        }
 
out:
        return ret;
}
 
static void __exit fini(void)
{
        crypto_unregister_alg(&compress_null);
        crypto_unregister_alg(&digest_null);
        crypto_unregister_alg(&cipher_null);
}
 
module_init(init);
module_exit(fini);
 
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Null Cryptographic Algorithms");

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
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			`#include <linux/init.h>`
20			`#include <linux/module.h>`
21			`#include <linux/mm.h>`
22			`#include <linux/crypto.h>`
23			`#include <linux/string.h>`
24
25			`#define NULL_KEY_SIZE 0`
26			`#define NULL_BLOCK_SIZE 1`
27			`#define NULL_DIGEST_SIZE 0`
28
29			`static int null_compress(struct crypto_tfm tfm, const u8 src,`
30			`unsigned int slen, u8 dst, unsigned int dlen)`
31			`{`
32			`if (slen > *dlen)`
33			`return -EINVAL;`
34			`memcpy(dst, src, slen);`
35			`*dlen = slen;`
36			`return 0;`
37			`}`
38
39			`static void null_init(struct crypto_tfm *tfm)`
40			`{ }`
41
42			`static void null_update(struct crypto_tfm tfm, const u8 data,`
43			`unsigned int len)`
44			`{ }`
45
46			`static void null_final(struct crypto_tfm tfm, u8 out)`
47			`{ }`
48
49			`static int null_setkey(struct crypto_tfm tfm, const u8 key,`
50			`unsigned int keylen)`
51			`{ return 0; }`
52
53			`static void null_crypt(struct crypto_tfm tfm, u8 dst, const u8 *src)`
54			`{`
55			`memcpy(dst, src, NULL_BLOCK_SIZE);`
56			`}`
57
58			`static struct crypto_alg compress_null = {`
59			`.cra_name = "compress_null",`
60			`.cra_flags = CRYPTO_ALG_TYPE_COMPRESS,`
61			`.cra_blocksize = NULL_BLOCK_SIZE,`
62			`.cra_ctxsize = 0,`
63			`.cra_module = THIS_MODULE,`
64			`.cra_list = LIST_HEAD_INIT(compress_null.cra_list),`
65			`.cra_u = { .compress = {`
66			`.coa_compress = null_compress,`
67			`.coa_decompress = null_compress } }`
68			`};`
69
70			`static struct crypto_alg digest_null = {`
71			`.cra_name = "digest_null",`
72			`.cra_flags = CRYPTO_ALG_TYPE_DIGEST,`
73			`.cra_blocksize = NULL_BLOCK_SIZE,`
74			`.cra_ctxsize = 0,`
75			`.cra_module = THIS_MODULE,`
76			`.cra_list = LIST_HEAD_INIT(digest_null.cra_list),`
77			`.cra_u = { .digest = {`
78			`.dia_digestsize = NULL_DIGEST_SIZE,`
79			`.dia_init = null_init,`
80			`.dia_update = null_update,`
81			`.dia_final = null_final } }`
82			`};`
83
84			`static struct crypto_alg cipher_null = {`
85			`.cra_name = "cipher_null",`
86			`.cra_flags = CRYPTO_ALG_TYPE_CIPHER,`
87			`.cra_blocksize = NULL_BLOCK_SIZE,`
88			`.cra_ctxsize = 0,`
89			`.cra_module = THIS_MODULE,`
90			`.cra_list = LIST_HEAD_INIT(cipher_null.cra_list),`
91			`.cra_u = { .cipher = {`
92			`.cia_min_keysize = NULL_KEY_SIZE,`
93			`.cia_max_keysize = NULL_KEY_SIZE,`
94			`.cia_setkey = null_setkey,`
95			`.cia_encrypt = null_crypt,`
96			`.cia_decrypt = null_crypt } }`
97			`};`
98
99			`MODULE_ALIAS("compress_null");`
100			`MODULE_ALIAS("digest_null");`
101			`MODULE_ALIAS("cipher_null");`
102
103			`static int __init init(void)`
104			`{`
105			`int ret = 0;`
106
107			`ret = crypto_register_alg(&cipher_null);`
108			`if (ret < 0)`
109			`goto out;`
110
111			`ret = crypto_register_alg(&digest_null);`
112			`if (ret < 0) {`
113			`crypto_unregister_alg(&cipher_null);`
114			`goto out;`
115			`}`
116
117			`ret = crypto_register_alg(&compress_null);`
118			`if (ret < 0) {`
119			`crypto_unregister_alg(&digest_null);`
120			`crypto_unregister_alg(&cipher_null);`
121			`goto out;`
122			`}`
123
124			`out:`
125			`return ret;`
126			`}`
127
128			`static void __exit fini(void)`
129			`{`
130			`crypto_unregister_alg(&compress_null);`
131			`crypto_unregister_alg(&digest_null);`
132			`crypto_unregister_alg(&cipher_null);`
133			`}`
134
135			`module_init(init);`
136			`module_exit(fini);`
137
138			`MODULE_LICENSE("GPL");`
139			`MODULE_DESCRIPTION("Null Cryptographic Algorithms");`

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [crypto/] [crypto_null.c] - Blame information for rev 86