1 /* $NetBSD: get_mic.c,v 1.4 2019/12/15 22:50:47 christos Exp $ */ 2 3 /* 4 * Copyright (c) 1997 - 2003 Kungliga Tekniska Högskolan 5 * (Royal Institute of Technology, Stockholm, Sweden). 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 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 * 19 * 3. Neither the name of the Institute nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include "gsskrb5_locl.h" 37 38 #ifdef HEIM_WEAK_CRYPTO 39 40 static OM_uint32 41 mic_des 42 (OM_uint32 * minor_status, 43 const gsskrb5_ctx ctx, 44 krb5_context context, 45 gss_qop_t qop_req, 46 const gss_buffer_t message_buffer, 47 gss_buffer_t message_token, 48 krb5_keyblock *key 49 ) 50 { 51 u_char *p; 52 EVP_MD_CTX *md5; 53 u_char hash[16]; 54 DES_key_schedule schedule; 55 EVP_CIPHER_CTX* des_ctx; 56 DES_cblock deskey; 57 DES_cblock zero; 58 int32_t seq_number; 59 size_t len, total_len; 60 61 _gsskrb5_encap_length (22, &len, &total_len, GSS_KRB5_MECHANISM); 62 63 message_token->length = total_len; 64 message_token->value = malloc (total_len); 65 if (message_token->value == NULL) { 66 message_token->length = 0; 67 *minor_status = ENOMEM; 68 return GSS_S_FAILURE; 69 } 70 71 p = _gsskrb5_make_header(message_token->value, 72 len, 73 "\x01\x01", /* TOK_ID */ 74 GSS_KRB5_MECHANISM); 75 76 memcpy (p, "\x00\x00", 2); /* SGN_ALG = DES MAC MD5 */ 77 p += 2; 78 79 memcpy (p, "\xff\xff\xff\xff", 4); /* Filler */ 80 p += 4; 81 82 /* Fill in later (SND-SEQ) */ 83 memset (p, 0, 16); 84 p += 16; 85 86 /* checksum */ 87 md5 = EVP_MD_CTX_create(); 88 EVP_DigestInit_ex(md5, EVP_md5(), NULL); 89 EVP_DigestUpdate(md5, p - 24, 8); 90 EVP_DigestUpdate(md5, message_buffer->value, message_buffer->length); 91 EVP_DigestFinal_ex(md5, hash, NULL); 92 EVP_MD_CTX_destroy(md5); 93 94 memset (&zero, 0, sizeof(zero)); 95 memcpy (&deskey, key->keyvalue.data, sizeof(deskey)); 96 DES_set_key_unchecked (&deskey, &schedule); 97 DES_cbc_cksum ((void *)hash, (void *)hash, sizeof(hash), 98 &schedule, &zero); 99 memcpy (p - 8, hash, 8); /* SGN_CKSUM */ 100 101 HEIMDAL_MUTEX_lock(&ctx->ctx_id_mutex); 102 /* sequence number */ 103 krb5_auth_con_getlocalseqnumber (context, 104 ctx->auth_context, 105 &seq_number); 106 107 p -= 16; /* SND_SEQ */ 108 p[0] = (seq_number >> 0) & 0xFF; 109 p[1] = (seq_number >> 8) & 0xFF; 110 p[2] = (seq_number >> 16) & 0xFF; 111 p[3] = (seq_number >> 24) & 0xFF; 112 memset (p + 4, 113 (ctx->more_flags & LOCAL) ? 0 : 0xFF, 114 4); 115 116 117 #if OPENSSL_VERSION_NUMBER < 0x10100000UL 118 EVP_CIPHER_CTX des_ctxs; 119 des_ctx = &des_ctxs; 120 EVP_CIPHER_CTX_init(des_ctx); 121 #else 122 des_ctx = EVP_CIPHER_CTX_new(); 123 #endif 124 EVP_CIPHER_CTX_init(des_ctx); 125 EVP_CipherInit_ex(des_ctx, EVP_des_cbc(), NULL, key->keyvalue.data, p + 8, 1); 126 EVP_Cipher(des_ctx, p, p, 8); 127 #if OPENSSL_VERSION_NUMBER < 0x10100000UL 128 EVP_CIPHER_CTX_cleanup(des_ctx); 129 #else 130 EVP_CIPHER_CTX_free(des_ctx); 131 #endif 132 133 krb5_auth_con_setlocalseqnumber (context, 134 ctx->auth_context, 135 ++seq_number); 136 HEIMDAL_MUTEX_unlock(&ctx->ctx_id_mutex); 137 138 memset_s(deskey, sizeof(deskey), 0, sizeof(deskey)); 139 memset_s(&schedule, sizeof(schedule), 0, sizeof(schedule)); 140 141 *minor_status = 0; 142 return GSS_S_COMPLETE; 143 } 144 #endif 145 146 static OM_uint32 147 mic_des3 148 (OM_uint32 * minor_status, 149 const gsskrb5_ctx ctx, 150 krb5_context context, 151 gss_qop_t qop_req, 152 const gss_buffer_t message_buffer, 153 gss_buffer_t message_token, 154 krb5_keyblock *key 155 ) 156 { 157 u_char *p; 158 Checksum cksum; 159 u_char seq[8]; 160 161 int32_t seq_number; 162 size_t len, total_len; 163 164 krb5_crypto crypto; 165 krb5_error_code kret; 166 krb5_data encdata; 167 char *tmp; 168 char ivec[8]; 169 170 _gsskrb5_encap_length (36, &len, &total_len, GSS_KRB5_MECHANISM); 171 172 message_token->length = total_len; 173 message_token->value = malloc (total_len); 174 if (message_token->value == NULL) { 175 message_token->length = 0; 176 *minor_status = ENOMEM; 177 return GSS_S_FAILURE; 178 } 179 180 p = _gsskrb5_make_header(message_token->value, 181 len, 182 "\x01\x01", /* TOK-ID */ 183 GSS_KRB5_MECHANISM); 184 185 memcpy (p, "\x04\x00", 2); /* SGN_ALG = HMAC SHA1 DES3-KD */ 186 p += 2; 187 188 memcpy (p, "\xff\xff\xff\xff", 4); /* filler */ 189 p += 4; 190 191 /* this should be done in parts */ 192 193 tmp = malloc (message_buffer->length + 8); 194 if (tmp == NULL) { 195 free (message_token->value); 196 message_token->value = NULL; 197 message_token->length = 0; 198 *minor_status = ENOMEM; 199 return GSS_S_FAILURE; 200 } 201 memcpy (tmp, p - 8, 8); 202 memcpy (tmp + 8, message_buffer->value, message_buffer->length); 203 204 kret = krb5_crypto_init(context, key, 0, &crypto); 205 if (kret) { 206 free (message_token->value); 207 message_token->value = NULL; 208 message_token->length = 0; 209 free (tmp); 210 *minor_status = kret; 211 return GSS_S_FAILURE; 212 } 213 214 kret = krb5_create_checksum (context, 215 crypto, 216 KRB5_KU_USAGE_SIGN, 217 0, 218 tmp, 219 message_buffer->length + 8, 220 &cksum); 221 free (tmp); 222 krb5_crypto_destroy (context, crypto); 223 if (kret) { 224 free (message_token->value); 225 message_token->value = NULL; 226 message_token->length = 0; 227 *minor_status = kret; 228 return GSS_S_FAILURE; 229 } 230 231 memcpy (p + 8, cksum.checksum.data, cksum.checksum.length); 232 233 HEIMDAL_MUTEX_lock(&ctx->ctx_id_mutex); 234 /* sequence number */ 235 krb5_auth_con_getlocalseqnumber (context, 236 ctx->auth_context, 237 &seq_number); 238 239 seq[0] = (seq_number >> 0) & 0xFF; 240 seq[1] = (seq_number >> 8) & 0xFF; 241 seq[2] = (seq_number >> 16) & 0xFF; 242 seq[3] = (seq_number >> 24) & 0xFF; 243 memset (seq + 4, 244 (ctx->more_flags & LOCAL) ? 0 : 0xFF, 245 4); 246 247 kret = krb5_crypto_init(context, key, 248 ETYPE_DES3_CBC_NONE, &crypto); 249 if (kret) { 250 free (message_token->value); 251 message_token->value = NULL; 252 message_token->length = 0; 253 *minor_status = kret; 254 return GSS_S_FAILURE; 255 } 256 257 if (ctx->more_flags & COMPAT_OLD_DES3) 258 memset(ivec, 0, 8); 259 else 260 memcpy(ivec, p + 8, 8); 261 262 kret = krb5_encrypt_ivec (context, 263 crypto, 264 KRB5_KU_USAGE_SEQ, 265 seq, 8, &encdata, ivec); 266 krb5_crypto_destroy (context, crypto); 267 if (kret) { 268 free (message_token->value); 269 message_token->value = NULL; 270 message_token->length = 0; 271 *minor_status = kret; 272 return GSS_S_FAILURE; 273 } 274 275 assert (encdata.length == 8); 276 277 memcpy (p, encdata.data, encdata.length); 278 krb5_data_free (&encdata); 279 280 krb5_auth_con_setlocalseqnumber (context, 281 ctx->auth_context, 282 ++seq_number); 283 HEIMDAL_MUTEX_unlock(&ctx->ctx_id_mutex); 284 285 free_Checksum (&cksum); 286 *minor_status = 0; 287 return GSS_S_COMPLETE; 288 } 289 290 OM_uint32 GSSAPI_CALLCONV _gsskrb5_get_mic 291 (OM_uint32 * minor_status, 292 gss_const_ctx_id_t context_handle, 293 gss_qop_t qop_req, 294 const gss_buffer_t message_buffer, 295 gss_buffer_t message_token 296 ) 297 { 298 krb5_context context; 299 const gsskrb5_ctx ctx = (const gsskrb5_ctx) context_handle; 300 krb5_keyblock *key; 301 OM_uint32 ret; 302 303 GSSAPI_KRB5_INIT (&context); 304 305 if (ctx->more_flags & IS_CFX) 306 return _gssapi_mic_cfx (minor_status, ctx, context, qop_req, 307 message_buffer, message_token); 308 309 HEIMDAL_MUTEX_lock(&ctx->ctx_id_mutex); 310 ret = _gsskrb5i_get_token_key(ctx, context, &key); 311 HEIMDAL_MUTEX_unlock(&ctx->ctx_id_mutex); 312 if (ret) { 313 *minor_status = ret; 314 return GSS_S_FAILURE; 315 } 316 317 switch (key->keytype) { 318 case KRB5_ENCTYPE_DES_CBC_CRC : 319 case KRB5_ENCTYPE_DES_CBC_MD4 : 320 case KRB5_ENCTYPE_DES_CBC_MD5 : 321 #ifdef HEIM_WEAK_CRYPTO 322 ret = mic_des (minor_status, ctx, context, qop_req, 323 message_buffer, message_token, key); 324 #else 325 ret = GSS_S_FAILURE; 326 #endif 327 break; 328 case KRB5_ENCTYPE_DES3_CBC_MD5 : 329 case KRB5_ENCTYPE_DES3_CBC_SHA1 : 330 ret = mic_des3 (minor_status, ctx, context, qop_req, 331 message_buffer, message_token, key); 332 break; 333 case KRB5_ENCTYPE_ARCFOUR_HMAC_MD5: 334 case KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56: 335 ret = _gssapi_get_mic_arcfour (minor_status, ctx, context, qop_req, 336 message_buffer, message_token, key); 337 break; 338 default : 339 abort(); 340 break; 341 } 342 krb5_free_keyblock (context, key); 343 return ret; 344 } 345