crypto/external/bsd/heimdal/dist/lib/hdb/print.c

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