lib/encapreppart.c

   1 /* encapreppart.c       Key distribution encrypted reply part functions
   2  * Copyright (C) 2002, 2003  Simon Josefsson
   3  *
   4  * This file is part of Shishi.
   5  *
   6  * Shishi is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Shishi is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Shishi; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "internal.h"
  23
  24 /**
  25  * shishi_encapreppart:
  26  * @handle: shishi handle as allocated by shishi_init().
  27  *
  28  * This function creates a new EncAPRepPart, populated with some
  29  * default values.  It uses the current time as returned by the system
  30  * for the ctime and cusec fields.
  31  *
  32  * Return value: Returns the encapreppart or NULL on failure.
  33  **/
  34 Shishi_asn1
  35 shishi_encapreppart (Shishi * handle)
  36 {
  37   int res;
  38   Shishi_asn1 node = NULL;
  39   struct timeval tv;
  40   struct timezone tz;
  41
  42   node = shishi_asn1_encapreppart (handle);
  43   if (!node)
  44     return NULL;
  45
  46   res = shishi_asn1_write (handle, node, "ctime",
  47                            shishi_generalize_time (handle, time (NULL)), 0);
  48   if (res != SHISHI_OK)
  49     goto error;
  50
  51   gettimeofday (&tv, &tz);
  52   res = shishi_asn1_write_integer (handle, node, "cusec",
  53                                    tv.tv_usec % 1000000);
  54   if (res != SHISHI_OK)
  55     goto error;
  56
  57   res = shishi_asn1_write (handle, node, "subkey", NULL, 0);
  58   if (res != SHISHI_OK)
  59     goto error;
  60
  61   res = shishi_asn1_write (handle, node, "seq-number", NULL, 0);
  62   if (res != SHISHI_OK)
  63     goto error;
  64
  65   return node;
  66
  67 error:
  68   shishi_asn1_done (handle, node);
  69   return NULL;
  70 }
  71
  72 /**
  73  * shishi_encapreppart_print:
  74  * @handle: shishi handle as allocated by shishi_init().
  75  * @fh: file handle open for writing.
  76  * @encapreppart: EncAPRepPart to print.
  77  *
  78  * Print ASCII armored DER encoding of EncAPRepPart to file.
  79  *
  80  * Return value: Returns SHISHI_OK iff successful.
  81  **/
  82 int
  83 shishi_encapreppart_print (Shishi * handle, FILE * fh,
  84                            Shishi_asn1 encapreppart)
  85 {
  86   return _shishi_print_armored_data (handle, fh, encapreppart,
  87                                      "EncAPRepPart", NULL);
  88 }
  89
  90 /**
  91  * shishi_encapreppart_save:
  92  * @handle: shishi handle as allocated by shishi_init().
  93  * @fh: file handle open for writing.
  94  * @encapreppart: EncAPRepPart to save.
  95  *
  96  * Save DER encoding of EncAPRepPart to file.
  97  *
  98  * Return value: Returns SHISHI_OK iff successful.
  99  **/
 100 int
 101 shishi_encapreppart_save (Shishi * handle, FILE * fh,
 102                           Shishi_asn1 encapreppart)
 103 {
 104   return _shishi_save_data (handle, fh, encapreppart, "EncAPRepPart");
 105 }
 106
 107 /**
 108  * shishi_encapreppart_to_file:
 109  * @handle: shishi handle as allocated by shishi_init().
 110  * @encapreppart: EncAPRepPart to save.
 111  * @filetype: input variable specifying type of file to be written,
 112  *            see Shishi_filetype.
 113  * @filename: input variable with filename to write to.
 114  *
 115  * Write EncAPRepPart to file in specified TYPE.  The file will be
 116  * truncated if it exists.
 117  *
 118  * Return value: Returns SHISHI_OK iff successful.
 119  **/
 120 int
 121 shishi_encapreppart_to_file (Shishi * handle, Shishi_asn1 encapreppart,
 122                              int filetype, char *filename)
 123 {
 124   FILE *fh;
 125   int res;
 126
 127   if (VERBOSE (handle))
 128     printf (_("Writing EncAPRepPart to %s...\n"), filename);
 129
 130   fh = fopen (filename, "w");
 131   if (fh == NULL)
 132     return SHISHI_FOPEN_ERROR;
 133
 134   if (VERBOSE (handle))
 135     printf (_("Writing EncAPRepPart in %s format...\n"),
 136             filetype == SHISHI_FILETYPE_TEXT ? "TEXT" : "DER");
 137
 138   if (filetype == SHISHI_FILETYPE_TEXT)
 139     res = shishi_encapreppart_print (handle, fh, encapreppart);
 140   else
 141     res = shishi_encapreppart_save (handle, fh, encapreppart);
 142   if (res != SHISHI_OK)
 143     return res;
 144
 145   res = fclose (fh);
 146   if (res != 0)
 147     return SHISHI_FCLOSE_ERROR;
 148
 149   if (VERBOSE (handle))
 150     printf (_("Writing EncAPRepPart to %s...done\n"), filename);
 151
 152   return SHISHI_OK;
 153 }
 154
 155 /**
 156  * shishi_encapreppart_parse:
 157  * @handle: shishi handle as allocated by shishi_init().
 158  * @fh: file handle open for reading.
 159  * @encapreppart: output variable with newly allocated EncAPRepPart.
 160  *
 161  * Read ASCII armored DER encoded EncAPRepPart from file and populate given
 162  * variable.
 163  *
 164  * Return value: Returns SHISHI_OK iff successful.
 165  **/
 166 int
 167 shishi_encapreppart_parse (Shishi * handle, FILE * fh,
 168                            Shishi_asn1 * encapreppart)
 169 {
 170   return _shishi_encapreppart_input (handle, fh, encapreppart, 0);
 171 }
 172
 173 /**
 174  * shishi_encapreppart_read:
 175  * @handle: shishi handle as allocated by shishi_init().
 176  * @fh: file handle open for reading.
 177  * @encapreppart: output variable with newly allocated EncAPRepPart.
 178  *
 179  * Read DER encoded EncAPRepPart from file and populate given variable.
 180  *
 181  * Return value: Returns SHISHI_OK iff successful.
 182  **/
 183 int
 184 shishi_encapreppart_read (Shishi * handle, FILE * fh,
 185                           Shishi_asn1 * encapreppart)
 186 {
 187   return _shishi_encapreppart_input (handle, fh, encapreppart, 1);
 188 }
 189
 190 /**
 191  * shishi_encapreppart_from_file:
 192  * @handle: shishi handle as allocated by shishi_init().
 193  * @encapreppart: output variable with newly allocated EncAPRepPart.
 194  * @filetype: input variable specifying type of file to be read,
 195  *            see Shishi_filetype.
 196  * @filename: input variable with filename to read from.
 197  *
 198  * Read EncAPRepPart from file in specified TYPE.
 199  *
 200  * Return value: Returns SHISHI_OK iff successful.
 201  **/
 202 int
 203 shishi_encapreppart_from_file (Shishi * handle, Shishi_asn1 * encapreppart,
 204                                int filetype, char *filename)
 205 {
 206   int res;
 207   FILE *fh;
 208
 209   if (VERBOSE (handle))
 210     printf (_("Reading EncAPRepPart from %s...\n"), filename);
 211
 212   fh = fopen (filename, "r");
 213   if (fh == NULL)
 214     return SHISHI_FOPEN_ERROR;
 215
 216   if (VERBOSE (handle))
 217     printf (_("Reading EncAPRepPart in %s format...\n"),
 218             filetype == SHISHI_FILETYPE_TEXT ? "TEXT" : "DER");
 219
 220   if (filetype == SHISHI_FILETYPE_TEXT)
 221     res = shishi_encapreppart_parse (handle, fh, encapreppart);
 222   else
 223     res = shishi_encapreppart_read (handle, fh, encapreppart);
 224   if (res != SHISHI_OK)
 225     return res;
 226
 227   res = fclose (fh);
 228   if (res != 0)
 229     return SHISHI_FCLOSE_ERROR;
 230
 231   if (VERBOSE (handle))
 232     printf (_("Reading EncAPRepPart from %s...done\n"), filename);
 233
 234   return SHISHI_OK;
 235 }
 236
 237 /**
 238  * shishi_encapreppart_get_key:
 239  * @handle: shishi handle as allocated by shishi_init().
 240  * @encapreppart: input EncAPRepPart variable.
 241  * @keytype: output variable that holds key type.
 242  * @keyvalue: output array with key.
 243  * @keyvalue_len: on input, maximum size of output array with key,
 244  *                on output, holds the actual size of output array with key.
 245  *
 246  * Extract the subkey from the encrypted AP-REP part.
 247  *
 248  * Return value: Returns SHISHI_OK iff succesful.
 249  **/
 250 int
 251 shishi_encapreppart_get_key (Shishi * handle,
 252                              Shishi_asn1 encapreppart,
 253                              int32_t * keytype,
 254                              char *keyvalue, size_t * keyvalue_len)
 255 {
 256   int res;
 257
 258   *keytype = 0;
 259   res = shishi_asn1_read_int32 (handle, encapreppart,
 260                                 "subkey.keytype", keytype);
 261   if (res != SHISHI_OK)
 262     return res;
 263
 264   res = shishi_asn1_read (handle, encapreppart,
 265                           "subkey.keyvalue", keyvalue, keyvalue_len);
 266   if (res != SHISHI_OK)
 267     return res;
 268
 269   return SHISHI_OK;
 270 }
 271
 272 /**
 273  * shishi_encapreppart_ctime:
 274  * @handle: shishi handle as allocated by shishi_init().
 275  * @encapreppart: EncAPRepPart as allocated by shishi_encapreppart().
 276  * @ctime: newly allocated zero-terminated character array with client time.
 277  *
 278  * Extract client time from EncAPRepPart.
 279  *
 280  * Return value: Returns SHISHI_OK iff successful.
 281  **/
 282 int
 283 shishi_encapreppart_ctime (Shishi * handle,
 284                            Shishi_asn1 encapreppart, char **ctime)
 285 {
 286   return shishi_time (handle, encapreppart, "ctime", ctime);
 287 }
 288
 289 /**
 290  * shishi_encapreppart_ctime_set:
 291  * @handle: shishi handle as allocated by shishi_init().
 292  * @encapreppart: EncAPRepPart as allocated by shishi_encapreppart().
 293  * @ctime: string with generalized time value to store in EncAPRepPart.
 294  *
 295  * Store client time in EncAPRepPart.
 296  *
 297  * Return value: Returns SHISHI_OK iff successful.
 298  **/
 299 int
 300 shishi_encapreppart_ctime_set (Shishi * handle,
 301                                Shishi_asn1 encapreppart, char *ctime)
 302 {
 303   int res;
 304
 305   res = shishi_asn1_write (handle, encapreppart, "ctime",
 306                            ctime, GENERALIZEDTIME_TIME_LEN);
 307   if (res != SHISHI_OK)
 308     return res;
 309
 310   return SHISHI_OK;
 311 }
 312
 313 /**
 314  * shishi_encapreppart_cusec_get:
 315  * @handle: shishi handle as allocated by shishi_init().
 316  * @encapreppart: EncAPRepPart as allocated by shishi_encapreppart().
 317  * @cusec: output integer with client microseconds field.
 318  *
 319  * Extract client microseconds field from EncAPRepPart.
 320  *
 321  * Return value: Returns SHISHI_OK iff successful.
 322  **/
 323 int
 324 shishi_encapreppart_cusec_get (Shishi * handle,
 325                                Shishi_asn1 encapreppart, int *cusec)
 326 {
 327   int res;
 328
 329   res = shishi_asn1_read_integer (handle, encapreppart, "cusec", cusec);
 330   if (res != SHISHI_OK)
 331     return res;
 332
 333   return res;
 334 }
 335
 336 /**
 337  * shishi_encapreppart_cusec_set:
 338  * @handle: shishi handle as allocated by shishi_init().
 339  * @encapreppart: EncAPRepPart as allocated by shishi_encapreppart().
 340  * @cusec: client microseconds to set in authenticator, 0-999999.
 341  *
 342  * Set the cusec field in the Authenticator.
 343  *
 344  * Return value: Returns SHISHI_OK iff successful.
 345  **/
 346 int
 347 shishi_encapreppart_cusec_set (Shishi * handle,
 348                                Shishi_asn1 encapreppart, int cusec)
 349 {
 350   int res;
 351
 352   res = shishi_asn1_write_integer (handle, encapreppart, "cusec", cusec);
 353   if (res != SHISHI_OK)
 354     return res;
 355
 356   return SHISHI_OK;
 357 }
 358
 359 /**
 360  * shishi_encapreppart_seqnumber_get:
 361  * @handle: shishi handle as allocated by shishi_init().
 362  * @encapreppart: EncAPRepPart as allocated by shishi_encapreppart().
 363  * @seqnumber: output integer with sequence number field.
 364  *
 365  * Extract sequence number field from EncAPRepPart.
 366  *
 367  * Return value: Returns SHISHI_OK iff successful.
 368  **/
 369 int
 370 shishi_encapreppart_seqnumber_get (Shishi * handle,
 371                                    Shishi_asn1 encapreppart,
 372                                    uint32_t * seqnumber)
 373 {
 374   int res;
 375
 376   res = shishi_asn1_read_uint32 (handle, encapreppart,
 377                                  "seq-number", seqnumber);
 378   if (res != SHISHI_OK)
 379     return res;
 380
 381   return res;
 382 }
 383
 384 /**
 385  * shishi_encapreppart_time_copy:
 386  * @handle: shishi handle as allocated by shishi_init().
 387  * @encapreppart: EncAPRepPart as allocated by shishi_encapreppart().
 388  * @authenticator: Authenticator to copy time fields from.
 389  *
 390  * Copy time fields from Authenticator into EncAPRepPart.
 391  *
 392  * Return value: Returns SHISHI_OK iff successful.
 393  **/
 394 int
 395 shishi_encapreppart_time_copy (Shishi * handle,
 396                                Shishi_asn1 encapreppart,
 397                                Shishi_asn1 authenticator)
 398 {
 399   char *buf;
 400   size_t buflen;
 401   int res;
 402
 403   res = shishi_asn1_read2 (handle, authenticator, "cusec", &buf, &buflen);
 404   if (res != SHISHI_OK)
 405     return res;
 406
 407   res = shishi_asn1_write (handle, encapreppart, "cusec", buf, buflen);
 408   free (buf);
 409   if (res != SHISHI_OK)
 410     return res;
 411
 412   res = shishi_asn1_read2 (handle, authenticator, "ctime", &buf, &buflen);
 413   if (res != SHISHI_OK)
 414     return res;
 415
 416   res = shishi_asn1_write (handle, encapreppart, "ctime", buf, buflen);
 417   free (buf);
 418   if (res != SHISHI_OK)
 419     return res;
 420
 421   return SHISHI_OK;
 422 }