2 * Copyright (c) 1997 - 2002 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
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.
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.
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
34 #include "krb5_locl.h"
36 RCSID("$Id: keytab_krb4.c 17046 2006-04-10 17:10:53Z lha $");
42 static krb5_error_code
43 krb4_kt_resolve(krb5_context context, const char *name, krb5_keytab id)
45 struct krb4_kt_data *d;
47 d = malloc (sizeof(*d));
49 krb5_set_error_string (context, "malloc: out of memory");
52 d->filename = strdup (name);
53 if (d->filename == NULL) {
55 krb5_set_error_string (context, "malloc: out of memory");
62 static krb5_error_code
63 krb4_kt_get_name (krb5_context context,
68 struct krb4_kt_data *d = id->data;
70 strlcpy (name, d->filename, name_sz);
74 static krb5_error_code
75 krb4_kt_close (krb5_context context,
78 struct krb4_kt_data *d = id->data;
85 struct krb4_cursor_extra_data {
86 krb5_keytab_entry entry;
91 open_flock(const char *filename, int flags, int mode)
95 int fd = open(filename, flags, mode);
98 if((flags & O_ACCMODE) == O_RDONLY)
99 lock_mode = LOCK_SH | LOCK_NB;
101 lock_mode = LOCK_EX | LOCK_NB;
102 while(flock(fd, lock_mode) < 0) {
115 static krb5_error_code
116 krb4_kt_start_seq_get_int (krb5_context context,
121 struct krb4_kt_data *d = id->data;
122 struct krb4_cursor_extra_data *ed;
125 ed = malloc (sizeof(*ed));
127 krb5_set_error_string (context, "malloc: out of memory");
130 ed->entry.principal = NULL;
133 c->fd = open_flock (d->filename, flags, 0);
137 krb5_set_error_string(context, "open(%s): %s", d->filename,
141 c->sp = krb5_storage_from_fd(c->fd);
147 krb5_storage_set_eof_code(c->sp, KRB5_KT_END);
151 static krb5_error_code
152 krb4_kt_start_seq_get (krb5_context context,
156 return krb4_kt_start_seq_get_int (context, id, O_BINARY | O_RDONLY, c);
159 static krb5_error_code
160 read_v4_entry (krb5_context context,
161 struct krb4_kt_data *d,
163 struct krb4_cursor_extra_data *ed)
165 unsigned char des_key[8];
167 char *service, *instance, *realm;
170 ret = krb5_ret_stringz(c->sp, &service);
173 ret = krb5_ret_stringz(c->sp, &instance);
178 ret = krb5_ret_stringz(c->sp, &realm);
184 ret = krb5_425_conv_principal (context, service, instance, realm,
185 &ed->entry.principal);
191 ret = krb5_ret_int8(c->sp, &kvno);
193 krb5_free_principal (context, ed->entry.principal);
196 ret = krb5_storage_read(c->sp, des_key, sizeof(des_key));
198 krb5_free_principal(context, ed->entry.principal);
202 krb5_free_principal(context, ed->entry.principal);
205 ed->entry.vno = kvno;
206 ret = krb5_data_copy (&ed->entry.keyblock.keyvalue,
207 des_key, sizeof(des_key));
210 ed->entry.timestamp = time(NULL);
215 static krb5_error_code
216 krb4_kt_next_entry (krb5_context context,
218 krb5_keytab_entry *entry,
222 struct krb4_kt_data *d = id->data;
223 struct krb4_cursor_extra_data *ed = c->data;
224 const krb5_enctype keytypes[] = {ETYPE_DES_CBC_MD5,
229 ret = read_v4_entry (context, d, c, ed);
233 ret = krb5_kt_copy_entry_contents (context,
238 entry->keyblock.keytype = keytypes[ed->num];
239 if (++ed->num == 3) {
240 krb5_kt_free_entry (context, &ed->entry);
246 static krb5_error_code
247 krb4_kt_end_seq_get (krb5_context context,
251 struct krb4_cursor_extra_data *ed = c->data;
253 krb5_storage_free (c->sp);
255 krb5_kt_free_entry (context, &ed->entry);
261 static krb5_error_code
262 krb4_store_keytab_entry(krb5_context context,
263 krb5_keytab_entry *entry,
270 char service[ANAME_SZ];
271 char instance[INST_SZ];
272 char realm[REALM_SZ];
273 ret = krb5_524_conv_principal (context, entry->principal,
274 service, instance, realm);
277 if (entry->keyblock.keyvalue.length == 8
278 && entry->keyblock.keytype == ETYPE_DES_CBC_MD5) {
279 ret = krb5_store_stringz(sp, service);
280 ret = krb5_store_stringz(sp, instance);
281 ret = krb5_store_stringz(sp, realm);
282 ret = krb5_store_int8(sp, entry->vno);
283 ret = krb5_storage_write(sp, entry->keyblock.keyvalue.data, 8);
288 static krb5_error_code
289 krb4_kt_add_entry (krb5_context context,
291 krb5_keytab_entry *entry)
293 struct krb4_kt_data *d = id->data;
298 fd = open_flock (d->filename, O_WRONLY | O_APPEND | O_BINARY, 0);
300 fd = open_flock (d->filename,
301 O_WRONLY | O_APPEND | O_BINARY | O_CREAT, 0600);
304 krb5_set_error_string(context, "open(%s): %s", d->filename,
309 sp = krb5_storage_from_fd(fd);
314 krb5_storage_set_eof_code(sp, KRB5_KT_END);
315 ret = krb4_store_keytab_entry(context, entry, sp);
316 krb5_storage_free(sp);
322 static krb5_error_code
323 krb4_kt_remove_entry(krb5_context context,
325 krb5_keytab_entry *entry)
327 struct krb4_kt_data *d = id->data;
330 krb5_kt_cursor cursor;
334 sp = krb5_storage_emem();
336 krb5_set_error_string(context, "malloc: out of memory");
339 ret = krb5_kt_start_seq_get(context, id, &cursor);
341 krb5_storage_free(sp);
344 while(krb5_kt_next_entry(context, id, &e, &cursor) == 0) {
345 if(!krb5_kt_compare(context, &e, entry->principal,
346 entry->vno, entry->keyblock.keytype)) {
347 ret = krb4_store_keytab_entry(context, &e, sp);
349 krb5_kt_free_entry(context, &e);
350 krb5_storage_free(sp);
355 krb5_kt_free_entry(context, &e);
357 krb5_kt_end_seq_get(context, id, &cursor);
360 unsigned char buf[1024];
365 krb5_storage_to_data(sp, &data);
366 krb5_storage_free(sp);
368 fd = open_flock (d->filename, O_RDWR | O_BINARY, 0);
370 memset(data.data, 0, data.length);
371 krb5_data_free(&data);
372 if(errno == EACCES || errno == EROFS)
373 return KRB5_KT_NOWRITE;
377 if(write(fd, data.data, data.length) != data.length) {
378 memset(data.data, 0, data.length);
379 krb5_data_free(&data);
381 krb5_set_error_string(context, "failed writing to \"%s\"", d->filename);
384 memset(data.data, 0, data.length);
385 if(fstat(fd, &st) < 0) {
386 krb5_data_free(&data);
388 krb5_set_error_string(context, "failed getting size of \"%s\"", d->filename);
391 st.st_size -= data.length;
392 memset(buf, 0, sizeof(buf));
393 while(st.st_size > 0) {
394 n = min(st.st_size, sizeof(buf));
395 n = write(fd, buf, n);
397 krb5_data_free(&data);
399 krb5_set_error_string(context, "failed writing to \"%s\"", d->filename);
405 if(ftruncate(fd, data.length) < 0) {
406 krb5_data_free(&data);
408 krb5_set_error_string(context, "failed truncating \"%s\"", d->filename);
411 krb5_data_free(&data);
413 krb5_set_error_string(context, "error closing \"%s\"", d->filename);
418 krb5_storage_free(sp);
419 return KRB5_KT_NOTFOUND;
424 const krb5_kt_ops krb4_fkt_ops = {
430 krb4_kt_start_seq_get,
433 krb4_kt_add_entry, /* add_entry */
434 krb4_kt_remove_entry /* remove_entry */
437 const krb5_kt_ops krb5_srvtab_fkt_ops = {
443 krb4_kt_start_seq_get,
446 krb4_kt_add_entry, /* add_entry */
447 krb4_kt_remove_entry /* remove_entry */