[PATCH] s390: aes support
[linux-2.6.git] / arch / s390 / crypto / aes_s390.c
1 /*
2  * Cryptographic API.
3  *
4  * s390 implementation of the AES Cipher Algorithm.
5  *
6  * s390 Version:
7  *   Copyright (C) 2005 IBM Deutschland GmbH, IBM Corporation
8  *   Author(s): Jan Glauber (jang@de.ibm.com)
9  *
10  * Derived from "crypto/aes.c"
11  *
12  * This program is free software; you can redistribute it and/or modify it
13  * under the terms of the GNU General Public License as published by the Free
14  * Software Foundation; either version 2 of the License, or (at your option)
15  * any later version.
16  *
17  */
18
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/crypto.h>
22 #include "crypt_s390.h"
23
24 #define AES_MIN_KEY_SIZE        16
25 #define AES_MAX_KEY_SIZE        32
26
27 /* data block size for all key lengths */
28 #define AES_BLOCK_SIZE          16
29
30 int has_aes_128 = 0;
31 int has_aes_192 = 0;
32 int has_aes_256 = 0;
33
34 struct s390_aes_ctx {
35         u8 iv[AES_BLOCK_SIZE];
36         u8 key[AES_MAX_KEY_SIZE];
37         int key_len;
38 };
39
40 static int aes_set_key(void *ctx, const u8 *in_key, unsigned int key_len,
41                        u32 *flags)
42 {
43         struct s390_aes_ctx *sctx = ctx;
44
45         switch (key_len) {
46         case 16:
47                 if (!has_aes_128)
48                         goto fail;
49                 break;
50         case 24:
51                 if (!has_aes_192)
52                         goto fail;
53
54                 break;
55         case 32:
56                 if (!has_aes_256)
57                         goto fail;
58                 break;
59         default:
60                 /* invalid key length */
61                 goto fail;
62                 break;
63         }
64
65         sctx->key_len = key_len;
66         memcpy(sctx->key, in_key, key_len);
67         return 0;
68 fail:
69         *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
70         return -EINVAL;
71 }
72
73 static void aes_encrypt(void *ctx, u8 *out, const u8 *in)
74 {
75         const struct s390_aes_ctx *sctx = ctx;
76
77         switch (sctx->key_len) {
78         case 16:
79                 crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in,
80                               AES_BLOCK_SIZE);
81                 break;
82         case 24:
83                 crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in,
84                               AES_BLOCK_SIZE);
85                 break;
86         case 32:
87                 crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in,
88                               AES_BLOCK_SIZE);
89                 break;
90         }
91 }
92
93 static void aes_decrypt(void *ctx, u8 *out, const u8 *in)
94 {
95         const struct s390_aes_ctx *sctx = ctx;
96
97         switch (sctx->key_len) {
98         case 16:
99                 crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in,
100                               AES_BLOCK_SIZE);
101                 break;
102         case 24:
103                 crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in,
104                               AES_BLOCK_SIZE);
105                 break;
106         case 32:
107                 crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in,
108                               AES_BLOCK_SIZE);
109                 break;
110         }
111 }
112
113 static unsigned int aes_encrypt_ecb(const struct cipher_desc *desc, u8 *out,
114                                     const u8 *in, unsigned int nbytes)
115 {
116         struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
117
118         switch (sctx->key_len) {
119         case 16:
120                 crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in, nbytes);
121                 break;
122         case 24:
123                 crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in, nbytes);
124                 break;
125         case 32:
126                 crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in, nbytes);
127                 break;
128         }
129         return nbytes & ~(AES_BLOCK_SIZE - 1);
130 }
131
132 static unsigned int aes_decrypt_ecb(const struct cipher_desc *desc, u8 *out,
133                                     const u8 *in, unsigned int nbytes)
134 {
135         struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
136
137         switch (sctx->key_len) {
138         case 16:
139                 crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in, nbytes);
140                 break;
141         case 24:
142                 crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in, nbytes);
143                 break;
144         case 32:
145                 crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in, nbytes);
146                 break;
147         }
148         return nbytes & ~(AES_BLOCK_SIZE - 1);
149 }
150
151 static unsigned int aes_encrypt_cbc(const struct cipher_desc *desc, u8 *out,
152                                     const u8 *in, unsigned int nbytes)
153 {
154         struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
155
156         memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);
157         switch (sctx->key_len) {
158         case 16:
159                 crypt_s390_kmc(KMC_AES_128_ENCRYPT, &sctx->iv, out, in, nbytes);
160                 break;
161         case 24:
162                 crypt_s390_kmc(KMC_AES_192_ENCRYPT, &sctx->iv, out, in, nbytes);
163                 break;
164         case 32:
165                 crypt_s390_kmc(KMC_AES_256_ENCRYPT, &sctx->iv, out, in, nbytes);
166                 break;
167         }
168         memcpy(desc->info, &sctx->iv, AES_BLOCK_SIZE);
169
170         return nbytes & ~(AES_BLOCK_SIZE - 1);
171 }
172
173 static unsigned int aes_decrypt_cbc(const struct cipher_desc *desc, u8 *out,
174                                     const u8 *in, unsigned int nbytes)
175 {
176         struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
177
178         memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);
179         switch (sctx->key_len) {
180         case 16:
181                 crypt_s390_kmc(KMC_AES_128_DECRYPT, &sctx->iv, out, in, nbytes);
182                 break;
183         case 24:
184                 crypt_s390_kmc(KMC_AES_192_DECRYPT, &sctx->iv, out, in, nbytes);
185                 break;
186         case 32:
187                 crypt_s390_kmc(KMC_AES_256_DECRYPT, &sctx->iv, out, in, nbytes);
188                 break;
189         }
190         return nbytes & ~(AES_BLOCK_SIZE - 1);
191 }
192
193
194 static struct crypto_alg aes_alg = {
195         .cra_name               =       "aes",
196         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
197         .cra_blocksize          =       AES_BLOCK_SIZE,
198         .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
199         .cra_module             =       THIS_MODULE,
200         .cra_list               =       LIST_HEAD_INIT(aes_alg.cra_list),
201         .cra_u                  =       {
202                 .cipher = {
203                         .cia_min_keysize        =       AES_MIN_KEY_SIZE,
204                         .cia_max_keysize        =       AES_MAX_KEY_SIZE,
205                         .cia_setkey             =       aes_set_key,
206                         .cia_encrypt            =       aes_encrypt,
207                         .cia_decrypt            =       aes_decrypt,
208                         .cia_encrypt_ecb        =       aes_encrypt_ecb,
209                         .cia_decrypt_ecb        =       aes_decrypt_ecb,
210                         .cia_encrypt_cbc        =       aes_encrypt_cbc,
211                         .cia_decrypt_cbc        =       aes_decrypt_cbc,
212                 }
213         }
214 };
215
216 static int __init aes_init(void)
217 {
218         int ret;
219
220         if (crypt_s390_func_available(KM_AES_128_ENCRYPT))
221                 has_aes_128 = 1;
222         if (crypt_s390_func_available(KM_AES_192_ENCRYPT))
223                 has_aes_192 = 1;
224         if (crypt_s390_func_available(KM_AES_256_ENCRYPT))
225                 has_aes_256 = 1;
226
227         if (!has_aes_128 && !has_aes_192 && !has_aes_256)
228                 return -ENOSYS;
229
230         ret = crypto_register_alg(&aes_alg);
231         if (ret != 0)
232                 printk(KERN_INFO "crypt_s390: aes_s390 couldn't be loaded.\n");
233         return ret;
234 }
235
236 static void __exit aes_fini(void)
237 {
238         crypto_unregister_alg(&aes_alg);
239 }
240
241 module_init(aes_init);
242 module_exit(aes_fini);
243
244 MODULE_ALIAS("aes");
245
246 MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
247 MODULE_LICENSE("GPL");
248