crypto/dist/heimdal/lib/otp/otp_md.c

   1 /*
   2  * Copyright (c) 1995 - 2003 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 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 __RCSID("$Heimdal: otp_md.c 12048 2003-04-16 16:19:33Z lha $"
  37         "$NetBSD$");
  38 #endif
  39 #include "otp_locl.h"
  40
  41 #include "otp_md.h"
  42 #include "crypto-headers.h"
  43
  44 /*
  45  * Compress len bytes from md into key
  46  */
  47
  48 static void
  49 compressmd (OtpKey key, unsigned char *md, size_t len)
  50 {
  51   u_char *p = key;
  52
  53   memset (p, 0, OTPKEYSIZE);
  54   while(len) {
  55     *p++ ^= *md++;
  56     *p++ ^= *md++;
  57     *p++ ^= *md++;
  58     *p++ ^= *md++;
  59     len -= 4;
  60     if (p == key + OTPKEYSIZE)
  61       p = key;
  62   }
  63 }
  64
  65 #ifdef HAVE_OLD_HASH_NAMES
  66 static void
  67 otp_md4_final (void *res, struct md4 *m)
  68 {
  69     MD4_Final(res, m);
  70 }
  71 #undef MD4_Final
  72 #define MD4_Final otp_md4_final
  73
  74 static void
  75 otp_md5_final (void *res, struct md5 *m)
  76 {
  77     MD5_Final(res, m);
  78 }
  79 #undef MD5_Final
  80 #define MD5_Final otp_md5_final
  81 #endif
  82
  83 static int
  84 otp_md_init (OtpKey key,
  85              const char *pwd,
  86              const char *seed,
  87              void (*init)(void *),
  88              void (*update)(void *, const void *, size_t),
  89              void (*final)(void *, void *),
  90              void *arg,
  91              unsigned char *res,
  92              size_t ressz)
  93 {
  94   char *p;
  95   int len;
  96
  97   len = strlen(pwd) + strlen(seed);
  98   p = malloc (len + 1);
  99   if (p == NULL)
 100     return -1;
 101   strlcpy (p, seed, len + 1);
 102   strlwr (p);
 103   strlcat (p, pwd, len + 1);
 104   (*init)(arg);
 105   (*update)(arg, p, len);
 106   (*final)(res, arg);
 107   free (p);
 108   compressmd (key, res, ressz);
 109   return 0;
 110 }
 111
 112 static int
 113 otp_md_next (OtpKey key,
 114              void (*init)(void *),
 115              void (*update)(void *, const void *, size_t),
 116              void (*final)(void *, void *),
 117              void *arg,
 118              unsigned char *res,
 119              size_t ressz)
 120 {
 121   (*init)(arg);
 122   (*update)(arg, key, OTPKEYSIZE);
 123   (*final)(res, arg);
 124   compressmd (key, res, ressz);
 125   return 0;
 126 }
 127
 128 static int
 129 otp_md_hash (const char *data,
 130              size_t len,
 131              void (*init)(void *),
 132              void (*update)(void *, const void *, size_t),
 133              void (*final)(void *, void *),
 134              void *arg,
 135              unsigned char *res,
 136              size_t ressz)
 137 {
 138   (*init)(arg);
 139   (*update)(arg, data, len);
 140   (*final)(res, arg);
 141   return 0;
 142 }
 143
 144 int
 145 otp_md4_init (OtpKey key, const char *pwd, const char *seed)
 146 {
 147   unsigned char res[16];
 148   MD4_CTX md4;
 149
 150   return otp_md_init (key, pwd, seed,
 151                       (void (*)(void *))MD4_Init,
 152                       (void (*)(void *, const void *, size_t))MD4_Update,
 153                       (void (*)(void *, void *))MD4_Final,
 154                       &md4, res, sizeof(res));
 155 }
 156
 157 int
 158 otp_md4_hash (const char *data,
 159               size_t len,
 160               unsigned char *res)
 161 {
 162   MD4_CTX md4;
 163
 164   return otp_md_hash (data, len,
 165                       (void (*)(void *))MD4_Init,
 166                       (void (*)(void *, const void *, size_t))MD4_Update,
 167                       (void (*)(void *, void *))MD4_Final,
 168                       &md4, res, 16);
 169 }
 170
 171 int
 172 otp_md4_next (OtpKey key)
 173 {
 174   unsigned char res[16];
 175   MD4_CTX md4;
 176
 177   return otp_md_next (key,
 178                       (void (*)(void *))MD4_Init,
 179                       (void (*)(void *, const void *, size_t))MD4_Update,
 180                       (void (*)(void *, void *))MD4_Final,
 181                       &md4, res, sizeof(res));
 182 }
 183
 184
 185 int
 186 otp_md5_init (OtpKey key, const char *pwd, const char *seed)
 187 {
 188   unsigned char res[16];
 189   MD5_CTX md5;
 190
 191   return otp_md_init (key, pwd, seed,
 192                       (void (*)(void *))MD5_Init,
 193                       (void (*)(void *, const void *, size_t))MD5_Update,
 194                       (void (*)(void *, void *))MD5_Final,
 195                       &md5, res, sizeof(res));
 196 }
 197
 198 int
 199 otp_md5_hash (const char *data,
 200               size_t len,
 201               unsigned char *res)
 202 {
 203   MD5_CTX md5;
 204
 205   return otp_md_hash (data, len,
 206                       (void (*)(void *))MD5_Init,
 207                       (void (*)(void *, const void *, size_t))MD5_Update,
 208                       (void (*)(void *, void *))MD5_Final,
 209                       &md5, res, 16);
 210 }
 211
 212 int
 213 otp_md5_next (OtpKey key)
 214 {
 215   unsigned char res[16];
 216   MD5_CTX md5;
 217
 218   return otp_md_next (key,
 219                       (void (*)(void *))MD5_Init,
 220                       (void (*)(void *, const void *, size_t))MD5_Update,
 221                       (void (*)(void *, void *))MD5_Final,
 222                       &md5, res, sizeof(res));
 223 }
 224
 225 /*
 226  * For histerical reasons, in the OTP definition it's said that the
 227  * result from SHA must be stored in little-endian order.  See
 228  * draft-ietf-otp-01.txt.
 229  */
 230
 231 static void
 232 SHA1_Final_little_endian (void *res, SHA_CTX *m)
 233 {
 234   unsigned char tmp[20];
 235   unsigned char *p = res;
 236   int j;
 237
 238   SHA1_Final (tmp, m);
 239   for (j = 0; j < 20; j += 4) {
 240     p[j]   = tmp[j+3];
 241     p[j+1] = tmp[j+2];
 242     p[j+2] = tmp[j+1];
 243     p[j+3] = tmp[j];
 244   }
 245 }
 246
 247 int
 248 otp_sha_init (OtpKey key, const char *pwd, const char *seed)
 249 {
 250   unsigned char res[20];
 251   SHA_CTX sha1;
 252
 253   return otp_md_init (key, pwd, seed,
 254                       (void (*)(void *))SHA1_Init,
 255                       (void (*)(void *, const void *, size_t))SHA1_Update,
 256                       (void (*)(void *, void *))SHA1_Final_little_endian,
 257                       &sha1, res, sizeof(res));
 258 }
 259
 260 int
 261 otp_sha_hash (const char *data,
 262               size_t len,
 263               unsigned char *res)
 264 {
 265   SHA_CTX sha1;
 266
 267   return otp_md_hash (data, len,
 268                       (void (*)(void *))SHA1_Init,
 269                       (void (*)(void *, const void *, size_t))SHA1_Update,
 270                       (void (*)(void *, void *))SHA1_Final_little_endian,
 271                       &sha1, res, 20);
 272 }
 273
 274 int
 275 otp_sha_next (OtpKey key)
 276 {
 277   unsigned char res[20];
 278   SHA_CTX sha1;
 279
 280   return otp_md_next (key,
 281                       (void (*)(void *))SHA1_Init,
 282                       (void (*)(void *, const void *, size_t))SHA1_Update,
 283                       (void (*)(void *, void *))SHA1_Final_little_endian,
 284                       &sha1, res, sizeof(res));
 285 }