source4/heimdal/lib/hdb/mkey.c

   1 /*
   2  * Copyright (c) 2000 - 2004 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 "hdb_locl.h"
  35 #ifndef O_BINARY
  36 #define O_BINARY 0
  37 #endif
  38
  39 RCSID("$Id$");
  40
  41 struct hdb_master_key_data {
  42     krb5_keytab_entry keytab;
  43     krb5_crypto crypto;
  44     struct hdb_master_key_data *next;
  45 };
  46
  47 void
  48 hdb_free_master_key(krb5_context context, hdb_master_key mkey)
  49 {
  50     struct hdb_master_key_data *ptr;
  51     while(mkey) {
  52         krb5_kt_free_entry(context, &mkey->keytab);
  53         if (mkey->crypto)
  54             krb5_crypto_destroy(context, mkey->crypto);
  55         ptr = mkey;
  56         mkey = mkey->next;
  57         free(ptr);
  58     }
  59 }
  60
  61 krb5_error_code
  62 hdb_process_master_key(krb5_context context,
  63                        int kvno, krb5_keyblock *key, krb5_enctype etype,
  64                        hdb_master_key *mkey)
  65 {
  66     krb5_error_code ret;
  67
  68     *mkey = calloc(1, sizeof(**mkey));
  69     if(*mkey == NULL) {
  70         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
  71         return ENOMEM;
  72     }
  73     (*mkey)->keytab.vno = kvno;
  74     ret = krb5_parse_name(context, "K/M", &(*mkey)->keytab.principal);
  75     if(ret)
  76         goto fail;
  77     ret = krb5_copy_keyblock_contents(context, key, &(*mkey)->keytab.keyblock);
  78     if(ret)
  79         goto fail;
  80     if(etype != 0)
  81         (*mkey)->keytab.keyblock.keytype = etype;
  82     (*mkey)->keytab.timestamp = time(NULL);
  83     ret = krb5_crypto_init(context, key, etype, &(*mkey)->crypto);
  84     if(ret)
  85         goto fail;
  86     return 0;
  87  fail:
  88     hdb_free_master_key(context, *mkey);
  89     *mkey = NULL;
  90     return ret;
  91 }
  92
  93 krb5_error_code
  94 hdb_add_master_key(krb5_context context, krb5_keyblock *key,
  95                    hdb_master_key *inout)
  96 {
  97     int vno = 0;
  98     hdb_master_key p;
  99     krb5_error_code ret;
 100
 101     for(p = *inout; p; p = p->next)
 102         vno = max(vno, p->keytab.vno);
 103     vno++;
 104     ret = hdb_process_master_key(context, vno, key, 0, &p);
 105     if(ret)
 106         return ret;
 107     p->next = *inout;
 108     *inout = p;
 109     return 0;
 110 }
 111
 112 static krb5_error_code
 113 read_master_keytab(krb5_context context, const char *filename,
 114                    hdb_master_key *mkey)
 115 {
 116     krb5_error_code ret;
 117     krb5_keytab id;
 118     krb5_kt_cursor cursor;
 119     krb5_keytab_entry entry;
 120     hdb_master_key p;
 121
 122     ret = krb5_kt_resolve(context, filename, &id);
 123     if(ret)
 124         return ret;
 125
 126     ret = krb5_kt_start_seq_get(context, id, &cursor);
 127     if(ret)
 128         goto out;
 129     *mkey = NULL;
 130     while(krb5_kt_next_entry(context, id, &entry, &cursor) == 0) {
 131         p = calloc(1, sizeof(*p));
 132         if(p == NULL) {
 133             krb5_kt_end_seq_get(context, id, &cursor);
 134             ret = ENOMEM;
 135             goto out;
 136         }
 137         p->keytab = entry;
 138         ret = krb5_crypto_init(context, &p->keytab.keyblock, 0, &p->crypto);
 139         p->next = *mkey;
 140         *mkey = p;
 141     }
 142     krb5_kt_end_seq_get(context, id, &cursor);
 143   out:
 144     krb5_kt_close(context, id);
 145     return ret;
 146 }
 147
 148 /* read a MIT master keyfile */
 149 static krb5_error_code
 150 read_master_mit(krb5_context context, const char *filename,
 151                 hdb_master_key *mkey)
 152 {
 153     int fd;
 154     krb5_error_code ret;
 155     krb5_storage *sp;
 156     int16_t enctype;
 157     krb5_keyblock key;
 158
 159     fd = open(filename, O_RDONLY | O_BINARY);
 160     if(fd < 0) {
 161         int save_errno = errno;
 162         krb5_set_error_message(context, save_errno, "failed to open %s: %s",
 163                                filename, strerror(save_errno));
 164         return save_errno;
 165     }
 166     sp = krb5_storage_from_fd(fd);
 167     if(sp == NULL) {
 168         close(fd);
 169         return errno;
 170     }
 171     krb5_storage_set_flags(sp, KRB5_STORAGE_HOST_BYTEORDER);
 172     /* could possibly use ret_keyblock here, but do it with more
 173        checks for now */
 174     {
 175         ret = krb5_ret_int16(sp, &enctype);
 176         if (ret)
 177             goto out;
 178         if((htons(enctype) & 0xff00) == 0x3000) {
 179             ret = HEIM_ERR_BAD_MKEY;
 180             krb5_set_error_message(context, ret, "unknown keytype in %s: "
 181                                    "%#x, expected %#x",
 182                                    filename, htons(enctype), 0x3000);
 183             goto out;
 184         }
 185         key.keytype = enctype;
 186         ret = krb5_ret_data(sp, &key.keyvalue);
 187         if(ret)
 188             goto out;
 189     }
 190     ret = hdb_process_master_key(context, 0, &key, 0, mkey);
 191     krb5_free_keyblock_contents(context, &key);
 192   out:
 193     krb5_storage_free(sp);
 194     close(fd);
 195     return ret;
 196 }
 197
 198 /* read an old master key file */
 199 static krb5_error_code
 200 read_master_encryptionkey(krb5_context context, const char *filename,
 201                           hdb_master_key *mkey)
 202 {
 203     int fd;
 204     krb5_keyblock key;
 205     krb5_error_code ret;
 206     unsigned char buf[256];
 207     ssize_t len;
 208     size_t ret_len;
 209
 210     fd = open(filename, O_RDONLY | O_BINARY);
 211     if(fd < 0) {
 212         int save_errno = errno;
 213         krb5_set_error_message(context, save_errno, "failed to open %s: %s",
 214                               filename, strerror(save_errno));
 215         return save_errno;
 216     }
 217
 218     len = read(fd, buf, sizeof(buf));
 219     close(fd);
 220     if(len < 0) {
 221         int save_errno = errno;
 222         krb5_set_error_message(context, save_errno, "error reading %s: %s",
 223                               filename, strerror(save_errno));
 224         return save_errno;
 225     }
 226
 227     ret = decode_EncryptionKey(buf, len, &key, &ret_len);
 228     memset(buf, 0, sizeof(buf));
 229     if(ret)
 230         return ret;
 231
 232     /* Originally, the keytype was just that, and later it got changed
 233        to des-cbc-md5, but we always used des in cfb64 mode. This
 234        should cover all cases, but will break if someone has hacked
 235        this code to really use des-cbc-md5 -- but then that's not my
 236        problem. */
 237     if(key.keytype == KEYTYPE_DES || key.keytype == ETYPE_DES_CBC_MD5)
 238         key.keytype = ETYPE_DES_CFB64_NONE;
 239
 240     ret = hdb_process_master_key(context, 0, &key, 0, mkey);
 241     krb5_free_keyblock_contents(context, &key);
 242     return ret;
 243 }
 244
 245 /* read a krb4 /.k style file */
 246 static krb5_error_code
 247 read_master_krb4(krb5_context context, const char *filename,
 248                  hdb_master_key *mkey)
 249 {
 250     int fd;
 251     krb5_keyblock key;
 252     krb5_error_code ret;
 253     unsigned char buf[256];
 254     ssize_t len;
 255
 256     fd = open(filename, O_RDONLY | O_BINARY);
 257     if(fd < 0) {
 258         int save_errno = errno;
 259         krb5_set_error_message(context, save_errno, "failed to open %s: %s",
 260                                filename, strerror(save_errno));
 261         return save_errno;
 262     }
 263
 264     len = read(fd, buf, sizeof(buf));
 265     close(fd);
 266     if(len < 0) {
 267         int save_errno = errno;
 268         krb5_set_error_message(context, save_errno, "error reading %s: %s",
 269                                filename, strerror(save_errno));
 270         return save_errno;
 271     }
 272     if(len != 8) {
 273         krb5_set_error_message(context, HEIM_ERR_EOF,
 274                                "bad contents of %s", filename);
 275         return HEIM_ERR_EOF; /* XXX file might be too large */
 276     }
 277
 278     memset(&key, 0, sizeof(key));
 279     key.keytype = ETYPE_DES_PCBC_NONE;
 280     ret = krb5_data_copy(&key.keyvalue, buf, len);
 281     memset(buf, 0, sizeof(buf));
 282     if(ret)
 283         return ret;
 284
 285     ret = hdb_process_master_key(context, 0, &key, 0, mkey);
 286     krb5_free_keyblock_contents(context, &key);
 287     return ret;
 288 }
 289
 290 krb5_error_code
 291 hdb_read_master_key(krb5_context context, const char *filename,
 292                     hdb_master_key *mkey)
 293 {
 294     FILE *f;
 295     unsigned char buf[16];
 296     krb5_error_code ret;
 297
 298     off_t len;
 299
 300     *mkey = NULL;
 301
 302     if(filename == NULL)
 303         filename = HDB_DB_DIR "/m-key";
 304
 305     f = fopen(filename, "r");
 306     if(f == NULL) {
 307         int save_errno = errno;
 308         krb5_set_error_message(context, save_errno, "failed to open %s: %s",
 309                                filename, strerror(save_errno));
 310         return save_errno;
 311     }
 312
 313     if(fread(buf, 1, 2, f) != 2) {
 314         fclose(f);
 315         krb5_set_error_message(context, HEIM_ERR_EOF, "end of file reading %s", filename);
 316         return HEIM_ERR_EOF;
 317     }
 318
 319     fseek(f, 0, SEEK_END);
 320     len = ftell(f);
 321
 322     if(fclose(f) != 0)
 323         return errno;
 324
 325     if(len < 0)
 326         return errno;
 327
 328     if(len == 8) {
 329         ret = read_master_krb4(context, filename, mkey);
 330     } else if(buf[0] == 0x30 && len <= 127 && buf[1] == len - 2) {
 331         ret = read_master_encryptionkey(context, filename, mkey);
 332     } else if(buf[0] == 5 && buf[1] >= 1 && buf[1] <= 2) {
 333         ret = read_master_keytab(context, filename, mkey);
 334     } else {
 335         ret = read_master_mit(context, filename, mkey);
 336     }
 337     return ret;
 338 }
 339
 340 krb5_error_code
 341 hdb_write_master_key(krb5_context context, const char *filename,
 342                      hdb_master_key mkey)
 343 {
 344     krb5_error_code ret;
 345     hdb_master_key p;
 346     krb5_keytab kt;
 347
 348     if(filename == NULL)
 349         filename = HDB_DB_DIR "/m-key";
 350
 351     ret = krb5_kt_resolve(context, filename, &kt);
 352     if(ret)
 353         return ret;
 354
 355     for(p = mkey; p; p = p->next) {
 356         ret = krb5_kt_add_entry(context, kt, &p->keytab);
 357     }
 358
 359     krb5_kt_close(context, kt);
 360
 361     return ret;
 362 }
 363
 364 hdb_master_key
 365 _hdb_find_master_key(uint32_t *mkvno, hdb_master_key mkey)
 366 {
 367     hdb_master_key ret = NULL;
 368     while(mkey) {
 369         if(ret == NULL && mkey->keytab.vno == 0)
 370             ret = mkey;
 371         if(mkvno == NULL) {
 372             if(ret == NULL || mkey->keytab.vno > ret->keytab.vno)
 373                 ret = mkey;
 374         } else if(mkey->keytab.vno == *mkvno)
 375             return mkey;
 376         mkey = mkey->next;
 377     }
 378     return ret;
 379 }
 380
 381 int
 382 _hdb_mkey_version(hdb_master_key mkey)
 383 {
 384     return mkey->keytab.vno;
 385 }
 386
 387 int
 388 _hdb_mkey_decrypt(krb5_context context, hdb_master_key key,
 389                   krb5_key_usage usage,
 390                   void *ptr, size_t size, krb5_data *res)
 391 {
 392     return krb5_decrypt(context, key->crypto, usage,
 393                         ptr, size, res);
 394 }
 395
 396 int
 397 _hdb_mkey_encrypt(krb5_context context, hdb_master_key key,
 398                   krb5_key_usage usage,
 399                   const void *ptr, size_t size, krb5_data *res)
 400 {
 401     return krb5_encrypt(context, key->crypto, usage,
 402                         ptr, size, res);
 403 }
 404
 405 krb5_error_code
 406 hdb_unseal_key_mkey(krb5_context context, Key *k, hdb_master_key mkey)
 407 {
 408
 409     krb5_error_code ret;
 410     krb5_data res;
 411     size_t keysize;
 412
 413     hdb_master_key key;
 414
 415     if(k->mkvno == NULL)
 416         return 0;
 417
 418     key = _hdb_find_master_key(k->mkvno, mkey);
 419
 420     if (key == NULL)
 421         return HDB_ERR_NO_MKEY;
 422
 423     ret = _hdb_mkey_decrypt(context, key, HDB_KU_MKEY,
 424                             k->key.keyvalue.data,
 425                             k->key.keyvalue.length,
 426                             &res);
 427     if(ret == KRB5KRB_AP_ERR_BAD_INTEGRITY) {
 428         /* try to decrypt with MIT key usage */
 429         ret = _hdb_mkey_decrypt(context, key, 0,
 430                                 k->key.keyvalue.data,
 431                                 k->key.keyvalue.length,
 432                                 &res);
 433     }
 434     if (ret)
 435         return ret;
 436
 437     /* fixup keylength if the key got padded when encrypting it */
 438     ret = krb5_enctype_keysize(context, k->key.keytype, &keysize);
 439     if (ret) {
 440         krb5_data_free(&res);
 441         return ret;
 442     }
 443     if (keysize > res.length) {
 444         krb5_data_free(&res);
 445         return KRB5_BAD_KEYSIZE;
 446     }
 447
 448     memset(k->key.keyvalue.data, 0, k->key.keyvalue.length);
 449     free(k->key.keyvalue.data);
 450     k->key.keyvalue = res;
 451     k->key.keyvalue.length = keysize;
 452     free(k->mkvno);
 453     k->mkvno = NULL;
 454
 455     return 0;
 456 }
 457
 458 krb5_error_code
 459 hdb_unseal_keys_mkey(krb5_context context, hdb_entry *ent, hdb_master_key mkey)
 460 {
 461     int i;
 462
 463     for(i = 0; i < ent->keys.len; i++){
 464         krb5_error_code ret;
 465
 466         ret = hdb_unseal_key_mkey(context, &ent->keys.val[i], mkey);
 467         if (ret)
 468             return ret;
 469     }
 470     return 0;
 471 }
 472
 473 krb5_error_code
 474 hdb_unseal_keys(krb5_context context, HDB *db, hdb_entry *ent)
 475 {
 476     if (db->hdb_master_key_set == 0)
 477         return 0;
 478     return hdb_unseal_keys_mkey(context, ent, db->hdb_master_key);
 479 }
 480
 481 krb5_error_code
 482 hdb_unseal_key(krb5_context context, HDB *db, Key *k)
 483 {
 484     if (db->hdb_master_key_set == 0)
 485         return 0;
 486     return hdb_unseal_key_mkey(context, k, db->hdb_master_key);
 487 }
 488
 489 krb5_error_code
 490 hdb_seal_key_mkey(krb5_context context, Key *k, hdb_master_key mkey)
 491 {
 492     krb5_error_code ret;
 493     krb5_data res;
 494     hdb_master_key key;
 495
 496     if(k->mkvno != NULL)
 497         return 0;
 498
 499     key = _hdb_find_master_key(k->mkvno, mkey);
 500
 501     if (key == NULL)
 502         return HDB_ERR_NO_MKEY;
 503
 504     ret = _hdb_mkey_encrypt(context, key, HDB_KU_MKEY,
 505                             k->key.keyvalue.data,
 506                             k->key.keyvalue.length,
 507                             &res);
 508     if (ret)
 509         return ret;
 510
 511     memset(k->key.keyvalue.data, 0, k->key.keyvalue.length);
 512     free(k->key.keyvalue.data);
 513     k->key.keyvalue = res;
 514
 515     if (k->mkvno == NULL) {
 516         k->mkvno = malloc(sizeof(*k->mkvno));
 517         if (k->mkvno == NULL)
 518             return ENOMEM;
 519     }
 520     *k->mkvno = key->keytab.vno;
 521
 522     return 0;
 523 }
 524
 525 krb5_error_code
 526 hdb_seal_keys_mkey(krb5_context context, hdb_entry *ent, hdb_master_key mkey)
 527 {
 528     int i;
 529     for(i = 0; i < ent->keys.len; i++){
 530         krb5_error_code ret;
 531
 532         ret = hdb_seal_key_mkey(context, &ent->keys.val[i], mkey);
 533         if (ret)
 534             return ret;
 535     }
 536     return 0;
 537 }
 538
 539 krb5_error_code
 540 hdb_seal_keys(krb5_context context, HDB *db, hdb_entry *ent)
 541 {
 542     if (db->hdb_master_key_set == 0)
 543         return 0;
 544
 545     return hdb_seal_keys_mkey(context, ent, db->hdb_master_key);
 546 }
 547
 548 krb5_error_code
 549 hdb_seal_key(krb5_context context, HDB *db, Key *k)
 550 {
 551     if (db->hdb_master_key_set == 0)
 552         return 0;
 553
 554     return hdb_seal_key_mkey(context, k, db->hdb_master_key);
 555 }
 556
 557 krb5_error_code
 558 hdb_set_master_key (krb5_context context,
 559                     HDB *db,
 560                     krb5_keyblock *key)
 561 {
 562     krb5_error_code ret;
 563     hdb_master_key mkey;
 564
 565     ret = hdb_process_master_key(context, 0, key, 0, &mkey);
 566     if (ret)
 567         return ret;
 568     db->hdb_master_key = mkey;
 569 #if 0 /* XXX - why? */
 570     des_set_random_generator_seed(key.keyvalue.data);
 571 #endif
 572     db->hdb_master_key_set = 1;
 573     return 0;
 574 }
 575
 576 krb5_error_code
 577 hdb_set_master_keyfile (krb5_context context,
 578                         HDB *db,
 579                         const char *keyfile)
 580 {
 581     hdb_master_key key;
 582     krb5_error_code ret;
 583
 584     ret = hdb_read_master_key(context, keyfile, &key);
 585     if (ret) {
 586         if (ret != ENOENT)
 587             return ret;
 588         krb5_clear_error_message(context);
 589         return 0;
 590     }
 591     db->hdb_master_key = key;
 592     db->hdb_master_key_set = 1;
 593     return ret;
 594 }
 595
 596 krb5_error_code
 597 hdb_clear_master_key (krb5_context context,
 598                       HDB *db)
 599 {
 600     if (db->hdb_master_key_set) {
 601         hdb_free_master_key(context, db->hdb_master_key);
 602         db->hdb_master_key_set = 0;
 603     }
 604     return 0;
 605 }