lib/key.c

   1 /* key.c        Key related 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 struct Shishi_key
  25 {
  26   Shishi *handle;
  27   char *principal;
  28   char *realm;
  29   int type;
  30   char value[MAX_KEY_LEN];
  31   int version;
  32 };
  33
  34 /**
  35  * shishi_key_principal:
  36  * @key: structure that holds key information
  37  *
  38  * Return value: Returns the principal owning the key.  (Not a copy of
  39  * it, so don't modify or deallocate it.)
  40  **/
  41 const char *
  42 shishi_key_principal (Shishi_key * key)
  43 {
  44   return key->principal;
  45 }
  46
  47 /**
  48  * shishi_key_principal_set:
  49  * @key: structure that holds key information
  50  * @principal: string with new principal name.
  51  *
  52  * Set the principal owning the key. The string is copied into the
  53  * key, so you can dispose of the variable immediately after calling
  54  * this function.
  55  **/
  56 void
  57 shishi_key_principal_set (Shishi_key * key, const char *principal)
  58 {
  59   if (key->principal)
  60     free (key->principal);
  61   if (principal)
  62     key->principal = strdup (principal);
  63   else
  64     key->principal = NULL;
  65 }
  66
  67 /**
  68  * shishi_key_realm:
  69  * @key: structure that holds key information
  70  *
  71  * Return value: Returns the realm for the principal owning the key.
  72  * (Not a copy of it, so don't modify or deallocate it.)
  73  **/
  74 const char *
  75 shishi_key_realm (Shishi_key * key)
  76 {
  77   return key->realm;
  78 }
  79
  80 /**
  81  * shishi_key_realm_set:
  82  * @key: structure that holds key information
  83  * @realm: string with new realm name.
  84  *
  85  * Set the realm for the principal owning the key. The string is
  86  * copied into the key, so you can dispose of the variable immediately
  87  * after calling this function.
  88  **/
  89 void
  90 shishi_key_realm_set (Shishi_key * key, const char *realm)
  91 {
  92   if (key->realm)
  93     free (key->realm);
  94   if (realm)
  95     key->realm = strdup (realm);
  96   else
  97     key->realm = NULL;
  98 }
  99
 100 /**
 101  * shishi_key_type:
 102  * @key: structure that holds key information
 103  *
 104  * Return value: Returns the type of key as an integer as described in
 105  * the standard.
 106  **/
 107 int
 108 shishi_key_type (Shishi_key * key)
 109 {
 110   return key->type;
 111 }
 112
 113 /**
 114  * shishi_key_type_set:
 115  * @key: structure that holds key information
 116  *
 117  * Set the type of key in key structure.
 118  **/
 119 void
 120 shishi_key_type_set (Shishi_key * key, int32_t type)
 121 {
 122   key->type = type;
 123 }
 124
 125 /**
 126  * shishi_key_value:
 127  * @key: structure that holds key information
 128  *
 129  * Return value: Returns the key value as a pointer which is valid
 130  * throughout the lifetime of the key structure.
 131  **/
 132 char *
 133 shishi_key_value (Shishi_key * key)
 134 {
 135   return key->value;
 136 }
 137
 138 /**
 139  * shishi_key_value_set:
 140  * @key: structure that holds key information
 141  * @value: input array with key data.
 142  * @length: length of input array with key data.
 143  *
 144  * Set the key value and length in key structure.
 145  **/
 146 void
 147 shishi_key_value_set (Shishi_key * key, const char *value)
 148 {
 149   if (value &&
 150       shishi_cipher_keylen (key->type) > 0 &&
 151       shishi_cipher_keylen (key->type) <= MAX_KEY_LEN)
 152     memcpy (key->value, value, shishi_cipher_keylen (key->type));
 153 }
 154
 155 /**
 156  * shishi_key_version:
 157  * @key: structure that holds key information
 158  *
 159  * Return value: Returns the version of key ("kvno").
 160  **/
 161 int
 162 shishi_key_version (Shishi_key * key)
 163 {
 164   return key->version;
 165 }
 166
 167 /**
 168  * shishi_key_version_set:
 169  * @key: structure that holds key information
 170  * @version: new version integer.
 171  *
 172  * Set the version of key ("kvno") in key structure.
 173  **/
 174 void
 175 shishi_key_version_set (Shishi_key * key, int version)
 176 {
 177   key->version = version;
 178 }
 179
 180 /**
 181  * shishi_key_name:
 182  * @key: structure that holds key information
 183  *
 184  * Calls shishi_cipher_name for key type.
 185  *
 186  * Return value: Return name of key.
 187  **/
 188 const char *
 189 shishi_key_name (Shishi_key * key)
 190 {
 191   return shishi_cipher_name (key->type);
 192 }
 193
 194 /**
 195  * shishi_key_length:
 196  * @key: structure that holds key information
 197  *
 198  * Calls shishi_cipher_keylen for key type.
 199  *
 200  * Return value: Returns the length of the key value.
 201  **/
 202 size_t
 203 shishi_key_length (Shishi_key * key)
 204 {
 205   return shishi_cipher_keylen (key->type);
 206 }
 207
 208 /**
 209  * shishi_key:
 210  * @handle: Shishi library handle create by shishi_init().
 211  * @key: pointer to structure that will hold newly created key information
 212  *
 213  * Create a new Key information structure.
 214  *
 215  * Return value: Returns SHISHI_MALLOC_ERROR on memory allocation
 216  *               errors, and SHISHI_OK on success.
 217  **/
 218 int
 219 shishi_key (Shishi * handle, Shishi_key ** key)
 220 {
 221   *key = malloc (sizeof (**key));
 222   if (!*key)
 223     return SHISHI_MALLOC_ERROR;
 224   memset (*key, 0, sizeof (**key));
 225
 226   (*key)->handle = handle;
 227
 228   return SHISHI_OK;
 229 }
 230
 231 /**
 232  * shishi_key_done:
 233  * @key: pointer to structure that holds key information.
 234  *
 235  * Deallocates key information structure and set key handle to NULL.
 236  **/
 237 void
 238 shishi_key_done (Shishi_key ** key)
 239 {
 240   free (*key);
 241   *key = NULL;
 242 }
 243
 244 /**
 245  * shishi_key_copy:
 246  * @dstkey: structure that holds destination key information
 247  * @srckey: structure that holds source key information
 248  *
 249  * Copies source key into existing allocated destination key.
 250  **/
 251 void
 252 shishi_key_copy (Shishi_key * dstkey, Shishi_key * srckey)
 253 {
 254   shishi_key_principal_set (dstkey, shishi_key_principal (srckey));
 255   shishi_key_realm_set (dstkey, shishi_key_realm (srckey));
 256   shishi_key_type_set (dstkey, shishi_key_type (srckey));
 257   shishi_key_value_set (dstkey, shishi_key_value (srckey));
 258   shishi_key_version_set (dstkey, shishi_key_version (srckey));
 259 }
 260
 261 /**
 262  * shishi_key_from_value:
 263  * @handle: Shishi library handle create by shishi_init().
 264  * @type: type of key.
 265  * @value: input array with key value, or NULL.
 266  * @key: pointer to structure that will hold newly created key information
 267  *
 268  * Create a new Key information structure, and set the key type and
 269  * key value. KEY contains a newly allocated structure only if this
 270  * function is successful.
 271  *
 272  * Return value: Returns SHISHI_MALLOC_ERROR on memory allocation
 273  *               errors, and SHISHI_OK on success.
 274  **/
 275 int
 276 shishi_key_from_value (Shishi * handle,
 277                        int32_t type, char *value, Shishi_key ** key)
 278 {
 279   int rc;
 280
 281   rc = shishi_key (handle, key);
 282   if (rc != SHISHI_OK)
 283     return rc;
 284
 285   shishi_key_type_set (*key, type);
 286   if (value)
 287     shishi_key_value_set (*key, value);
 288
 289   return SHISHI_OK;
 290 }
 291
 292 /**
 293  * shishi_key_from_base64:
 294  * @handle: Shishi library handle create by shishi_init().
 295  * @type: type of key.
 296  * @value: input string with base64 encoded key value, or NULL.
 297  * @key: pointer to structure that will hold newly created key information
 298  *
 299  * Create a new Key information structure, and set the key type and
 300  * key value. KEY contains a newly allocated structure only if this
 301  * function is successful.
 302  *
 303  * Return value: Returns SHISHI_MALLOC_ERROR on memory allocation
 304  *               errors, SHISHI_INVALID_KEY if the base64 encoded key
 305  *               length doesn't match the key type, and SHISHI_OK on
 306  *               success.
 307  **/
 308 int
 309 shishi_key_from_base64 (Shishi * handle,
 310                         int32_t type, char *value, Shishi_key ** key)
 311 {
 312   int rc;
 313
 314   rc = shishi_key (handle, key);
 315   if (rc != SHISHI_OK)
 316     return rc;
 317
 318   shishi_key_type_set (*key, type);
 319
 320   if (value)
 321     {
 322       size_t len;
 323       char *buf;
 324
 325       buf = malloc (strlen (value) + 1);
 326       if (!buf)
 327         return SHISHI_MALLOC_ERROR;
 328
 329       len = shishi_from_base64 (buf, value);
 330
 331       if (len != shishi_key_length (*key))
 332         {
 333           free (buf);
 334           return SHISHI_INVALID_KEY;
 335         }
 336
 337       shishi_key_value_set (*key, buf);
 338
 339       free (buf);
 340     }
 341
 342   return SHISHI_OK;
 343 }
 344
 345 /**
 346  * shishi_key_random
 347  * @handle: Shishi library handle create by shishi_init().
 348  * @type: type of key.
 349  *
 350  * Create a new Key information structure for the key type and some
 351  * random data.  KEY contains a newly allocated structure only if this
 352  * function is successful.
 353  *
 354  * Return value: Returns SHISHI_OK iff successful.
 355  **/
 356 int
 357 shishi_key_random (Shishi * handle, int32_t type, Shishi_key ** key)
 358 {
 359   char buf[MAX_RANDOM_LEN];
 360   int len = shishi_cipher_randomlen (type);
 361   int rc;
 362
 363   rc = shishi_key (handle, key);
 364   if (rc != SHISHI_OK)
 365     return rc;
 366
 367   rc = shishi_randomize (handle, buf, len);
 368   if (rc != SHISHI_OK)
 369     return rc;
 370
 371   rc = shishi_random_to_key (handle, type, buf, len, *key);
 372   if (rc != SHISHI_OK)
 373     return rc;
 374
 375   return SHISHI_OK;
 376 }
 377
 378 /**
 379  * shishi_key_from_random
 380  * @handle: Shishi library handle create by shishi_init().
 381  * @type: type of key.
 382  * @random: random data.
 383  * @randomlen: length of random data.
 384  *
 385  * Create a new Key information structure, and set the key type and
 386  * key value using shishi_random_to_key().  KEY contains a newly
 387  * allocated structure only if this function is successful.
 388  *
 389  * Return value: Returns SHISHI_MALLOC_ERROR on memory allocation
 390  *               errors, and SHISHI_OK on success.
 391  **/
 392 int
 393 shishi_key_from_random (Shishi * handle,
 394                         int32_t type,
 395                         char *random, size_t randomlen, Shishi_key ** key)
 396 {
 397   int rc;
 398
 399   rc = shishi_key (handle, key);
 400   if (rc != SHISHI_OK)
 401     return rc;
 402
 403   rc = shishi_random_to_key (handle, type, random, randomlen, *key);
 404
 405   return rc;
 406 }
 407
 408 /**
 409  * shishi_key_from_string
 410  * @handle: Shishi library handle create by shishi_init().
 411  * @type: type of key.
 412  * @password: input array containing password.
 413  * @passwordlen: length of input array containing password.
 414  * @salt: input array containing salt.
 415  * @saltlen: length of input array containing salt.
 416  * @parameter: input array with opaque encryption type specific information.
 417  *
 418  * Create a new Key information structure, and set the key type and
 419  * key value using shishi_string_to_key().  KEY contains a newly
 420  * allocated structure only if this function is successful.
 421  *
 422  * Return value: Returns SHISHI_MALLOC_ERROR on memory allocation
 423  *               errors, and SHISHI_OK on success.
 424  **/
 425 int
 426 shishi_key_from_string (Shishi * handle,
 427                         int32_t type,
 428                         const char *password, size_t passwordlen,
 429                         const char *salt, size_t saltlen,
 430                         const char *parameter, Shishi_key ** key)
 431 {
 432   int rc;
 433
 434   rc = shishi_key (handle, key);
 435   if (rc != SHISHI_OK)
 436     return rc;
 437
 438   rc = shishi_string_to_key (handle, type, password, passwordlen,
 439                              salt, saltlen, parameter, *key);
 440   if (rc != SHISHI_OK)
 441     return rc;
 442
 443   return SHISHI_OK;
 444 }