1/* 2 * linux/net/sunrpc/gss_spkm3_seal.c 3 * 4 * Copyright (c) 2003 The Regents of the University of Michigan. 5 * All rights reserved. 6 * 7 * Andy Adamson <andros@umich.edu> 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the University nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 23 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 24 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 25 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 29 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 30 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 31 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 * 34 */ 35 36#include <linux/types.h> 37#include <linux/jiffies.h> 38#include <linux/sunrpc/gss_spkm3.h> 39#include <linux/random.h> 40#include <linux/crypto.h> 41#include <linux/pagemap.h> 42#include <linux/scatterlist.h> 43#include <linux/sunrpc/xdr.h> 44 45#ifdef RPC_DEBUG 46# define RPCDBG_FACILITY RPCDBG_AUTH 47#endif 48 49const struct xdr_netobj hmac_md5_oid = { 8, "\x2B\x06\x01\x05\x05\x08\x01\x01"}; 50const struct xdr_netobj cast5_cbc_oid = {9, "\x2A\x86\x48\x86\xF6\x7D\x07\x42\x0A"}; 51 52/* 53 * spkm3_make_token() 54 * 55 * Only SPKM_MIC_TOK with md5 intg-alg is supported 56 */ 57 58u32 59spkm3_make_token(struct spkm3_ctx *ctx, 60 struct xdr_buf * text, struct xdr_netobj * token, 61 int toktype) 62{ 63 s32 checksum_type; 64 char tokhdrbuf[25]; 65 char cksumdata[16]; 66 struct xdr_netobj md5cksum = {.len = 0, .data = cksumdata}; 67 struct xdr_netobj mic_hdr = {.len = 0, .data = tokhdrbuf}; 68 int tokenlen = 0; 69 unsigned char *ptr; 70 s32 now; 71 int ctxelen = 0, ctxzbit = 0; 72 int md5elen = 0, md5zbit = 0; 73 74 now = jiffies; 75 76 if (ctx->ctx_id.len != 16) { 77 dprintk("RPC: spkm3_make_token BAD ctx_id.len %d\n", 78 ctx->ctx_id.len); 79 goto out_err; 80 } 81 82 if (!g_OID_equal(&ctx->intg_alg, &hmac_md5_oid)) { 83 dprintk("RPC: gss_spkm3_seal: unsupported I-ALG " 84 "algorithm. only support hmac-md5 I-ALG.\n"); 85 goto out_err; 86 } else 87 checksum_type = CKSUMTYPE_HMAC_MD5; 88 89 if (!g_OID_equal(&ctx->conf_alg, &cast5_cbc_oid)) { 90 dprintk("RPC: gss_spkm3_seal: unsupported C-ALG " 91 "algorithm\n"); 92 goto out_err; 93 } 94 95 if (toktype == SPKM_MIC_TOK) { 96 /* Calculate checksum over the mic-header */ 97 asn1_bitstring_len(&ctx->ctx_id, &ctxelen, &ctxzbit); 98 spkm3_mic_header(&mic_hdr.data, &mic_hdr.len, ctx->ctx_id.data, 99 ctxelen, ctxzbit); 100 if (make_spkm3_checksum(checksum_type, &ctx->derived_integ_key, 101 (char *)mic_hdr.data, mic_hdr.len, 102 text, 0, &md5cksum)) 103 goto out_err; 104 105 asn1_bitstring_len(&md5cksum, &md5elen, &md5zbit); 106 tokenlen = 10 + ctxelen + 1 + md5elen + 1; 107 108 /* Create token header using generic routines */ 109 token->len = g_token_size(&ctx->mech_used, tokenlen + 2); 110 111 ptr = token->data; 112 g_make_token_header(&ctx->mech_used, tokenlen + 2, &ptr); 113 114 spkm3_make_mic_token(&ptr, tokenlen, &mic_hdr, &md5cksum, md5elen, md5zbit); 115 } else if (toktype == SPKM_WRAP_TOK) { /* Not Supported */ 116 dprintk("RPC: gss_spkm3_seal: SPKM_WRAP_TOK " 117 "not supported\n"); 118 goto out_err; 119 } 120 121 122 return GSS_S_COMPLETE; 123out_err: 124 token->data = NULL; 125 token->len = 0; 126 return GSS_S_FAILURE; 127} 128 129static int 130spkm3_checksummer(struct scatterlist *sg, void *data) 131{ 132 struct hash_desc *desc = data; 133 134 return crypto_hash_update(desc, sg, sg->length); 135} 136 137/* checksum the plaintext data and hdrlen bytes of the token header */ 138s32 139make_spkm3_checksum(s32 cksumtype, struct xdr_netobj *key, char *header, 140 unsigned int hdrlen, struct xdr_buf *body, 141 unsigned int body_offset, struct xdr_netobj *cksum) 142{ 143 char *cksumname; 144 struct hash_desc desc; 145 struct scatterlist sg[1]; 146 int err; 147 148 switch (cksumtype) { 149 case CKSUMTYPE_HMAC_MD5: 150 cksumname = "hmac(md5)"; 151 break; 152 default: 153 dprintk("RPC: spkm3_make_checksum:" 154 " unsupported checksum %d", cksumtype); 155 return GSS_S_FAILURE; 156 } 157 158 if (key->data == NULL || key->len <= 0) return GSS_S_FAILURE; 159 160 desc.tfm = crypto_alloc_hash(cksumname, 0, CRYPTO_ALG_ASYNC); 161 if (IS_ERR(desc.tfm)) 162 return GSS_S_FAILURE; 163 cksum->len = crypto_hash_digestsize(desc.tfm); 164 desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP; 165 166 err = crypto_hash_setkey(desc.tfm, key->data, key->len); 167 if (err) 168 goto out; 169 170 err = crypto_hash_init(&desc); 171 if (err) 172 goto out; 173 174 sg_init_one(sg, header, hdrlen); 175 crypto_hash_update(&desc, sg, sg->length); 176 177 xdr_process_buf(body, body_offset, body->len - body_offset, 178 spkm3_checksummer, &desc); 179 crypto_hash_final(&desc, cksum->data); 180 181out: 182 crypto_free_hash(desc.tfm); 183 184 return err ? GSS_S_FAILURE : 0; 185} 186