lib/hdb/print.c

   1 /*
   2  * Copyright (c) 1999-2005 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 KTH nor the names of its contributors may be
  18  *    used to endorse or promote products derived from this software without
  19  *    specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY KTH AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KTH OR ITS CONTRIBUTORS BE
  25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  28  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  30  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  31  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
  32
  33 #include "hdb_locl.h"
  34 #include <hex.h>
  35 #include <ctype.h>
  36
  37 /*
  38    This is the present contents of a dump line. This might change at
  39    any time. Fields are separated by white space.
  40
  41   principal
  42   keyblock
  43         kvno
  44         keys...
  45                 mkvno
  46                 enctype
  47                 keyvalue
  48                 salt (- means use normal salt)
  49   creation date and principal
  50   modification date and principal
  51   principal valid from date (not used)
  52   principal valid end date (not used)
  53   principal key expires (not used)
  54   max ticket life
  55   max renewable life
  56   flags
  57   generation number
  58   */
  59
  60 static krb5_error_code
  61 append_string(krb5_context context, krb5_storage *sp, const char *fmt, ...)
  62 {
  63     krb5_error_code ret;
  64     char *s;
  65     int rc;
  66     va_list ap;
  67     va_start(ap, fmt);
  68     rc = vasprintf(&s, fmt, ap);
  69     va_end(ap);
  70     if(rc < 0) {
  71         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
  72         return ENOMEM;
  73     }
  74     ret = krb5_storage_write(sp, s, strlen(s));
  75     free(s);
  76     return ret;
  77 }
  78
  79 static krb5_error_code
  80 append_hex(krb5_context context, krb5_storage *sp, krb5_data *data)
  81 {
  82     int printable = 1;
  83     size_t i;
  84     char *p;
  85
  86     p = data->data;
  87     for(i = 0; i < data->length; i++)
  88         if(!isalnum((unsigned char)p[i]) && p[i] != '.'){
  89             printable = 0;
  90             break;
  91         }
  92     if(printable)
  93         return append_string(context, sp, "\"%.*s\"",
  94                              data->length, data->data);
  95     hex_encode(data->data, data->length, &p);
  96     append_string(context, sp, "%s", p);
  97     free(p);
  98     return 0;
  99 }
 100
 101 static char *
 102 time2str(time_t t)
 103 {
 104     static char buf[128];
 105     strftime(buf, sizeof(buf), "%Y%m%d%H%M%S", gmtime(&t));
 106     return buf;
 107 }
 108
 109 static krb5_error_code
 110 append_event(krb5_context context, krb5_storage *sp, Event *ev)
 111 {
 112     char *pr = NULL;
 113     krb5_error_code ret;
 114     if(ev == NULL)
 115         return append_string(context, sp, "- ");
 116     if (ev->principal != NULL) {
 117        ret = krb5_unparse_name(context, ev->principal, &pr);
 118        if(ret)
 119            return ret;
 120     }
 121     ret = append_string(context, sp, "%s:%s ",
 122                         time2str(ev->time), pr ? pr : "UNKNOWN");
 123     free(pr);
 124     return ret;
 125 }
 126
 127 static krb5_error_code
 128 entry2string_int (krb5_context context, krb5_storage *sp, hdb_entry *ent)
 129 {
 130     char *p;
 131     size_t i;
 132     krb5_error_code ret;
 133
 134     /* --- principal */
 135     ret = krb5_unparse_name(context, ent->principal, &p);
 136     if(ret)
 137         return ret;
 138     append_string(context, sp, "%s ", p);
 139     free(p);
 140     /* --- kvno */
 141     append_string(context, sp, "%d", ent->kvno);
 142     /* --- keys */
 143     for(i = 0; i < ent->keys.len; i++){
 144         /* --- mkvno, keytype */
 145         if(ent->keys.val[i].mkvno)
 146             append_string(context, sp, ":%d:%d:",
 147                           *ent->keys.val[i].mkvno,
 148                           ent->keys.val[i].key.keytype);
 149         else
 150             append_string(context, sp, "::%d:",
 151                           ent->keys.val[i].key.keytype);
 152         /* --- keydata */
 153         append_hex(context, sp, &ent->keys.val[i].key.keyvalue);
 154         append_string(context, sp, ":");
 155         /* --- salt */
 156         if(ent->keys.val[i].salt){
 157             append_string(context, sp, "%u/", ent->keys.val[i].salt->type);
 158             append_hex(context, sp, &ent->keys.val[i].salt->salt);
 159         }else
 160             append_string(context, sp, "-");
 161     }
 162     append_string(context, sp, " ");
 163     /* --- created by */
 164     append_event(context, sp, &ent->created_by);
 165     /* --- modified by */
 166     append_event(context, sp, ent->modified_by);
 167
 168     /* --- valid start */
 169     if(ent->valid_start)
 170         append_string(context, sp, "%s ", time2str(*ent->valid_start));
 171     else
 172         append_string(context, sp, "- ");
 173
 174     /* --- valid end */
 175     if(ent->valid_end)
 176         append_string(context, sp, "%s ", time2str(*ent->valid_end));
 177     else
 178         append_string(context, sp, "- ");
 179
 180     /* --- password ends */
 181     if(ent->pw_end)
 182         append_string(context, sp, "%s ", time2str(*ent->pw_end));
 183     else
 184         append_string(context, sp, "- ");
 185
 186     /* --- max life */
 187     if(ent->max_life)
 188         append_string(context, sp, "%d ", *ent->max_life);
 189     else
 190         append_string(context, sp, "- ");
 191
 192     /* --- max renewable life */
 193     if(ent->max_renew)
 194         append_string(context, sp, "%d ", *ent->max_renew);
 195     else
 196         append_string(context, sp, "- ");
 197
 198     /* --- flags */
 199     append_string(context, sp, "%d ", HDBFlags2int(ent->flags));
 200
 201     /* --- generation number */
 202     if(ent->generation) {
 203         append_string(context, sp, "%s:%d:%d ", time2str(ent->generation->time),
 204                       ent->generation->usec,
 205                       ent->generation->gen);
 206     } else
 207         append_string(context, sp, "- ");
 208
 209     /* --- extensions */
 210     if(ent->extensions && ent->extensions->len > 0) {
 211         for(i = 0; i < ent->extensions->len; i++) {
 212             void *d;
 213             size_t size, sz = 0;
 214
 215             ASN1_MALLOC_ENCODE(HDB_extension, d, size,
 216                                &ent->extensions->val[i], &sz, ret);
 217             if (ret) {
 218                 krb5_clear_error_message(context);
 219                 return ret;
 220             }
 221             if(size != sz)
 222                 krb5_abortx(context, "internal asn.1 encoder error");
 223
 224             if (hex_encode(d, size, &p) < 0) {
 225                 free(d);
 226                 krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 227                 return ENOMEM;
 228             }
 229
 230             free(d);
 231             append_string(context, sp, "%s%s", p,
 232                           ent->extensions->len - 1 != i ? ":" : "");
 233             free(p);
 234         }
 235     } else
 236         append_string(context, sp, "-");
 237
 238     return 0;
 239 }
 240
 241 krb5_error_code
 242 hdb_entry2string (krb5_context context, hdb_entry *ent, char **str)
 243 {
 244     krb5_error_code ret;
 245     krb5_data data;
 246     krb5_storage *sp;
 247
 248     sp = krb5_storage_emem();
 249     if(sp == NULL) {
 250         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 251         return ENOMEM;
 252     }
 253
 254     ret = entry2string_int(context, sp, ent);
 255     if(ret) {
 256         krb5_storage_free(sp);
 257         return ret;
 258     }
 259
 260     krb5_storage_write(sp, "\0", 1);
 261     krb5_storage_to_data(sp, &data);
 262     krb5_storage_free(sp);
 263     *str = data.data;
 264     return 0;
 265 }
 266
 267 /* print a hdb_entry to (FILE*)data; suitable for hdb_foreach */
 268
 269 krb5_error_code
 270 hdb_print_entry(krb5_context context, HDB *db, hdb_entry_ex *entry, void *data)
 271 {
 272     krb5_error_code ret;
 273     krb5_storage *sp;
 274
 275     FILE *f = data;
 276
 277     fflush(f);
 278     sp = krb5_storage_from_fd(fileno(f));
 279     if(sp == NULL) {
 280         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
 281         return ENOMEM;
 282     }
 283
 284     ret = entry2string_int(context, sp, &entry->entry);
 285     if(ret) {
 286         krb5_storage_free(sp);
 287         return ret;
 288     }
 289
 290     krb5_storage_write(sp, "\n", 1);
 291     krb5_storage_free(sp);
 292     return 0;
 293 }