lib/principal.c

   1 /* principal.c --- Get and set default principal.
   2  * Copyright (C) 2002, 2003, 2004, 2006, 2007  Simon Josefsson
   3  *
   4  * This file is part of Shishi.
   5  *
   6  * Shishi is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Shishi is distributed in the hope that it will be useful, but
  12  * 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, see http://www.gnu.org/licenses or write
  18  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  19  * Floor, Boston, MA 02110-1301, USA
  20  *
  21  */
  22
  23 #include "internal.h"
  24
  25 /**
  26  * shishi_principal_default_guess:
  27  *
  28  * Guesses the principal name for the user, looking at environment
  29  * variables SHISHI_USER and USER, or if that fails, returns the
  30  * string "user".
  31  *
  32  * Return value: Returns guessed default principal for user as a
  33  * string that has to be deallocated with free() by the caller.
  34  **/
  35 char *
  36 shishi_principal_default_guess (void)
  37 {
  38   char *envuser;
  39
  40   envuser = getenv ("SHISHI_USER");
  41   if (!envuser)
  42     envuser = getenv ("USER");
  43   if (!envuser)
  44     envuser = "user";
  45
  46   return xstrdup (envuser);
  47 }
  48
  49
  50 /**
  51  * shishi_principal_default:
  52  * @handle: Shishi library handle create by shishi_init().
  53  *
  54  * The default principal name is the name in the environment variable
  55  * USER, but can be overridden by specifying the environment variable
  56  * SHISHI_USER.
  57  *
  58  * Return value: Returns the default principal name used in the
  59  * library.  (Not a copy of it, so don't modify or deallocate it.)
  60  **/
  61 const char *
  62 shishi_principal_default (Shishi * handle)
  63 {
  64   if (!handle->default_principal)
  65     {
  66       char *p;
  67       p = shishi_principal_default_guess ();
  68       shishi_principal_default_set (handle, p);
  69       free (p);
  70     }
  71
  72   return handle->default_principal;
  73 }
  74
  75 /**
  76  * shishi_principal_default_set:
  77  * @handle: Shishi library handle create by shishi_init().
  78  * @principal: string with new default principal name, or NULL to
  79  * reset to default.
  80  *
  81  * Set the default realm used in the library.  The string is copied
  82  * into the library, so you can dispose of the variable immediately
  83  * after calling this function.
  84  **/
  85 void
  86 shishi_principal_default_set (Shishi * handle, const char *principal)
  87 {
  88   if (handle->default_principal)
  89     free (handle->default_principal);
  90   if (principal)
  91     handle->default_principal = xstrdup (principal);
  92   else
  93     handle->default_principal = NULL;
  94 }
  95
  96 /**
  97  * shishi_parse_name:
  98  * @handle: Shishi library handle create by shishi_init().
  99  * @name: Input principal name string, e.g. imap/mail.gnu.org@GNU.ORG.
 100  * @principal: newly allocated output string with principal name.
 101  * @realm: newly allocated output string with realm name.
 102  *
 103  * Split up principal name (e.g., "simon@JOSEFSSON.ORG") into two
 104  * newly allocated strings, the principal ("simon") and realm
 105  * ("JOSEFSSON.ORG").  If there is no realm part in NAME, REALM is set
 106  * to NULL.
 107  *
 108  * Return value: Returns SHISHI_INVALID_PRINCIPAL_NAME if NAME is NULL
 109  *   or ends with the escape character "\", or SHISHI_OK iff
 110  *   successful
 111  **/
 112 int
 113 shishi_parse_name (Shishi * handle, const char *name,
 114                    char **principal, char **realm)
 115 {
 116   const char *p = name;
 117   const char *q;
 118   int escaped = 0;
 119
 120   if (!name)
 121     return SHISHI_INVALID_PRINCIPAL_NAME;
 122
 123   while (*p && (*p != '@' || escaped))
 124     if (escaped)
 125       escaped = 0;
 126     else if (*p++ == '\\')
 127       escaped = 1;
 128
 129   if (escaped)
 130     return SHISHI_INVALID_PRINCIPAL_NAME;
 131
 132   if (principal)
 133     {
 134       *principal = xstrndup (name, p - name + 1);
 135       (*principal)[p - name] = '\0';
 136     }
 137
 138   if (*p)
 139     {
 140       q = ++p;
 141
 142       while (*q)
 143         if (escaped)
 144           escaped = 0;
 145         else if (*q++ == '\\')
 146           escaped = 1;
 147
 148       if (escaped)
 149         return SHISHI_INVALID_PRINCIPAL_NAME;
 150
 151       if (realm)
 152         *realm = xstrdup (p);
 153     }
 154   else if (realm)
 155     *realm = NULL;
 156
 157   return SHISHI_OK;
 158 }
 159
 160 /**
 161  * shishi_principal_name:
 162  * @handle: Shishi library handle create by shishi_init().
 163  * @namenode: ASN.1 structure with principal in @namefield.
 164  * @namefield: name of field in @namenode containing principal name.
 165  * @out: pointer to newly allocated zero terminated string containing
 166  *   principal name.  May be %NULL (to only populate @outlen).
 167  * @outlen: pointer to length of @out on output, excluding terminating
 168  *   zero.  May be %NULL (to only populate @out).
 169  *
 170  * Represent principal name in ASN.1 structure as zero-terminated
 171  * string.  The string is allocate by this function, and it is the
 172  * responsibility of the caller to deallocate it.  Note that the
 173  * output length @outlen does not include the terminating zero.
 174  *
 175  * Return value: Returns SHISHI_OK iff successful.
 176  **/
 177 int
 178 shishi_principal_name (Shishi * handle,
 179                        Shishi_asn1 namenode,
 180                        const char *namefield, char **out, size_t * outlen)
 181 {
 182   char *format;
 183   size_t i, j, n;
 184   char *name = NULL;
 185   size_t namelen = 0;
 186   int res;
 187
 188   asprintf (&format, "%s.name-string", namefield);
 189   res = shishi_asn1_number_of_elements (handle, namenode, format, &n);
 190   free (format);
 191   if (res != SHISHI_OK)
 192     return res;
 193
 194   for (i = 1; i <= n; i++)
 195     {
 196       char *tmp;
 197       size_t tmplen;
 198       size_t safetmplen;
 199
 200       asprintf (&format, "%s.name-string.?%d", namefield, i);
 201       res = shishi_asn1_read (handle, namenode, format, &tmp, &tmplen);
 202       free (format);
 203       if (res != SHISHI_OK)
 204         return res;
 205
 206       safetmplen = tmplen;
 207       for (j = 0; j < tmplen; j++)
 208         if (tmp[j] == '@' || tmp[j] == '/' || tmp[j] == '\\')
 209           safetmplen++;
 210       if (i < n)
 211         safetmplen++;
 212
 213       name = xrealloc (name, namelen + safetmplen);
 214
 215       for (j = 0; j < tmplen; j++)
 216         {
 217           if (tmp[j] == '@' || tmp[j] == '/' || tmp[j] == '\\')
 218             name[namelen++] = '\\';
 219           name[namelen++] = tmp[j];
 220         }
 221
 222       if (i < n)
 223         name[namelen++] = '/';
 224
 225       free (tmp);
 226     }
 227
 228   name = xrealloc (name, namelen + 1);
 229   name[namelen] = '\0';
 230
 231   if (out)
 232     *out = name;
 233   else
 234     free (name);
 235   if (outlen)
 236     *outlen = namelen;
 237
 238   return SHISHI_OK;
 239 }
 240
 241 /**
 242  * shishi_principal_name_realm:
 243  * @handle: Shishi library handle create by shishi_init().
 244  * @namenode: ASN.1 structure with principal name in @namefield.
 245  * @namefield: name of field in @namenode containing principal name.
 246  * @realmnode: ASN.1 structure with principal realm in @realmfield.
 247  * @realmfield: name of field in @realmnode containing principal realm.
 248  * @out: pointer to newly allocated zero terminated string containing
 249  *   principal name.  May be %NULL (to only populate @outlen).
 250  * @outlen: pointer to length of @out on output, excluding terminating
 251  *   zero.  May be %NULL (to only populate @out).
 252  *
 253  * Represent principal name and realm in ASN.1 structure as
 254  * zero-terminated string.  The string is allocate by this function,
 255  * and it is the responsibility of the caller to deallocate it.  Note
 256  * that the output length @outlen does not include the terminating
 257  * zero.
 258  *
 259  * Return value: Returns SHISHI_OK iff successful.
 260  **/
 261 int
 262 shishi_principal_name_realm (Shishi * handle,
 263                              Shishi_asn1 namenode,
 264                              const char *namefield,
 265                              Shishi_asn1 realmnode,
 266                              const char *realmfield,
 267                              char **out, size_t * outlen)
 268 {
 269   char *tmp;
 270   size_t tmplen;
 271   int rc;
 272
 273   rc = shishi_principal_name (handle, namenode, namefield, &tmp, &tmplen);
 274   if (rc != SHISHI_OK)
 275     return rc;
 276
 277   if (realmnode == NULL && realmfield)
 278     {
 279       size_t realmfieldlen = strlen (realmfield);
 280
 281       tmp = xrealloc (tmp, tmplen + 1 + realmfieldlen + 1);
 282
 283       tmp[tmplen] = '@';
 284       memcpy (tmp + tmplen + 1, realmfield, realmfieldlen);
 285
 286       tmplen += 1 + realmfieldlen;
 287
 288       tmp[tmplen] = '\0';
 289     }
 290   else if (realmnode != NULL)
 291     {
 292       char *realm;
 293       size_t realmlen;
 294
 295       rc = shishi_asn1_read (handle, realmnode, realmfield,
 296                              &realm, &realmlen);
 297       if (rc != SHISHI_OK)
 298         {
 299           free (tmp);
 300           return rc;
 301         }
 302
 303       tmp = xrealloc (tmp, tmplen + 1 + realmlen + 1);
 304
 305       tmp[tmplen] = '@';
 306       memcpy (tmp + tmplen + 1, realm, realmlen);
 307
 308       tmplen += 1 + realmlen;
 309
 310       tmp[tmplen] = '\0';
 311
 312       free (realm);
 313     }
 314
 315   *out = tmp;
 316   if (outlen)
 317     *outlen = tmplen;
 318
 319   return SHISHI_OK;
 320 }
 321
 322 /**
 323  * shishi_principal_name_set:
 324  * @handle: shishi handle as allocated by shishi_init().
 325  * @namenode: ASN.1 structure with principal in @namefield.
 326  * @namefield: name of field in namenode containing principal name.
 327  * @name_type: type of principial, see Shishi_name_type, usually
 328  *             SHISHI_NT_UNKNOWN.
 329  * @name: zero-terminated input array with principal name.
 330  *
 331  * Set the given principal name field to given name.
 332  *
 333  * Return value: Returns SHISHI_OK iff successful.
 334  **/
 335 int
 336 shishi_principal_name_set (Shishi * handle,
 337                            Shishi_asn1 namenode,
 338                            const char *namefield,
 339                            Shishi_name_type name_type, const char *name[])
 340 {
 341   int res;
 342   char *asn1name;
 343   int i;
 344
 345   asprintf (&asn1name, "%s.name-type", namefield);
 346   res = shishi_asn1_write_int32 (handle, namenode, asn1name, name_type);
 347   free (asn1name);
 348   if (res != SHISHI_OK)
 349     return res;
 350
 351   asprintf (&asn1name, "%s.name-string", namefield);
 352   res = shishi_asn1_write (handle, namenode, asn1name, NULL, 0);
 353   free (asn1name);
 354   if (res != SHISHI_OK)
 355     return res;
 356
 357   i = 1;
 358   while (name[i - 1])
 359     {
 360       asprintf (&asn1name, "%s.name-string", namefield);
 361       res = shishi_asn1_write (handle, namenode, asn1name, "NEW", 1);
 362       free (asn1name);
 363       if (res != SHISHI_OK)
 364         return res;
 365
 366       asprintf (&asn1name, "%s.name-string.?%d", namefield, i);
 367       res = shishi_asn1_write (handle, namenode, asn1name, name[i - 1], 0);
 368       free (asn1name);
 369       if (res != SHISHI_OK)
 370         return res;
 371
 372       i++;
 373     }
 374
 375   return SHISHI_OK;
 376 }
 377
 378 /**
 379  * shishi_principal_set:
 380  * @handle: shishi handle as allocated by shishi_init().
 381  * @namenode: ASN.1 structure with principal in @namefield.
 382  * @namefield: name of field in namenode containing principal name.
 383  * @name: zero-terminated string with principal name on RFC 1964 form.
 384  *
 385  * Set principal name field in ASN.1 structure to given name.
 386  *
 387  * Return value: Returns SHISHI_OK iff successful.
 388  **/
 389 int
 390 shishi_principal_set (Shishi * handle,
 391                       Shishi_asn1 namenode,
 392                       const char *namefield, const char *name)
 393 {
 394   char *tmpname;
 395   const char **namebuf;
 396   char *tokptr;
 397   int res;
 398   int i;
 399
 400   tmpname = xstrdup (name);
 401   namebuf = xmalloc (sizeof (*namebuf));
 402
 403   for (i = 0;
 404        (namebuf[i] = strtok_r (i == 0 ? tmpname : NULL, "/", &tokptr)); i++)
 405     {
 406       namebuf = xrealloc (namebuf, (i + 2) * sizeof (*namebuf));
 407     }
 408
 409   res = shishi_principal_name_set (handle, namenode, namefield,
 410                                    SHISHI_NT_UNKNOWN, namebuf);
 411   free (namebuf);
 412   free (tmpname);
 413   if (res != SHISHI_OK)
 414     {
 415       shishi_error_printf (handle, _("Could not set principal name: %s\n"),
 416                            shishi_strerror (res));
 417       return res;
 418     }
 419
 420   return SHISHI_OK;
 421 }
 422
 423 /**
 424  * shishi_derive_default_salt:
 425  * @handle: shishi handle as allocated by shishi_init().
 426  * @name: principal name of user.
 427  * @salt: output variable with newly allocated salt string.
 428  *
 429  * Derive the default salt from a principal.  The default salt is the
 430  * concatenation of the decoded realm and principal.
 431  *
 432  * Return value: Return SHISHI_OK if successful.
 433  **/
 434 int
 435 shishi_derive_default_salt (Shishi * handle,
 436                             const char *name,
 437                             char **salt)
 438 {
 439   char *principal;
 440   char *realm;
 441   int rc;
 442
 443   rc = shishi_parse_name (handle, name, &principal, &realm);
 444   if (rc != SHISHI_OK)
 445     return rc;
 446
 447   if (!principal || !realm)
 448     {
 449       if (realm)
 450         free (realm);
 451       if (principal)
 452         free (principal);
 453       return SHISHI_INVALID_PRINCIPAL_NAME;
 454     }
 455
 456   *salt = xasprintf ("%s%s", realm, principal);
 457
 458   free (realm);
 459   free (principal);
 460
 461   return SHISHI_OK;
 462 }
 463
 464 /**
 465  * shishi_server_for_local_service:
 466  * @handle: shishi handle as allocated by shishi_init().
 467  * @service: zero terminated string with name of service, e.g., "host".
 468  *
 469  * Construct a service principal (e.g., "imap/yxa.extuno.com") based
 470  * on supplied service name (i.e., "imap") and the system hostname as
 471  * returned by hostname() (i.e., "yxa.extundo.com").  The string must
 472  * be deallocated by the caller.
 473  *
 474  * Return value: Return newly allocated service name string.
 475  **/
 476 char *
 477 shishi_server_for_local_service (Shishi * handle, const char *service)
 478 {
 479   char *hostname;
 480   char *server;
 481
 482   hostname = xgethostname ();
 483
 484   asprintf (&server, "%s/%s", service, hostname);
 485
 486   free (hostname);
 487
 488   return server;
 489 }