Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/net/sunrpc/gss_krb5_crypto.c |
| 3 | * |
| 4 | * Copyright (c) 2000 The Regents of the University of Michigan. |
| 5 | * All rights reserved. |
| 6 | * |
| 7 | * Andy Adamson <andros@umich.edu> |
| 8 | * Bruce Fields <bfields@umich.edu> |
| 9 | */ |
| 10 | |
| 11 | /* |
| 12 | * Copyright (C) 1998 by the FundsXpress, INC. |
| 13 | * |
| 14 | * All rights reserved. |
| 15 | * |
| 16 | * Export of this software from the United States of America may require |
| 17 | * a specific license from the United States Government. It is the |
| 18 | * responsibility of any person or organization contemplating export to |
| 19 | * obtain such a license before exporting. |
| 20 | * |
| 21 | * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and |
| 22 | * distribute this software and its documentation for any purpose and |
| 23 | * without fee is hereby granted, provided that the above copyright |
| 24 | * notice appear in all copies and that both that copyright notice and |
| 25 | * this permission notice appear in supporting documentation, and that |
| 26 | * the name of FundsXpress. not be used in advertising or publicity pertaining |
| 27 | * to distribution of the software without specific, written prior |
| 28 | * permission. FundsXpress makes no representations about the suitability of |
| 29 | * this software for any purpose. It is provided "as is" without express |
| 30 | * or implied warranty. |
| 31 | * |
| 32 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR |
| 33 | * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED |
| 34 | * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
| 35 | */ |
| 36 | |
| 37 | #include <linux/types.h> |
| 38 | #include <linux/mm.h> |
| 39 | #include <linux/slab.h> |
David Hardeman | 378f058 | 2005-09-17 17:55:31 +1000 | [diff] [blame] | 40 | #include <linux/scatterlist.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | #include <linux/crypto.h> |
| 42 | #include <linux/highmem.h> |
| 43 | #include <linux/pagemap.h> |
| 44 | #include <linux/sunrpc/gss_krb5.h> |
| 45 | |
| 46 | #ifdef RPC_DEBUG |
| 47 | # define RPCDBG_FACILITY RPCDBG_AUTH |
| 48 | #endif |
| 49 | |
| 50 | u32 |
| 51 | krb5_encrypt( |
| 52 | struct crypto_tfm *tfm, |
| 53 | void * iv, |
| 54 | void * in, |
| 55 | void * out, |
| 56 | int length) |
| 57 | { |
| 58 | u32 ret = -EINVAL; |
| 59 | struct scatterlist sg[1]; |
| 60 | u8 local_iv[16] = {0}; |
| 61 | |
| 62 | dprintk("RPC: krb5_encrypt: input data:\n"); |
| 63 | print_hexl((u32 *)in, length, 0); |
| 64 | |
| 65 | if (length % crypto_tfm_alg_blocksize(tfm) != 0) |
| 66 | goto out; |
| 67 | |
| 68 | if (crypto_tfm_alg_ivsize(tfm) > 16) { |
| 69 | dprintk("RPC: gss_k5encrypt: tfm iv size to large %d\n", |
| 70 | crypto_tfm_alg_ivsize(tfm)); |
| 71 | goto out; |
| 72 | } |
| 73 | |
| 74 | if (iv) |
| 75 | memcpy(local_iv, iv, crypto_tfm_alg_ivsize(tfm)); |
| 76 | |
| 77 | memcpy(out, in, length); |
Herbert Xu | 6df5b9f | 2005-09-19 22:30:11 +1000 | [diff] [blame] | 78 | sg_set_buf(sg, out, length); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | |
| 80 | ret = crypto_cipher_encrypt_iv(tfm, sg, sg, length, local_iv); |
| 81 | |
| 82 | dprintk("RPC: krb5_encrypt: output data:\n"); |
| 83 | print_hexl((u32 *)out, length, 0); |
| 84 | out: |
| 85 | dprintk("RPC: krb5_encrypt returns %d\n",ret); |
| 86 | return(ret); |
| 87 | } |
| 88 | |
| 89 | EXPORT_SYMBOL(krb5_encrypt); |
| 90 | |
| 91 | u32 |
| 92 | krb5_decrypt( |
| 93 | struct crypto_tfm *tfm, |
| 94 | void * iv, |
| 95 | void * in, |
| 96 | void * out, |
| 97 | int length) |
| 98 | { |
| 99 | u32 ret = -EINVAL; |
| 100 | struct scatterlist sg[1]; |
| 101 | u8 local_iv[16] = {0}; |
| 102 | |
| 103 | dprintk("RPC: krb5_decrypt: input data:\n"); |
| 104 | print_hexl((u32 *)in, length, 0); |
| 105 | |
| 106 | if (length % crypto_tfm_alg_blocksize(tfm) != 0) |
| 107 | goto out; |
| 108 | |
| 109 | if (crypto_tfm_alg_ivsize(tfm) > 16) { |
| 110 | dprintk("RPC: gss_k5decrypt: tfm iv size to large %d\n", |
| 111 | crypto_tfm_alg_ivsize(tfm)); |
| 112 | goto out; |
| 113 | } |
| 114 | if (iv) |
| 115 | memcpy(local_iv,iv, crypto_tfm_alg_ivsize(tfm)); |
| 116 | |
| 117 | memcpy(out, in, length); |
Herbert Xu | 6df5b9f | 2005-09-19 22:30:11 +1000 | [diff] [blame] | 118 | sg_set_buf(sg, out, length); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | |
| 120 | ret = crypto_cipher_decrypt_iv(tfm, sg, sg, length, local_iv); |
| 121 | |
| 122 | dprintk("RPC: krb5_decrypt: output_data:\n"); |
| 123 | print_hexl((u32 *)out, length, 0); |
| 124 | out: |
| 125 | dprintk("RPC: gss_k5decrypt returns %d\n",ret); |
| 126 | return(ret); |
| 127 | } |
| 128 | |
| 129 | EXPORT_SYMBOL(krb5_decrypt); |
| 130 | |
J. Bruce Fields | f7b3af6 | 2005-10-13 16:55:03 -0400 | [diff] [blame] | 131 | static int |
| 132 | process_xdr_buf(struct xdr_buf *buf, int offset, int len, |
| 133 | int (*actor)(struct scatterlist *, void *), void *data) |
| 134 | { |
| 135 | int i, page_len, thislen, page_offset, ret = 0; |
| 136 | struct scatterlist sg[1]; |
| 137 | |
| 138 | if (offset >= buf->head[0].iov_len) { |
| 139 | offset -= buf->head[0].iov_len; |
| 140 | } else { |
| 141 | thislen = buf->head[0].iov_len - offset; |
| 142 | if (thislen > len) |
| 143 | thislen = len; |
David Hardeman | 378f058 | 2005-09-17 17:55:31 +1000 | [diff] [blame] | 144 | sg_set_buf(sg, buf->head[0].iov_base + offset, thislen); |
J. Bruce Fields | f7b3af6 | 2005-10-13 16:55:03 -0400 | [diff] [blame] | 145 | ret = actor(sg, data); |
| 146 | if (ret) |
| 147 | goto out; |
| 148 | offset = 0; |
| 149 | len -= thislen; |
| 150 | } |
| 151 | if (len == 0) |
| 152 | goto out; |
| 153 | |
| 154 | if (offset >= buf->page_len) { |
| 155 | offset -= buf->page_len; |
| 156 | } else { |
| 157 | page_len = buf->page_len - offset; |
| 158 | if (page_len > len) |
| 159 | page_len = len; |
| 160 | len -= page_len; |
| 161 | page_offset = (offset + buf->page_base) & (PAGE_CACHE_SIZE - 1); |
| 162 | i = (offset + buf->page_base) >> PAGE_CACHE_SHIFT; |
| 163 | thislen = PAGE_CACHE_SIZE - page_offset; |
| 164 | do { |
| 165 | if (thislen > page_len) |
| 166 | thislen = page_len; |
| 167 | sg->page = buf->pages[i]; |
| 168 | sg->offset = page_offset; |
| 169 | sg->length = thislen; |
| 170 | ret = actor(sg, data); |
| 171 | if (ret) |
| 172 | goto out; |
| 173 | page_len -= thislen; |
| 174 | i++; |
| 175 | page_offset = 0; |
| 176 | thislen = PAGE_CACHE_SIZE; |
| 177 | } while (page_len != 0); |
| 178 | offset = 0; |
| 179 | } |
| 180 | if (len == 0) |
| 181 | goto out; |
| 182 | |
| 183 | if (offset < buf->tail[0].iov_len) { |
| 184 | thislen = buf->tail[0].iov_len - offset; |
| 185 | if (thislen > len) |
| 186 | thislen = len; |
David Hardeman | 378f058 | 2005-09-17 17:55:31 +1000 | [diff] [blame] | 187 | sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen); |
J. Bruce Fields | f7b3af6 | 2005-10-13 16:55:03 -0400 | [diff] [blame] | 188 | ret = actor(sg, data); |
| 189 | len -= thislen; |
| 190 | } |
| 191 | if (len != 0) |
| 192 | ret = -EINVAL; |
| 193 | out: |
| 194 | return ret; |
| 195 | } |
| 196 | |
| 197 | static int |
| 198 | checksummer(struct scatterlist *sg, void *data) |
| 199 | { |
| 200 | struct crypto_tfm *tfm = (struct crypto_tfm *)data; |
| 201 | |
| 202 | crypto_digest_update(tfm, sg, 1); |
| 203 | |
| 204 | return 0; |
| 205 | } |
| 206 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | /* checksum the plaintext data and hdrlen bytes of the token header */ |
| 208 | s32 |
| 209 | make_checksum(s32 cksumtype, char *header, int hdrlen, struct xdr_buf *body, |
J. Bruce Fields | 14ae162 | 2005-10-13 16:55:13 -0400 | [diff] [blame] | 210 | int body_offset, struct xdr_netobj *cksum) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | { |
| 212 | char *cksumname; |
| 213 | struct crypto_tfm *tfm = NULL; /* XXX add to ctx? */ |
| 214 | struct scatterlist sg[1]; |
| 215 | u32 code = GSS_S_FAILURE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | |
| 217 | switch (cksumtype) { |
| 218 | case CKSUMTYPE_RSA_MD5: |
| 219 | cksumname = "md5"; |
| 220 | break; |
| 221 | default: |
| 222 | dprintk("RPC: krb5_make_checksum:" |
| 223 | " unsupported checksum %d", cksumtype); |
| 224 | goto out; |
| 225 | } |
Herbert Xu | eb6f116 | 2005-09-01 17:43:25 -0700 | [diff] [blame] | 226 | if (!(tfm = crypto_alloc_tfm(cksumname, CRYPTO_TFM_REQ_MAY_SLEEP))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | goto out; |
| 228 | cksum->len = crypto_tfm_alg_digestsize(tfm); |
| 229 | if ((cksum->data = kmalloc(cksum->len, GFP_KERNEL)) == NULL) |
| 230 | goto out; |
| 231 | |
| 232 | crypto_digest_init(tfm); |
David Hardeman | 378f058 | 2005-09-17 17:55:31 +1000 | [diff] [blame] | 233 | sg_set_buf(sg, header, hdrlen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | crypto_digest_update(tfm, sg, 1); |
J. Bruce Fields | 14ae162 | 2005-10-13 16:55:13 -0400 | [diff] [blame] | 235 | process_xdr_buf(body, body_offset, body->len - body_offset, |
| 236 | checksummer, tfm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | crypto_digest_final(tfm, cksum->data); |
| 238 | code = 0; |
| 239 | out: |
Jesper Juhl | 573dbd9 | 2005-09-01 17:44:29 -0700 | [diff] [blame] | 240 | crypto_free_tfm(tfm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | return code; |
| 242 | } |
| 243 | |
| 244 | EXPORT_SYMBOL(make_checksum); |
J. Bruce Fields | 14ae162 | 2005-10-13 16:55:13 -0400 | [diff] [blame] | 245 | |
| 246 | struct encryptor_desc { |
| 247 | u8 iv[8]; /* XXX hard-coded blocksize */ |
| 248 | struct crypto_tfm *tfm; |
| 249 | int pos; |
| 250 | struct xdr_buf *outbuf; |
| 251 | struct page **pages; |
| 252 | struct scatterlist infrags[4]; |
| 253 | struct scatterlist outfrags[4]; |
| 254 | int fragno; |
| 255 | int fraglen; |
| 256 | }; |
| 257 | |
| 258 | static int |
| 259 | encryptor(struct scatterlist *sg, void *data) |
| 260 | { |
| 261 | struct encryptor_desc *desc = data; |
| 262 | struct xdr_buf *outbuf = desc->outbuf; |
| 263 | struct page *in_page; |
| 264 | int thislen = desc->fraglen + sg->length; |
| 265 | int fraglen, ret; |
| 266 | int page_pos; |
| 267 | |
| 268 | /* Worst case is 4 fragments: head, end of page 1, start |
| 269 | * of page 2, tail. Anything more is a bug. */ |
| 270 | BUG_ON(desc->fragno > 3); |
| 271 | desc->infrags[desc->fragno] = *sg; |
| 272 | desc->outfrags[desc->fragno] = *sg; |
| 273 | |
| 274 | page_pos = desc->pos - outbuf->head[0].iov_len; |
| 275 | if (page_pos >= 0 && page_pos < outbuf->page_len) { |
| 276 | /* pages are not in place: */ |
| 277 | int i = (page_pos + outbuf->page_base) >> PAGE_CACHE_SHIFT; |
| 278 | in_page = desc->pages[i]; |
| 279 | } else { |
| 280 | in_page = sg->page; |
| 281 | } |
| 282 | desc->infrags[desc->fragno].page = in_page; |
| 283 | desc->fragno++; |
| 284 | desc->fraglen += sg->length; |
| 285 | desc->pos += sg->length; |
| 286 | |
| 287 | fraglen = thislen & 7; /* XXX hardcoded blocksize */ |
| 288 | thislen -= fraglen; |
| 289 | |
| 290 | if (thislen == 0) |
| 291 | return 0; |
| 292 | |
| 293 | ret = crypto_cipher_encrypt_iv(desc->tfm, desc->outfrags, desc->infrags, |
| 294 | thislen, desc->iv); |
| 295 | if (ret) |
| 296 | return ret; |
| 297 | if (fraglen) { |
| 298 | desc->outfrags[0].page = sg->page; |
| 299 | desc->outfrags[0].offset = sg->offset + sg->length - fraglen; |
| 300 | desc->outfrags[0].length = fraglen; |
| 301 | desc->infrags[0] = desc->outfrags[0]; |
| 302 | desc->infrags[0].page = in_page; |
| 303 | desc->fragno = 1; |
| 304 | desc->fraglen = fraglen; |
| 305 | } else { |
| 306 | desc->fragno = 0; |
| 307 | desc->fraglen = 0; |
| 308 | } |
| 309 | return 0; |
| 310 | } |
| 311 | |
| 312 | int |
| 313 | gss_encrypt_xdr_buf(struct crypto_tfm *tfm, struct xdr_buf *buf, int offset, |
| 314 | struct page **pages) |
| 315 | { |
| 316 | int ret; |
| 317 | struct encryptor_desc desc; |
| 318 | |
| 319 | BUG_ON((buf->len - offset) % crypto_tfm_alg_blocksize(tfm) != 0); |
| 320 | |
| 321 | memset(desc.iv, 0, sizeof(desc.iv)); |
| 322 | desc.tfm = tfm; |
| 323 | desc.pos = offset; |
| 324 | desc.outbuf = buf; |
| 325 | desc.pages = pages; |
| 326 | desc.fragno = 0; |
| 327 | desc.fraglen = 0; |
| 328 | |
| 329 | ret = process_xdr_buf(buf, offset, buf->len - offset, encryptor, &desc); |
| 330 | return ret; |
| 331 | } |
| 332 | |
| 333 | EXPORT_SYMBOL(gss_encrypt_xdr_buf); |
| 334 | |
| 335 | struct decryptor_desc { |
| 336 | u8 iv[8]; /* XXX hard-coded blocksize */ |
| 337 | struct crypto_tfm *tfm; |
| 338 | struct scatterlist frags[4]; |
| 339 | int fragno; |
| 340 | int fraglen; |
| 341 | }; |
| 342 | |
| 343 | static int |
| 344 | decryptor(struct scatterlist *sg, void *data) |
| 345 | { |
| 346 | struct decryptor_desc *desc = data; |
| 347 | int thislen = desc->fraglen + sg->length; |
| 348 | int fraglen, ret; |
| 349 | |
| 350 | /* Worst case is 4 fragments: head, end of page 1, start |
| 351 | * of page 2, tail. Anything more is a bug. */ |
| 352 | BUG_ON(desc->fragno > 3); |
| 353 | desc->frags[desc->fragno] = *sg; |
| 354 | desc->fragno++; |
| 355 | desc->fraglen += sg->length; |
| 356 | |
| 357 | fraglen = thislen & 7; /* XXX hardcoded blocksize */ |
| 358 | thislen -= fraglen; |
| 359 | |
| 360 | if (thislen == 0) |
| 361 | return 0; |
| 362 | |
| 363 | ret = crypto_cipher_decrypt_iv(desc->tfm, desc->frags, desc->frags, |
| 364 | thislen, desc->iv); |
| 365 | if (ret) |
| 366 | return ret; |
| 367 | if (fraglen) { |
| 368 | desc->frags[0].page = sg->page; |
| 369 | desc->frags[0].offset = sg->offset + sg->length - fraglen; |
| 370 | desc->frags[0].length = fraglen; |
| 371 | desc->fragno = 1; |
| 372 | desc->fraglen = fraglen; |
| 373 | } else { |
| 374 | desc->fragno = 0; |
| 375 | desc->fraglen = 0; |
| 376 | } |
| 377 | return 0; |
| 378 | } |
| 379 | |
| 380 | int |
| 381 | gss_decrypt_xdr_buf(struct crypto_tfm *tfm, struct xdr_buf *buf, int offset) |
| 382 | { |
| 383 | struct decryptor_desc desc; |
| 384 | |
| 385 | /* XXXJBF: */ |
| 386 | BUG_ON((buf->len - offset) % crypto_tfm_alg_blocksize(tfm) != 0); |
| 387 | |
| 388 | memset(desc.iv, 0, sizeof(desc.iv)); |
| 389 | desc.tfm = tfm; |
| 390 | desc.fragno = 0; |
| 391 | desc.fraglen = 0; |
| 392 | return process_xdr_buf(buf, offset, buf->len - offset, decryptor, &desc); |
| 393 | } |
| 394 | |
| 395 | EXPORT_SYMBOL(gss_decrypt_xdr_buf); |