2 * Copyright (c) 1997 - 2005 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_file.c 17457 2006-05-05 12:36:57Z lha $");
38 #define KRB5_KT_VNO_1 1
39 #define KRB5_KT_VNO_2 2
40 #define KRB5_KT_VNO KRB5_KT_VNO_2
42 #define KRB5_KT_FL_JAVA 1
45 /* file operations -------------------------------------------- */
52 static krb5_error_code
53 krb5_kt_ret_data(krb5_context context,
59 ret = krb5_ret_int16(sp, &size);
63 data->data = malloc(size);
64 if (data->data == NULL) {
65 krb5_set_error_string (context, "malloc: out of memory");
68 ret = krb5_storage_read(sp, data->data, size);
70 return (ret < 0)? errno : KRB5_KT_END;
74 static krb5_error_code
75 krb5_kt_ret_string(krb5_context context,
77 heim_general_string *data)
81 ret = krb5_ret_int16(sp, &size);
84 *data = malloc(size + 1);
86 krb5_set_error_string (context, "malloc: out of memory");
89 ret = krb5_storage_read(sp, *data, size);
92 return (ret < 0)? errno : KRB5_KT_END;
96 static krb5_error_code
97 krb5_kt_store_data(krb5_context context,
102 ret = krb5_store_int16(sp, data.length);
105 ret = krb5_storage_write(sp, data.data, data.length);
106 if(ret != data.length){
114 static krb5_error_code
115 krb5_kt_store_string(krb5_storage *sp,
116 heim_general_string data)
119 size_t len = strlen(data);
120 ret = krb5_store_int16(sp, len);
123 ret = krb5_storage_write(sp, data, len);
132 static krb5_error_code
133 krb5_kt_ret_keyblock(krb5_context context, krb5_storage *sp, krb5_keyblock *p)
138 ret = krb5_ret_int16(sp, &tmp); /* keytype + etype */
141 ret = krb5_kt_ret_data(context, sp, &p->keyvalue);
145 static krb5_error_code
146 krb5_kt_store_keyblock(krb5_context context,
152 ret = krb5_store_int16(sp, p->keytype); /* keytype + etype */
154 ret = krb5_kt_store_data(context, sp, p->keyvalue);
159 static krb5_error_code
160 krb5_kt_ret_principal(krb5_context context,
162 krb5_principal *princ)
171 krb5_set_error_string (context, "malloc: out of memory");
175 ret = krb5_ret_int16(sp, &len);
177 krb5_set_error_string(context,
178 "Failed decoding length of keytab principal");
181 if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS))
184 krb5_set_error_string(context,
185 "Keytab principal contains invalid length");
189 ret = krb5_kt_ret_string(context, sp, &p->realm);
192 p->name.name_string.val = calloc(len, sizeof(*p->name.name_string.val));
193 if(p->name.name_string.val == NULL) {
194 krb5_set_error_string (context, "malloc: out of memory");
198 p->name.name_string.len = len;
199 for(i = 0; i < p->name.name_string.len; i++){
200 ret = krb5_kt_ret_string(context, sp, p->name.name_string.val + i);
204 if (krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE))
205 p->name.name_type = KRB5_NT_UNKNOWN;
208 ret = krb5_ret_int32(sp, &tmp32);
209 p->name.name_type = tmp32;
216 krb5_free_principal(context, p);
220 static krb5_error_code
221 krb5_kt_store_principal(krb5_context context,
228 if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS))
229 ret = krb5_store_int16(sp, p->name.name_string.len + 1);
231 ret = krb5_store_int16(sp, p->name.name_string.len);
233 ret = krb5_kt_store_string(sp, p->realm);
235 for(i = 0; i < p->name.name_string.len; i++){
236 ret = krb5_kt_store_string(sp, p->name.name_string.val[i]);
240 if(!krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE)) {
241 ret = krb5_store_int32(sp, p->name.name_type);
249 static krb5_error_code
250 fkt_resolve(krb5_context context, const char *name, krb5_keytab id)
254 d = malloc(sizeof(*d));
256 krb5_set_error_string (context, "malloc: out of memory");
259 d->filename = strdup(name);
260 if(d->filename == NULL) {
262 krb5_set_error_string (context, "malloc: out of memory");
270 static krb5_error_code
271 fkt_resolve_java14(krb5_context context, const char *name, krb5_keytab id)
275 ret = fkt_resolve(context, name, id);
277 struct fkt_data *d = id->data;
278 d->flags |= KRB5_KT_FL_JAVA;
283 static krb5_error_code
284 fkt_close(krb5_context context, krb5_keytab id)
286 struct fkt_data *d = id->data;
292 static krb5_error_code
293 fkt_get_name(krb5_context context,
298 /* This function is XXX */
299 struct fkt_data *d = id->data;
300 strlcpy(name, d->filename, namesize);
305 storage_set_flags(krb5_context context, krb5_storage *sp, int vno)
310 flags |= KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS;
311 flags |= KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE;
312 flags |= KRB5_STORAGE_HOST_BYTEORDER;
318 "storage_set_flags called with bad vno (%d)", vno);
320 krb5_storage_set_flags(sp, flags);
323 static krb5_error_code
324 fkt_start_seq_get_int(krb5_context context,
332 struct fkt_data *d = id->data;
334 c->fd = open (d->filename, flags);
337 krb5_set_error_string(context, "%s: %s", d->filename,
341 ret = _krb5_xlock(context, c->fd, exclusive, d->filename);
346 c->sp = krb5_storage_from_fd(c->fd);
348 _krb5_xunlock(context, c->fd);
350 krb5_set_error_string (context, "malloc: out of memory");
353 krb5_storage_set_eof_code(c->sp, KRB5_KT_END);
354 ret = krb5_ret_int8(c->sp, &pvno);
356 krb5_storage_free(c->sp);
357 _krb5_xunlock(context, c->fd);
359 krb5_clear_error_string(context);
363 krb5_storage_free(c->sp);
364 _krb5_xunlock(context, c->fd);
366 krb5_clear_error_string (context);
367 return KRB5_KEYTAB_BADVNO;
369 ret = krb5_ret_int8(c->sp, &tag);
371 krb5_storage_free(c->sp);
372 _krb5_xunlock(context, c->fd);
374 krb5_clear_error_string(context);
378 storage_set_flags(context, c->sp, id->version);
382 static krb5_error_code
383 fkt_start_seq_get(krb5_context context,
387 return fkt_start_seq_get_int(context, id, O_RDONLY | O_BINARY, 0, c);
390 static krb5_error_code
391 fkt_next_entry_int(krb5_context context,
393 krb5_keytab_entry *entry,
394 krb5_kt_cursor *cursor,
404 pos = krb5_storage_seek(cursor->sp, 0, SEEK_CUR);
406 ret = krb5_ret_int32(cursor->sp, &len);
410 pos = krb5_storage_seek(cursor->sp, -len, SEEK_CUR);
413 ret = krb5_kt_ret_principal (context, cursor->sp, &entry->principal);
416 ret = krb5_ret_int32(cursor->sp, &tmp32);
417 entry->timestamp = tmp32;
420 ret = krb5_ret_int8(cursor->sp, &tmp8);
424 ret = krb5_kt_ret_keyblock (context, cursor->sp, &entry->keyblock);
427 /* there might be a 32 bit kvno here
428 * if it's zero, assume that the 8bit one was right,
429 * otherwise trust the new value */
430 curpos = krb5_storage_seek(cursor->sp, 0, SEEK_CUR);
431 if(len + 4 + pos - curpos >= 4) {
432 ret = krb5_ret_int32(cursor->sp, &tmp32);
433 if (ret == 0 && tmp32 != 0) {
437 if(start) *start = pos;
438 if(end) *end = pos + 4 + len;
440 krb5_storage_seek(cursor->sp, pos + 4 + len, SEEK_SET);
444 static krb5_error_code
445 fkt_next_entry(krb5_context context,
447 krb5_keytab_entry *entry,
448 krb5_kt_cursor *cursor)
450 return fkt_next_entry_int(context, id, entry, cursor, NULL, NULL);
453 static krb5_error_code
454 fkt_end_seq_get(krb5_context context,
456 krb5_kt_cursor *cursor)
458 krb5_storage_free(cursor->sp);
459 _krb5_xunlock(context, cursor->fd);
464 static krb5_error_code
465 fkt_setup_keytab(krb5_context context,
470 ret = krb5_store_int8(sp, 5);
474 id->version = KRB5_KT_VNO;
475 return krb5_store_int8 (sp, id->version);
478 static krb5_error_code
479 fkt_add_entry(krb5_context context,
481 krb5_keytab_entry *entry)
486 struct fkt_data *d = id->data;
490 fd = open (d->filename, O_RDWR | O_BINARY);
492 fd = open (d->filename, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0600);
495 krb5_set_error_string(context, "open(%s): %s", d->filename,
499 ret = _krb5_xlock(context, fd, 1, d->filename);
504 sp = krb5_storage_from_fd(fd);
505 krb5_storage_set_eof_code(sp, KRB5_KT_END);
506 ret = fkt_setup_keytab(context, id, sp);
510 storage_set_flags(context, sp, id->version);
513 ret = _krb5_xlock(context, fd, 1, d->filename);
518 sp = krb5_storage_from_fd(fd);
519 krb5_storage_set_eof_code(sp, KRB5_KT_END);
520 ret = krb5_ret_int8(sp, &pvno);
522 /* we probably have a zero byte file, so try to set it up
524 ret = fkt_setup_keytab(context, id, sp);
526 krb5_set_error_string(context, "%s: keytab is corrupted: %s",
527 d->filename, strerror(ret));
530 storage_set_flags(context, sp, id->version);
533 ret = KRB5_KEYTAB_BADVNO;
534 krb5_set_error_string(context, "%s: %s",
535 d->filename, strerror(ret));
538 ret = krb5_ret_int8 (sp, &tag);
540 krb5_set_error_string(context, "%s: reading tag: %s",
541 d->filename, strerror(ret));
545 storage_set_flags(context, sp, id->version);
551 emem = krb5_storage_emem();
554 krb5_set_error_string (context, "malloc: out of memory");
557 ret = krb5_kt_store_principal(context, emem, entry->principal);
559 krb5_storage_free(emem);
562 ret = krb5_store_int32 (emem, entry->timestamp);
564 krb5_storage_free(emem);
567 ret = krb5_store_int8 (emem, entry->vno % 256);
569 krb5_storage_free(emem);
572 ret = krb5_kt_store_keyblock (context, emem, &entry->keyblock);
574 krb5_storage_free(emem);
577 if ((d->flags & KRB5_KT_FL_JAVA) == 0) {
578 ret = krb5_store_int32 (emem, entry->vno);
580 krb5_storage_free(emem);
585 ret = krb5_storage_to_data(emem, &keytab);
586 krb5_storage_free(emem);
592 ret = krb5_ret_int32(sp, &len);
593 if(ret == KRB5_KT_END) {
599 if(len >= keytab.length) {
600 krb5_storage_seek(sp, -4, SEEK_CUR);
604 krb5_storage_seek(sp, len, SEEK_CUR);
606 ret = krb5_store_int32(sp, len);
607 if(krb5_storage_write(sp, keytab.data, keytab.length) < 0)
609 memset(keytab.data, 0, keytab.length);
610 krb5_data_free(&keytab);
612 krb5_storage_free(sp);
613 _krb5_xunlock(context, fd);
618 static krb5_error_code
619 fkt_remove_entry(krb5_context context,
621 krb5_keytab_entry *entry)
624 krb5_kt_cursor cursor;
625 off_t pos_start, pos_end;
629 ret = fkt_start_seq_get_int(context, id, O_RDWR | O_BINARY, 1, &cursor);
631 goto out; /* return other error here? */
632 while(fkt_next_entry_int(context, id, &e, &cursor,
633 &pos_start, &pos_end) == 0) {
634 if(krb5_kt_compare(context, &e, entry->principal,
635 entry->vno, entry->keyblock.keytype)) {
637 unsigned char buf[128];
639 krb5_storage_seek(cursor.sp, pos_start, SEEK_SET);
640 len = pos_end - pos_start - 4;
641 krb5_store_int32(cursor.sp, -len);
642 memset(buf, 0, sizeof(buf));
644 krb5_storage_write(cursor.sp, buf, min(len, sizeof(buf)));
645 len -= min(len, sizeof(buf));
648 krb5_kt_free_entry(context, &e);
650 krb5_kt_end_seq_get(context, id, &cursor);
653 krb5_clear_error_string (context);
654 return KRB5_KT_NOTFOUND;
659 const krb5_kt_ops krb5_fkt_ops = {
672 const krb5_kt_ops krb5_wrfkt_ops = {
685 const krb5_kt_ops krb5_javakt_ops = {