crypto/dist/heimdal/kadmin/server.c

   1 /*
   2  * Copyright (c) 1997 - 2005 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. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "kadmin_locl.h"
  35 #include <krb5-private.h>
  36
  37 __RCSID("$Heimdal: server.c 17611 2006-06-02 22:10:21Z lha $"
  38         "$NetBSD$");
  39
  40 static kadm5_ret_t
  41 kadmind_dispatch(void *kadm_handle, krb5_boolean initial,
  42                  krb5_data *in, krb5_data *out)
  43 {
  44     kadm5_ret_t ret;
  45     int32_t cmd, mask, tmp;
  46     kadm5_server_context *context = kadm_handle;
  47     char client[128], name[128], name2[128];
  48     char *op = "";
  49     krb5_principal princ, princ2;
  50     kadm5_principal_ent_rec ent;
  51     char *password, *expression;
  52     krb5_keyblock *new_keys;
  53     int n_keys;
  54     char **princs;
  55     int n_princs;
  56     krb5_storage *sp;
  57
  58     krb5_unparse_name_fixed(context->context, context->caller,
  59                             client, sizeof(client));
  60
  61     sp = krb5_storage_from_data(in);
  62
  63     krb5_ret_int32(sp, &cmd);
  64     switch(cmd){
  65     case kadm_get:{
  66         op = "GET";
  67         ret = krb5_ret_principal(sp, &princ);
  68         if(ret)
  69             goto fail;
  70         ret = krb5_ret_int32(sp, &mask);
  71         if(ret){
  72             krb5_free_principal(context->context, princ);
  73             goto fail;
  74         }
  75         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
  76         krb5_warnx(context->context, "%s: %s %s", client, op, name);
  77         ret = _kadm5_acl_check_permission(context, KADM5_PRIV_GET, princ);
  78         if(ret){
  79             krb5_free_principal(context->context, princ);
  80             goto fail;
  81         }
  82         ret = kadm5_get_principal(kadm_handle, princ, &ent, mask);
  83         krb5_storage_free(sp);
  84         sp = krb5_storage_emem();
  85         krb5_store_int32(sp, ret);
  86         if(ret == 0){
  87             kadm5_store_principal_ent(sp, &ent);
  88             kadm5_free_principal_ent(kadm_handle, &ent);
  89         }
  90         krb5_free_principal(context->context, princ);
  91         break;
  92     }
  93     case kadm_delete:{
  94         op = "DELETE";
  95         ret = krb5_ret_principal(sp, &princ);
  96         if(ret)
  97             goto fail;
  98         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
  99         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 100         ret = _kadm5_acl_check_permission(context, KADM5_PRIV_DELETE, princ);
 101         if(ret){
 102             krb5_free_principal(context->context, princ);
 103             goto fail;
 104         }
 105         ret = kadm5_delete_principal(kadm_handle, princ);
 106         krb5_free_principal(context->context, princ);
 107         krb5_storage_free(sp);
 108         sp = krb5_storage_emem();
 109         krb5_store_int32(sp, ret);
 110         break;
 111     }
 112     case kadm_create:{
 113         op = "CREATE";
 114         ret = kadm5_ret_principal_ent(sp, &ent);
 115         if(ret)
 116             goto fail;
 117         ret = krb5_ret_int32(sp, &mask);
 118         if(ret){
 119             kadm5_free_principal_ent(context->context, &ent);
 120             goto fail;
 121         }
 122         ret = krb5_ret_string(sp, &password);
 123         if(ret){
 124             kadm5_free_principal_ent(context->context, &ent);
 125             goto fail;
 126         }
 127         krb5_unparse_name_fixed(context->context, ent.principal,
 128                                 name, sizeof(name));
 129         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 130         ret = _kadm5_acl_check_permission(context, KADM5_PRIV_ADD,
 131                                           ent.principal);
 132         if(ret){
 133             kadm5_free_principal_ent(context->context, &ent);
 134             memset(password, 0, strlen(password));
 135             free(password);
 136             goto fail;
 137         }
 138         ret = kadm5_create_principal(kadm_handle, &ent,
 139                                      mask, password);
 140         kadm5_free_principal_ent(kadm_handle, &ent);
 141         memset(password, 0, strlen(password));
 142         free(password);
 143         krb5_storage_free(sp);
 144         sp = krb5_storage_emem();
 145         krb5_store_int32(sp, ret);
 146         break;
 147     }
 148     case kadm_modify:{
 149         op = "MODIFY";
 150         ret = kadm5_ret_principal_ent(sp, &ent);
 151         if(ret)
 152             goto fail;
 153         ret = krb5_ret_int32(sp, &mask);
 154         if(ret){
 155             kadm5_free_principal_ent(context, &ent);
 156             goto fail;
 157         }
 158         krb5_unparse_name_fixed(context->context, ent.principal,
 159                                 name, sizeof(name));
 160         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 161         ret = _kadm5_acl_check_permission(context, KADM5_PRIV_MODIFY,
 162                                           ent.principal);
 163         if(ret){
 164             kadm5_free_principal_ent(context, &ent);
 165             goto fail;
 166         }
 167         ret = kadm5_modify_principal(kadm_handle, &ent, mask);
 168         kadm5_free_principal_ent(kadm_handle, &ent);
 169         krb5_storage_free(sp);
 170         sp = krb5_storage_emem();
 171         krb5_store_int32(sp, ret);
 172         break;
 173     }
 174     case kadm_rename:{
 175         op = "RENAME";
 176         ret = krb5_ret_principal(sp, &princ);
 177         if(ret)
 178             goto fail;
 179         ret = krb5_ret_principal(sp, &princ2);
 180         if(ret){
 181             krb5_free_principal(context->context, princ);
 182             goto fail;
 183         }
 184         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
 185         krb5_unparse_name_fixed(context->context, princ2, name2, sizeof(name2));
 186         krb5_warnx(context->context, "%s: %s %s -> %s",
 187                    client, op, name, name2);
 188         ret = _kadm5_acl_check_permission(context,
 189                                           KADM5_PRIV_ADD,
 190                                           princ2)
 191             || _kadm5_acl_check_permission(context,
 192                                            KADM5_PRIV_DELETE,
 193                                            princ);
 194         if(ret){
 195             krb5_free_principal(context->context, princ);
 196             krb5_free_principal(context->context, princ2);
 197             goto fail;
 198         }
 199         ret = kadm5_rename_principal(kadm_handle, princ, princ2);
 200         krb5_free_principal(context->context, princ);
 201         krb5_free_principal(context->context, princ2);
 202         krb5_storage_free(sp);
 203         sp = krb5_storage_emem();
 204         krb5_store_int32(sp, ret);
 205         break;
 206     }
 207     case kadm_chpass:{
 208         op = "CHPASS";
 209         ret = krb5_ret_principal(sp, &princ);
 210         if(ret)
 211             goto fail;
 212         ret = krb5_ret_string(sp, &password);
 213         if(ret){
 214             krb5_free_principal(context->context, princ);
 215             goto fail;
 216         }
 217         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
 218         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 219
 220         /*
 221          * The change is allowed if at least one of:
 222
 223          * a) it's for the principal him/herself and this was an
 224          *    initial ticket, but then, check with the password quality
 225          *    function.
 226          * b) the user is on the CPW ACL.
 227          */
 228
 229         if (initial
 230             && krb5_principal_compare (context->context, context->caller,
 231                                        princ))
 232         {
 233             krb5_data pwd_data;
 234             const char *pwd_reason;
 235
 236             pwd_data.data = password;
 237             pwd_data.length = strlen(password);
 238
 239             pwd_reason = kadm5_check_password_quality (context->context,
 240                                                        princ, &pwd_data);
 241             if (pwd_reason != NULL)
 242                 ret = KADM5_PASS_Q_DICT;
 243             else
 244                 ret = 0;
 245         } else
 246             ret = _kadm5_acl_check_permission(context, KADM5_PRIV_CPW, princ);
 247
 248         if(ret) {
 249             krb5_free_principal(context->context, princ);
 250             memset(password, 0, strlen(password));
 251             free(password);
 252             goto fail;
 253         }
 254         ret = kadm5_chpass_principal(kadm_handle, princ, password);
 255         krb5_free_principal(context->context, princ);
 256         memset(password, 0, strlen(password));
 257         free(password);
 258         krb5_storage_free(sp);
 259         sp = krb5_storage_emem();
 260         krb5_store_int32(sp, ret);
 261         break;
 262     }
 263     case kadm_chpass_with_key:{
 264         int i;
 265         krb5_key_data *key_data;
 266         int n_key_data;
 267
 268         op = "CHPASS_WITH_KEY";
 269         ret = krb5_ret_principal(sp, &princ);
 270         if(ret)
 271             goto fail;
 272         ret = krb5_ret_int32(sp, &n_key_data);
 273         if (ret) {
 274             krb5_free_principal(context->context, princ);
 275             goto fail;
 276         }
 277         /* n_key_data will be squeezed into an int16_t below. */
 278         if (n_key_data < 0 || n_key_data >= 1 << 16 ||
 279             n_key_data > UINT_MAX/sizeof(*key_data)) {
 280             ret = ERANGE;
 281             krb5_free_principal(context->context, princ);
 282             goto fail;
 283         }
 284
 285         key_data = malloc (n_key_data * sizeof(*key_data));
 286         if (key_data == NULL) {
 287             ret = ENOMEM;
 288             krb5_free_principal(context->context, princ);
 289             goto fail;
 290         }
 291
 292         for (i = 0; i < n_key_data; ++i) {
 293             ret = kadm5_ret_key_data (sp, &key_data[i]);
 294             if (ret) {
 295                 int16_t dummy = i;
 296
 297                 kadm5_free_key_data (context, &dummy, key_data);
 298                 free (key_data);
 299                 krb5_free_principal(context->context, princ);
 300                 goto fail;
 301             }
 302         }
 303
 304         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
 305         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 306
 307         /*
 308          * The change is only allowed if the user is on the CPW ACL,
 309          * this it to force password quality check on the user.
 310          */
 311
 312         ret = _kadm5_acl_check_permission(context, KADM5_PRIV_CPW, princ);
 313         if(ret) {
 314             int16_t dummy = n_key_data;
 315
 316             kadm5_free_key_data (context, &dummy, key_data);
 317             free (key_data);
 318             krb5_free_principal(context->context, princ);
 319             goto fail;
 320         }
 321         ret = kadm5_chpass_principal_with_key(kadm_handle, princ,
 322                                               n_key_data, key_data);
 323         {
 324             int16_t dummy = n_key_data;
 325             kadm5_free_key_data (context, &dummy, key_data);
 326         }
 327         free (key_data);
 328         krb5_free_principal(context->context, princ);
 329         krb5_storage_free(sp);
 330         sp = krb5_storage_emem();
 331         krb5_store_int32(sp, ret);
 332         break;
 333     }
 334     case kadm_randkey:{
 335         op = "RANDKEY";
 336         ret = krb5_ret_principal(sp, &princ);
 337         if(ret)
 338             goto fail;
 339         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
 340         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 341         /*
 342          * The change is allowed if at least one of:
 343          * a) it's for the principal him/herself and this was an initial ticket
 344          * b) the user is on the CPW ACL.
 345          */
 346
 347         if (initial
 348             && krb5_principal_compare (context->context, context->caller,
 349                                        princ))
 350             ret = 0;
 351         else
 352             ret = _kadm5_acl_check_permission(context, KADM5_PRIV_CPW, princ);
 353
 354         if(ret) {
 355             krb5_free_principal(context->context, princ);
 356             goto fail;
 357         }
 358         ret = kadm5_randkey_principal(kadm_handle, princ,
 359                                       &new_keys, &n_keys);
 360         krb5_free_principal(context->context, princ);
 361         krb5_storage_free(sp);
 362         sp = krb5_storage_emem();
 363         krb5_store_int32(sp, ret);
 364         if(ret == 0){
 365             int i;
 366             krb5_store_int32(sp, n_keys);
 367             for(i = 0; i < n_keys; i++){
 368                 krb5_store_keyblock(sp, new_keys[i]);
 369                 krb5_free_keyblock_contents(context->context, &new_keys[i]);
 370             }
 371         }
 372         break;
 373     }
 374     case kadm_get_privs:{
 375         uint32_t privs;
 376         ret = kadm5_get_privs(kadm_handle, &privs);
 377         krb5_storage_free(sp);
 378         sp = krb5_storage_emem();
 379         krb5_store_int32(sp, ret);
 380         if(ret == 0)
 381             krb5_store_uint32(sp, privs);
 382         break;
 383     }
 384     case kadm_get_princs:{
 385         op = "LIST";
 386         ret = krb5_ret_int32(sp, &tmp);
 387         if(ret)
 388             goto fail;
 389         if(tmp){
 390             ret = krb5_ret_string(sp, &expression);
 391             if(ret)
 392                 goto fail;
 393         }else
 394             expression = NULL;
 395         krb5_warnx(context->context, "%s: %s %s", client, op,
 396                    expression ? expression : "*");
 397         ret = _kadm5_acl_check_permission(context, KADM5_PRIV_LIST, NULL);
 398         if(ret){
 399             free(expression);
 400             goto fail;
 401         }
 402         ret = kadm5_get_principals(kadm_handle, expression, &princs, &n_princs);
 403         free(expression);
 404         krb5_storage_free(sp);
 405         sp = krb5_storage_emem();
 406         krb5_store_int32(sp, ret);
 407         if(ret == 0){
 408             int i;
 409             krb5_store_int32(sp, n_princs);
 410             for(i = 0; i < n_princs; i++)
 411                 krb5_store_string(sp, princs[i]);
 412             kadm5_free_name_list(kadm_handle, princs, &n_princs);
 413         }
 414         break;
 415     }
 416     default:
 417         krb5_warnx(context->context, "%s: UNKNOWN OP %d", client, cmd);
 418         krb5_storage_free(sp);
 419         sp = krb5_storage_emem();
 420         krb5_store_int32(sp, KADM5_FAILURE);
 421         break;
 422     }
 423     krb5_storage_to_data(sp, out);
 424     krb5_storage_free(sp);
 425     return 0;
 426 fail:
 427     krb5_warn(context->context, ret, "%s", op);
 428     krb5_storage_seek(sp, 0, SEEK_SET);
 429     krb5_store_int32(sp, ret);
 430     krb5_storage_to_data(sp, out);
 431     krb5_storage_free(sp);
 432     return 0;
 433 }
 434
 435 static void
 436 v5_loop (krb5_context context,
 437          krb5_auth_context ac,
 438          krb5_boolean initial,
 439          void *kadm_handle,
 440          int fd)
 441 {
 442     krb5_error_code ret;
 443     krb5_data in, out;
 444
 445     for (;;) {
 446         doing_useful_work = 0;
 447         if(term_flag)
 448             exit(0);
 449         ret = krb5_read_priv_message(context, ac, &fd, &in);
 450         if(ret == HEIM_ERR_EOF)
 451             exit(0);
 452         if(ret)
 453             krb5_err(context, 1, ret, "krb5_read_priv_message");
 454         doing_useful_work = 1;
 455         kadmind_dispatch(kadm_handle, initial, &in, &out);
 456         krb5_data_free(&in);
 457         ret = krb5_write_priv_message(context, ac, &fd, &out);
 458         if(ret)
 459             krb5_err(context, 1, ret, "krb5_write_priv_message");
 460     }
 461 }
 462
 463 static krb5_boolean
 464 match_appl_version(const void *data, const char *appl_version)
 465 {
 466     unsigned minor;
 467     if(sscanf(appl_version, "KADM0.%u", &minor) != 1)
 468         return 0;
 469     *(unsigned*)data = minor;
 470     return 1;
 471 }
 472
 473 static void
 474 handle_v5(krb5_context context,
 475           krb5_auth_context ac,
 476           krb5_keytab keytab,
 477           int len,
 478           int fd)
 479 {
 480     krb5_error_code ret;
 481     u_char version[sizeof(KRB5_SENDAUTH_VERSION)];
 482     krb5_ticket *ticket;
 483     char *server_name;
 484     char *client;
 485     void *kadm_handle;
 486     ssize_t n;
 487     krb5_boolean initial;
 488
 489     unsigned kadm_version;
 490     kadm5_config_params realm_params;
 491
 492     if (len != sizeof(KRB5_SENDAUTH_VERSION))
 493         krb5_errx(context, 1, "bad sendauth len %d", len);
 494     n = krb5_net_read(context, &fd, version, len);
 495     if (n < 0)
 496         krb5_err (context, 1, errno, "reading sendauth version");
 497     if (n == 0)
 498         krb5_errx (context, 1, "EOF reading sendauth version");
 499     if(memcmp(version, KRB5_SENDAUTH_VERSION, len) != 0)
 500         krb5_errx(context, 1, "bad sendauth version %.8s", version);
 501
 502     ret = krb5_recvauth_match_version(context, &ac, &fd,
 503                                       match_appl_version, &kadm_version,
 504                                       NULL, KRB5_RECVAUTH_IGNORE_VERSION,
 505                                       keytab, &ticket);
 506     if(ret == KRB5_KT_NOTFOUND)
 507         krb5_errx(context, 1, "krb5_recvauth: key not found");
 508     if(ret)
 509         krb5_err(context, 1, ret, "krb5_recvauth");
 510
 511     ret = krb5_unparse_name (context, ticket->server, &server_name);
 512     if (ret)
 513         krb5_err (context, 1, ret, "krb5_unparse_name");
 514
 515     if (strncmp (server_name, KADM5_ADMIN_SERVICE,
 516                  strlen(KADM5_ADMIN_SERVICE)) != 0)
 517         krb5_errx (context, 1, "ticket for strange principal (%s)",
 518                    server_name);
 519
 520     free (server_name);
 521
 522     memset(&realm_params, 0, sizeof(realm_params));
 523
 524     if(kadm_version == 1) {
 525         krb5_data params;
 526         ret = krb5_read_priv_message(context, ac, &fd, &params);
 527         if(ret)
 528             krb5_err(context, 1, ret, "krb5_read_priv_message");
 529         _kadm5_unmarshal_params(context, &params, &realm_params);
 530     }
 531
 532     initial = ticket->ticket.flags.initial;
 533     ret = krb5_unparse_name(context, ticket->client, &client);
 534     if (ret)
 535         krb5_err (context, 1, ret, "krb5_unparse_name");
 536     krb5_free_ticket (context, ticket);
 537     ret = kadm5_init_with_password_ctx(context,
 538                                        client,
 539                                        NULL,
 540                                        KADM5_ADMIN_SERVICE,
 541                                        &realm_params,
 542                                        0, 0,
 543                                        &kadm_handle);
 544     if(ret)
 545         krb5_err (context, 1, ret, "kadm5_init_with_password_ctx");
 546     v5_loop (context, ac, initial, kadm_handle, fd);
 547 }
 548
 549 krb5_error_code
 550 kadmind_loop(krb5_context context,
 551              krb5_auth_context ac,
 552              krb5_keytab keytab,
 553              int fd)
 554 {
 555     unsigned char tmp[4];
 556     ssize_t n;
 557     unsigned long len;
 558
 559     n = krb5_net_read(context, &fd, tmp, 4);
 560     if(n == 0)
 561         exit(0);
 562     if(n < 0)
 563         krb5_err(context, 1, errno, "read");
 564     _krb5_get_int(tmp, &len, 4);
 565     /* this v4 test could probably also go away */
 566     if(len > 0xffff && (len & 0xffff) == ('K' << 8) + 'A') {
 567         unsigned char v4reply[] = {
 568             0x00, 0x0c,
 569             'K', 'Y', 'O', 'U', 'L', 'O', 'S', 'E',
 570             0x95, 0xb7, 0xa7, 0x08 /* KADM_BAD_VER */
 571         };
 572         krb5_net_write(context, &fd, v4reply, sizeof(v4reply));
 573         krb5_errx(context, 1, "packet appears to be version 4");
 574     } else {
 575         handle_v5(context, ac, keytab, len, fd);
 576     }
 577     return 0;
 578 }