kadmin/load.c

   1 /*
   2  * Copyright (c) 1997, 1998, 1999 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. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by Kungliga Tekniska
  20  *      Högskolan and its contributors.
  21  *
  22  * 4. Neither the name of the Institute nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  */
  38
  39 #include "kadmin_locl.h"
  40 #include <kadm5/private.h>
  41
  42 RCSID("$Id$");
  43
  44 struct entry{
  45     char *principal;
  46     char *key;
  47     char *max_life;
  48     char *max_renew;
  49     char *created;
  50     char *modified;
  51     char *valid_start;
  52     char *valid_end;
  53     char *pw_end;
  54     char *flags;
  55     char *etypes;
  56 };
  57
  58 static char *
  59 skip_next(char *p)
  60 {
  61     while(*p && !isspace((unsigned char)*p))
  62         p++;
  63     *p++ = 0;
  64     while(*p && isspace((unsigned char)*p)) p++;
  65     return p;
  66 }
  67
  68 static time_t*
  69 parse_time_string(time_t *t, char *s)
  70 {
  71     int year, month, date, hour, minute, second;
  72     struct tm tm;
  73     if(strcmp(s, "-") == 0)
  74         return NULL;
  75     if(t == NULL)
  76         t = malloc(sizeof(*t));
  77     sscanf(s, "%04d%02d%02d%02d%02d%02d",
  78            &year, &month, &date, &hour, &minute, &second);
  79     tm.tm_year = year - 1900;
  80     tm.tm_mon = month - 1;
  81     tm.tm_mday = date;
  82     tm.tm_hour = hour;
  83     tm.tm_min = minute;
  84     tm.tm_sec = second;
  85     tm.tm_isdst = 0;
  86     *t = timegm(&tm);
  87     return t;
  88 }
  89
  90 static unsigned*
  91 parse_integer(unsigned *u, char *s)
  92 {
  93     if(strcmp(s, "-") == 0)
  94         return NULL;
  95     if(u == NULL)
  96         u = malloc(sizeof(*u));
  97     sscanf(s, "%u", u);
  98     return u;
  99 }
 100
 101 static void
 102 parse_keys(hdb_entry *ent, char *str)
 103 {
 104     int tmp;
 105     char *p;
 106     int i;
 107
 108     p = strsep(&str, ":");
 109     sscanf(p, "%d", &tmp);
 110     ent->kvno = tmp;
 111     p = strsep(&str, ":");
 112     while(p){
 113         Key *key;
 114         key = realloc(ent->keys.val,
 115                       (ent->keys.len + 1) * sizeof(*ent->keys.val));
 116         if(key == NULL)
 117             abort();
 118         ent->keys.val = key;
 119         key = ent->keys.val + ent->keys.len;
 120         ent->keys.len++;
 121         memset(key, 0, sizeof(*key));
 122         if(sscanf(p, "%d", &tmp) == 1) {
 123             key->mkvno = malloc(sizeof(*key->mkvno));
 124             *key->mkvno = tmp;
 125         } else
 126             key->mkvno = NULL;
 127         p = strsep(&str, ":");
 128         sscanf(p, "%d", &tmp);
 129         key->key.keytype = tmp;
 130         p = strsep(&str, ":");
 131         krb5_data_alloc(&key->key.keyvalue, (strlen(p) - 1) / 2 + 1);
 132         for(i = 0; i < strlen(p); i += 2){
 133             sscanf(p + i, "%02x", &tmp);
 134             ((u_char*)key->key.keyvalue.data)[i / 2] = tmp;
 135         }
 136         p = strsep(&str, ":");
 137         if(strcmp(p, "-") != 0){
 138             unsigned type;
 139             size_t p_len;
 140             if(sscanf(p, "%u/", &type) != 1){
 141                 abort ();
 142             }
 143             p = strchr(p, '/');
 144             if(p == NULL)
 145                 abort ();
 146             p++;
 147             p_len = strlen(p);
 148
 149             key->salt = malloc(sizeof(*key->salt));
 150             key->salt->type = type;
 151
 152             if (p_len) {
 153                 if(*p == '\"'){
 154                     krb5_data_copy(&key->salt->salt, p + 1, p_len - 2);
 155                 }else{
 156                     krb5_data_alloc(&key->salt->salt, (p_len - 1) / 2 + 1);
 157                     for(i = 0; i < p_len; i += 2){
 158                         sscanf(p + i, "%02x", &tmp);
 159                         ((u_char*)key->salt->salt.data)[i / 2] = tmp;
 160                     }
 161                 }
 162             } else
 163                 krb5_data_zero (&key->salt->salt);
 164         }
 165         p = strsep(&str, ":");
 166     }
 167 }
 168
 169 static Event*
 170 parse_event(Event *ev, char *str)
 171 {
 172     char *p;
 173     if(strcmp(str, "-") == 0)
 174         return NULL;
 175     if(ev == NULL)
 176         ev = malloc(sizeof(*ev));
 177     memset(ev, 0, sizeof(*ev));
 178     p = strsep(&str, ":");
 179     parse_time_string(&ev->time, p);
 180     p = strsep(&str, ":");
 181     krb5_parse_name(context, p, &ev->principal);
 182     return ev;
 183 }
 184
 185 static HDBFlags
 186 parse_hdbflags2int(char *str)
 187 {
 188     unsigned i;
 189     parse_integer(&i, str);
 190
 191     return int2HDBFlags(i);
 192 }
 193
 194 #if 0
 195 static void
 196 parse_etypes(char *str, unsigned **val, unsigned *len)
 197 {
 198     unsigned v;
 199
 200     *val = NULL;
 201     *len = 0;
 202     while(sscanf(str, "%u", &v) == 1) {
 203         *val = realloc(*val, (*len+1) * sizeof(**val));
 204         (*val)[(*len)++] = v;
 205         str = strchr(str, ':');
 206         if(str == NULL)
 207             break;
 208         str++;
 209     }
 210 }
 211 #endif
 212
 213 static void
 214 doit(char *filename, int merge)
 215 {
 216     krb5_error_code ret;
 217     FILE *f;
 218     char s[1024];
 219     char *p;
 220     int line;
 221     int flags = O_RDWR;
 222     struct entry e;
 223     hdb_entry ent;
 224     HDB *db = _kadm5_s_get_db(kadm_handle);
 225
 226     f = fopen(filename, "r");
 227     if(f == NULL){
 228         krb5_warn(context, errno, "fopen(%s)", filename);
 229         return;
 230     }
 231     if(!merge)
 232         flags |= O_CREAT | O_TRUNC;
 233     ret = db->open(context, db, flags, 0600);
 234     if(ret){
 235         krb5_warn(context, ret, "hdb_open");
 236         fclose(f);
 237         return;
 238     }
 239     line = 0;
 240     while(fgets(s, sizeof(s), f)){
 241         line++;
 242         e.principal = s;
 243         for(p = s; *p; p++){
 244             if(*p == '\\')
 245                 p++;
 246             else if(isspace((unsigned char)*p)) {
 247                 *p = 0;
 248                 break;
 249             }
 250         }
 251         p = skip_next(p);
 252
 253         e.key = p;
 254         p = skip_next(p);
 255
 256         e.created = p;
 257         p = skip_next(p);
 258
 259         e.modified = p;
 260         p = skip_next(p);
 261
 262         e.valid_start = p;
 263         p = skip_next(p);
 264
 265         e.valid_end = p;
 266         p = skip_next(p);
 267
 268         e.pw_end = p;
 269         p = skip_next(p);
 270
 271         e.max_life = p;
 272         p = skip_next(p);
 273
 274         e.max_renew = p;
 275         p = skip_next(p);
 276
 277         e.flags = p;
 278         p = skip_next(p);
 279
 280         e.etypes = p;
 281         p = skip_next(p);
 282
 283         memset(&ent, 0, sizeof(ent));
 284         ret = krb5_parse_name(context, e.principal, &ent.principal);
 285         if(ret){
 286             fprintf(stderr, "%s:%d:%s (%s)\n",
 287                     filename,
 288                     line,
 289                     krb5_get_err_text(context, ret),
 290                     e.principal);
 291             continue;
 292         }
 293
 294         parse_keys(&ent, e.key);
 295
 296         parse_event(&ent.created_by, e.created);
 297         ent.modified_by = parse_event(NULL, e.modified);
 298         ent.valid_start = parse_time_string(NULL, e.valid_start);
 299         ent.valid_end = parse_time_string(NULL, e.valid_end);
 300         ent.pw_end = parse_time_string(NULL, e.pw_end);
 301         ent.max_life = parse_integer(NULL, e.max_life);
 302         ent.max_renew = parse_integer(NULL, e.max_renew);
 303         ent.flags = parse_hdbflags2int(e.flags);
 304 #if 0
 305         ALLOC(ent.etypes);
 306         parse_etypes(e.etypes, &ent.etypes->val, &ent.etypes->len);
 307         if(ent.etypes->len == 0) {
 308             free(ent.etypes);
 309             ent.etypes = NULL;
 310         }
 311 #endif
 312
 313         db->store(context, db, HDB_F_REPLACE, &ent);
 314         hdb_free_entry (context, &ent);
 315     }
 316     db->close(context, db);
 317     fclose(f);
 318 }
 319
 320 int
 321 load(int argc, char **argv)
 322 {
 323     if(argc < 2){
 324         krb5_warnx(context, "Usage: load filename");
 325         return 0;
 326     }
 327     doit(argv[1], 0);
 328     return 0;
 329 }
 330
 331 int
 332 merge(int argc, char **argv)
 333 {
 334     if(argc < 2){
 335         krb5_warnx(context, "Usage: merge filename");
 336         return 0;
 337     }
 338     doit(argv[1], 1);
 339     return 0;
 340 }