ia64/linux-2.6.18-xen.hg

view arch/s390/crypto/aes_s390.c @ 647:a5bb490065f6

Fix the build after public header sync.
Signed-off-by: Keir Fraser <keir.fraser@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Wed Aug 13 14:01:49 2008 +0100 (2008-08-13)
parents 831230e53067
children
line source
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 */
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/crypto.h>
22 #include "crypt_s390.h"
24 #define AES_MIN_KEY_SIZE 16
25 #define AES_MAX_KEY_SIZE 32
27 /* data block size for all key lengths */
28 #define AES_BLOCK_SIZE 16
30 int has_aes_128 = 0;
31 int has_aes_192 = 0;
32 int has_aes_256 = 0;
34 struct s390_aes_ctx {
35 u8 iv[AES_BLOCK_SIZE];
36 u8 key[AES_MAX_KEY_SIZE];
37 int key_len;
38 };
40 static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
41 unsigned int key_len, u32 *flags)
42 {
43 struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
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;
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 }
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 }
73 static void aes_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
74 {
75 const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
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 }
93 static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
94 {
95 const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
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 }
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 int ret;
119 /* only use complete blocks */
120 nbytes &= ~(AES_BLOCK_SIZE - 1);
122 switch (sctx->key_len) {
123 case 16:
124 ret = crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in, nbytes);
125 BUG_ON((ret < 0) || (ret != nbytes));
126 break;
127 case 24:
128 ret = crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in, nbytes);
129 BUG_ON((ret < 0) || (ret != nbytes));
130 break;
131 case 32:
132 ret = crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in, nbytes);
133 BUG_ON((ret < 0) || (ret != nbytes));
134 break;
135 }
136 return nbytes;
137 }
139 static unsigned int aes_decrypt_ecb(const struct cipher_desc *desc, u8 *out,
140 const u8 *in, unsigned int nbytes)
141 {
142 struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
143 int ret;
145 /* only use complete blocks */
146 nbytes &= ~(AES_BLOCK_SIZE - 1);
148 switch (sctx->key_len) {
149 case 16:
150 ret = crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in, nbytes);
151 BUG_ON((ret < 0) || (ret != nbytes));
152 break;
153 case 24:
154 ret = crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in, nbytes);
155 BUG_ON((ret < 0) || (ret != nbytes));
156 break;
157 case 32:
158 ret = crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in, nbytes);
159 BUG_ON((ret < 0) || (ret != nbytes));
160 break;
161 }
162 return nbytes;
163 }
165 static unsigned int aes_encrypt_cbc(const struct cipher_desc *desc, u8 *out,
166 const u8 *in, unsigned int nbytes)
167 {
168 struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
169 int ret;
171 /* only use complete blocks */
172 nbytes &= ~(AES_BLOCK_SIZE - 1);
174 memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);
175 switch (sctx->key_len) {
176 case 16:
177 ret = crypt_s390_kmc(KMC_AES_128_ENCRYPT, &sctx->iv, out, in, nbytes);
178 BUG_ON((ret < 0) || (ret != nbytes));
179 break;
180 case 24:
181 ret = crypt_s390_kmc(KMC_AES_192_ENCRYPT, &sctx->iv, out, in, nbytes);
182 BUG_ON((ret < 0) || (ret != nbytes));
183 break;
184 case 32:
185 ret = crypt_s390_kmc(KMC_AES_256_ENCRYPT, &sctx->iv, out, in, nbytes);
186 BUG_ON((ret < 0) || (ret != nbytes));
187 break;
188 }
189 memcpy(desc->info, &sctx->iv, AES_BLOCK_SIZE);
191 return nbytes;
192 }
194 static unsigned int aes_decrypt_cbc(const struct cipher_desc *desc, u8 *out,
195 const u8 *in, unsigned int nbytes)
196 {
197 struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
198 int ret;
200 /* only use complete blocks */
201 nbytes &= ~(AES_BLOCK_SIZE - 1);
203 memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);
204 switch (sctx->key_len) {
205 case 16:
206 ret = crypt_s390_kmc(KMC_AES_128_DECRYPT, &sctx->iv, out, in, nbytes);
207 BUG_ON((ret < 0) || (ret != nbytes));
208 break;
209 case 24:
210 ret = crypt_s390_kmc(KMC_AES_192_DECRYPT, &sctx->iv, out, in, nbytes);
211 BUG_ON((ret < 0) || (ret != nbytes));
212 break;
213 case 32:
214 ret = crypt_s390_kmc(KMC_AES_256_DECRYPT, &sctx->iv, out, in, nbytes);
215 BUG_ON((ret < 0) || (ret != nbytes));
216 break;
217 }
218 return nbytes;
219 }
222 static struct crypto_alg aes_alg = {
223 .cra_name = "aes",
224 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
225 .cra_blocksize = AES_BLOCK_SIZE,
226 .cra_ctxsize = sizeof(struct s390_aes_ctx),
227 .cra_module = THIS_MODULE,
228 .cra_list = LIST_HEAD_INIT(aes_alg.cra_list),
229 .cra_u = {
230 .cipher = {
231 .cia_min_keysize = AES_MIN_KEY_SIZE,
232 .cia_max_keysize = AES_MAX_KEY_SIZE,
233 .cia_setkey = aes_set_key,
234 .cia_encrypt = aes_encrypt,
235 .cia_decrypt = aes_decrypt,
236 .cia_encrypt_ecb = aes_encrypt_ecb,
237 .cia_decrypt_ecb = aes_decrypt_ecb,
238 .cia_encrypt_cbc = aes_encrypt_cbc,
239 .cia_decrypt_cbc = aes_decrypt_cbc,
240 }
241 }
242 };
244 static int __init aes_init(void)
245 {
246 int ret;
248 if (crypt_s390_func_available(KM_AES_128_ENCRYPT))
249 has_aes_128 = 1;
250 if (crypt_s390_func_available(KM_AES_192_ENCRYPT))
251 has_aes_192 = 1;
252 if (crypt_s390_func_available(KM_AES_256_ENCRYPT))
253 has_aes_256 = 1;
255 if (!has_aes_128 && !has_aes_192 && !has_aes_256)
256 return -ENOSYS;
258 ret = crypto_register_alg(&aes_alg);
259 if (ret != 0)
260 printk(KERN_INFO "crypt_s390: aes_s390 couldn't be loaded.\n");
261 return ret;
262 }
264 static void __exit aes_fini(void)
265 {
266 crypto_unregister_alg(&aes_alg);
267 }
269 module_init(aes_init);
270 module_exit(aes_fini);
272 MODULE_ALIAS("aes");
274 MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
275 MODULE_LICENSE("GPL");