lib/hdb/hdb-keytab.c

   1 /*
   2  * Copyright (c) 2009 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Portions Copyright (c) 2009 Apple Inc. 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 "hdb_locl.h"
  37 #include <assert.h>
  38
  39 typedef struct {
  40     char *path;
  41     krb5_keytab keytab;
  42 } *hdb_keytab;
  43
  44 /*
  45  *
  46  */
  47
  48 static krb5_error_code
  49 hkt_close(krb5_context context, HDB *db)
  50 {
  51     hdb_keytab k = (hdb_keytab)db->hdb_db;
  52     krb5_error_code ret;
  53
  54     assert(k->keytab);
  55
  56     ret = krb5_kt_close(context, k->keytab);
  57     k->keytab = NULL;
  58
  59     return ret;
  60 }
  61
  62 static krb5_error_code
  63 hkt_destroy(krb5_context context, HDB *db)
  64 {
  65     hdb_keytab k = (hdb_keytab)db->hdb_db;
  66     krb5_error_code ret;
  67
  68     ret = hdb_clear_master_key (context, db);
  69
  70     free(k->path);
  71     free(k);
  72
  73     free(db->hdb_name);
  74     free(db);
  75     return ret;
  76 }
  77
  78 static krb5_error_code
  79 hkt_lock(krb5_context context, HDB *db, int operation)
  80 {
  81     return 0;
  82 }
  83
  84 static krb5_error_code
  85 hkt_unlock(krb5_context context, HDB *db)
  86 {
  87     return 0;
  88 }
  89
  90 static krb5_error_code
  91 hkt_firstkey(krb5_context context, HDB *db,
  92              unsigned flags, hdb_entry_ex *entry)
  93 {
  94     return HDB_ERR_DB_INUSE;
  95 }
  96
  97 static krb5_error_code
  98 hkt_nextkey(krb5_context context, HDB * db, unsigned flags,
  99              hdb_entry_ex * entry)
 100 {
 101     return HDB_ERR_DB_INUSE;
 102 }
 103
 104 static krb5_error_code
 105 hkt_open(krb5_context context, HDB * db, int flags, mode_t mode)
 106 {
 107     hdb_keytab k = (hdb_keytab)db->hdb_db;
 108     krb5_error_code ret;
 109
 110     assert(k->keytab == NULL);
 111
 112     ret = krb5_kt_resolve(context, k->path, &k->keytab);
 113     if (ret)
 114         return ret;
 115
 116     return 0;
 117 }
 118
 119 static krb5_error_code
 120 hkt_fetch(krb5_context context, HDB * db, krb5_const_principal principal,
 121           unsigned flags, hdb_entry_ex * entry)
 122 {
 123     hdb_keytab k = (hdb_keytab)db->hdb_db;
 124     krb5_error_code ret;
 125     krb5_keytab_entry ktentry;
 126
 127     memset(&ktentry, 0, sizeof(ktentry));
 128
 129     entry->entry.flags.server = 1;
 130     entry->entry.flags.forwardable = 1;
 131     entry->entry.flags.renewable = 1;
 132
 133     /* Not recorded in the OD backend, make something up */
 134     ret = krb5_parse_name(context, "hdb/keytab@WELL-KNOWN:KEYTAB-BACKEND",
 135                           &entry->entry.created_by.principal);
 136     if (ret)
 137         goto out;
 138
 139     /*
 140      * XXX really needs to try all enctypes and just not pick the
 141      * first one, even if that happens to be des3-cbc-sha1 (ie best
 142      * enctype) in the Apple case. A while loop over all known
 143      * enctypes should work.
 144      */
 145
 146     ret = krb5_kt_get_entry(context, k->keytab, principal, 0, 0, &ktentry);
 147     if (ret) {
 148         ret = HDB_ERR_NOENTRY;
 149         goto out;
 150     }
 151
 152     ret = krb5_copy_principal(context, principal, &entry->entry.principal);
 153     if (ret)
 154         goto out;
 155
 156     ret = _hdb_keytab2hdb_entry(context, &ktentry, entry);
 157
 158  out:
 159     if (ret) {
 160         free_hdb_entry(&entry->entry);
 161         memset(&entry->entry, 0, sizeof(entry->entry));
 162     }
 163     krb5_kt_free_entry(context, &ktentry);
 164
 165     return ret;
 166 }
 167
 168 static krb5_error_code
 169 hkt_store(krb5_context context, HDB * db, unsigned flags,
 170           hdb_entry_ex * entry)
 171 {
 172     return HDB_ERR_DB_INUSE;
 173 }
 174
 175
 176 krb5_error_code
 177 hdb_keytab_create(krb5_context context, HDB ** db, const char *arg)
 178 {
 179     hdb_keytab k;
 180
 181     *db = calloc(1, sizeof(**db));
 182     if (*db == NULL) {
 183         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 184         return ENOMEM;
 185     }
 186     memset(*db, 0, sizeof(**db));
 187
 188     k = calloc(1, sizeof(*k));
 189     if (k == NULL) {
 190         free(*db);
 191         *db = NULL;
 192         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 193         return ENOMEM;
 194     }
 195
 196     k->path = strdup(arg);
 197     if (k->path == NULL) {
 198         free(k);
 199         free(*db);
 200         *db = NULL;
 201         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 202         return ENOMEM;
 203     }
 204
 205
 206     (*db)->hdb_db = k;
 207
 208     (*db)->hdb_master_key_set = 0;
 209     (*db)->hdb_openp = 0;
 210     (*db)->hdb_open = hkt_open;
 211     (*db)->hdb_close = hkt_close;
 212     (*db)->hdb_fetch = hkt_fetch;
 213     (*db)->hdb_store = hkt_store;
 214     (*db)->hdb_remove = NULL;
 215     (*db)->hdb_firstkey = hkt_firstkey;
 216     (*db)->hdb_nextkey = hkt_nextkey;
 217     (*db)->hdb_lock = hkt_lock;
 218     (*db)->hdb_unlock = hkt_unlock;
 219     (*db)->hdb_rename = NULL;
 220     (*db)->hdb__get = NULL;
 221     (*db)->hdb__put = NULL;
 222     (*db)->hdb__del = NULL;
 223     (*db)->hdb_destroy = hkt_destroy;
 224
 225     return 0;
 226 }