lib/krb5/salt-des3.c

   1 /*
   2  * Copyright (c) 1997 - 2008 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "krb5_locl.h"
  35
  36 #ifdef DES3_OLD_ENCTYPE
  37 static krb5_error_code
  38 DES3_string_to_key(krb5_context context,
  39                    krb5_enctype enctype,
  40                    krb5_data password,
  41                    krb5_salt salt,
  42                    krb5_data opaque,
  43                    krb5_keyblock *key)
  44 {
  45     char *str;
  46     size_t len;
  47     unsigned char tmp[24];
  48     DES_cblock keys[3];
  49     krb5_error_code ret;
  50
  51     len = password.length + salt.saltvalue.length;
  52     str = malloc(len);
  53     if(len != 0 && str == NULL) {
  54         krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
  55         return ENOMEM;
  56     }
  57     memcpy(str, password.data, password.length);
  58     memcpy(str + password.length, salt.saltvalue.data, salt.saltvalue.length);
  59     {
  60         DES_cblock ivec;
  61         DES_key_schedule s[3];
  62         int i;
  63
  64         ret = _krb5_n_fold(str, len, tmp, 24);
  65         if (ret) {
  66             memset(str, 0, len);
  67             free(str);
  68             krb5_set_error_message(context, ret, N_("malloc: out of memory", ""));
  69             return ret;
  70         }
  71
  72         for(i = 0; i < 3; i++){
  73             memcpy(keys + i, tmp + i * 8, sizeof(keys[i]));
  74             DES_set_odd_parity(keys + i);
  75             if(DES_is_weak_key(keys + i))
  76                 _krb5_xor(keys + i, (const unsigned char*)"\0\0\0\0\0\0\0\xf0");
  77             DES_set_key_unchecked(keys + i, &s[i]);
  78         }
  79         memset(&ivec, 0, sizeof(ivec));
  80         DES_ede3_cbc_encrypt(tmp,
  81                              tmp, sizeof(tmp),
  82                              &s[0], &s[1], &s[2], &ivec, DES_ENCRYPT);
  83         memset(s, 0, sizeof(s));
  84         memset(&ivec, 0, sizeof(ivec));
  85         for(i = 0; i < 3; i++){
  86             memcpy(keys + i, tmp + i * 8, sizeof(keys[i]));
  87             DES_set_odd_parity(keys + i);
  88             if(DES_is_weak_key(keys + i))
  89                 _krb5_xor(keys + i, (const unsigned char*)"\0\0\0\0\0\0\0\xf0");
  90         }
  91         memset(tmp, 0, sizeof(tmp));
  92     }
  93     key->keytype = enctype;
  94     krb5_data_copy(&key->keyvalue, keys, sizeof(keys));
  95     memset(keys, 0, sizeof(keys));
  96     memset(str, 0, len);
  97     free(str);
  98     return 0;
  99 }
 100 #endif
 101
 102 static krb5_error_code
 103 DES3_string_to_key_derived(krb5_context context,
 104                            krb5_enctype enctype,
 105                            krb5_data password,
 106                            krb5_salt salt,
 107                            krb5_data opaque,
 108                            krb5_keyblock *key)
 109 {
 110     krb5_error_code ret;
 111     size_t len = password.length + salt.saltvalue.length;
 112     char *s;
 113
 114     s = malloc(len);
 115     if(len != 0 && s == NULL) {
 116         krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
 117         return ENOMEM;
 118     }
 119     memcpy(s, password.data, password.length);
 120     memcpy(s + password.length, salt.saltvalue.data, salt.saltvalue.length);
 121     ret = krb5_string_to_key_derived(context,
 122                                      s,
 123                                      len,
 124                                      enctype,
 125                                      key);
 126     memset(s, 0, len);
 127     free(s);
 128     return ret;
 129 }
 130
 131
 132 #ifdef DES3_OLD_ENCTYPE
 133 struct salt_type _krb5_des3_salt[] = {
 134     {
 135         KRB5_PW_SALT,
 136         "pw-salt",
 137         DES3_string_to_key
 138     },
 139     { 0 }
 140 };
 141 #endif
 142
 143 struct salt_type _krb5_des3_salt_derived[] = {
 144     {
 145         KRB5_PW_SALT,
 146         "pw-salt",
 147         DES3_string_to_key_derived
 148     },
 149     { 0 }
 150 };