kadmin/server.c

   1 /*
   2  * Copyright (c) 1997 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 "kadm5_locl.h"
  40
  41 RCSID("$Id$");
  42
  43 kadm5_ret_t
  44 kadmind_dispatch(void *kadm_handle, krb5_storage *sp)
  45 {
  46     int32_t cmd;
  47     kadm5_ret_t ret;
  48     kadm5_server_context *context = kadm_handle;
  49     char client[128], name[128], name2[128];
  50     char *op = "";
  51     krb5_principal princ, princ2;
  52     kadm5_principal_ent_rec ent;
  53     int32_t mask;
  54     char *password;
  55     krb5_keyblock *new_keys;
  56     int n_keys;
  57
  58     krb5_unparse_name_fixed(context->context, context->caller,
  59                             client, sizeof(client));
  60
  61     krb5_ret_int32(sp, &cmd);
  62     switch(cmd){
  63     case kadm_get:{
  64         op = "GET";
  65         ret = krb5_ret_principal(sp, &princ);
  66         if(ret)
  67             goto fail;
  68         ret = krb5_ret_int32(sp, &mask);
  69         if(ret){
  70             krb5_free_principal(context->context, princ);
  71             goto fail;
  72         }
  73         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
  74         krb5_warnx(context->context, "%s: %s %s", client, op, name);
  75         ret = _kadm5_acl_check_permission(context, KADM5_ACL_GET);
  76         if(ret){
  77             krb5_free_principal(context->context, princ);
  78             goto fail;
  79         }
  80         ret = kadm5_get_principal(kadm_handle, princ, &ent, mask);
  81         sp->seek(sp, 0, SEEK_SET);
  82         krb5_store_int32(sp, ret);
  83         if(ret == 0){
  84             kadm5_store_principal_ent(sp, &ent);
  85             kadm5_free_principal_ent(kadm_handle, &ent);
  86         }
  87         krb5_free_principal(context->context, princ);
  88         break;
  89     }
  90     case kadm_delete:{
  91         op = "DELETE";
  92         ret = krb5_ret_principal(sp, &princ);
  93         if(ret)
  94             goto fail;
  95         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
  96         krb5_warnx(context->context, "%s: %s %s", client, op, name);
  97         ret = _kadm5_acl_check_permission(context, KADM5_ACL_DELETE);
  98         if(ret){
  99             krb5_free_principal(context->context, princ);
 100             goto fail;
 101         }
 102         ret = kadm5_delete_principal(kadm_handle, princ);
 103         krb5_free_principal(context->context, princ);
 104         sp->seek(sp, 0, SEEK_SET);
 105         krb5_store_int32(sp, ret);
 106         break;
 107     }
 108     case kadm_create:{
 109         op = "CREATE";
 110         ret = kadm5_ret_principal_ent(sp, &ent);
 111         if(ret)
 112             goto fail;
 113         ret = krb5_ret_int32(sp, &mask);
 114         if(ret){
 115             kadm5_free_principal_ent(context->context, &ent);
 116             goto fail;
 117         }
 118         ret = krb5_ret_string(sp, &password);
 119         if(ret){
 120             kadm5_free_principal_ent(context->context, &ent);
 121             goto fail;
 122         }
 123         krb5_unparse_name_fixed(context->context, ent.principal,
 124                                 name, sizeof(name));
 125         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 126         ret = _kadm5_acl_check_permission(context, KADM5_ACL_CREATE);
 127         if(ret){
 128             kadm5_free_principal_ent(context->context, &ent);
 129             memset(password, 0, strlen(password));
 130             free(password);
 131             goto fail;
 132         }
 133         ret = kadm5_create_principal(kadm_handle, &ent,
 134                                      mask, password);
 135         kadm5_free_principal_ent(kadm_handle, &ent);
 136         memset(password, 0, strlen(password));
 137         free(password);
 138         sp->seek(sp, 0, SEEK_SET);
 139         krb5_store_int32(sp, ret);
 140         break;
 141     }
 142     case kadm_modify:{
 143         op = "MODIFY";
 144         ret = kadm5_ret_principal_ent(sp, &ent);
 145         if(ret)
 146             goto fail;
 147         ret = krb5_ret_int32(sp, &mask);
 148         if(ret){
 149             kadm5_free_principal_ent(context, &ent);
 150             goto fail;
 151         }
 152         krb5_unparse_name_fixed(context->context, ent.principal,
 153                                 name, sizeof(name));
 154         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 155         ret = _kadm5_acl_check_permission(context, KADM5_ACL_MODIFY);
 156         if(ret){
 157             kadm5_free_principal_ent(context, &ent);
 158             goto fail;
 159         }
 160         ret = kadm5_modify_principal(kadm_handle, &ent, mask);
 161         kadm5_free_principal_ent(kadm_handle, &ent);
 162         sp->seek(sp, 0, SEEK_SET);
 163         krb5_store_int32(sp, ret);
 164         break;
 165     }
 166     case kadm_rename:{
 167         op = "RENAME";
 168         ret = krb5_ret_principal(sp, &princ);
 169         if(ret)
 170             goto fail;
 171         ret = krb5_ret_principal(sp, &princ2);
 172         if(ret){
 173             krb5_free_principal(context->context, princ);
 174             goto fail;
 175         }
 176         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
 177         krb5_unparse_name_fixed(context->context, princ2, name2, sizeof(name2));
 178         krb5_warnx(context->context, "%s: %s %s -> %s",
 179                    client, op, name, name2);
 180         ret = _kadm5_acl_check_permission(context,
 181                                          KADM5_ACL_CREATE|KADM5_ACL_DELETE);
 182         if(ret){
 183             krb5_free_principal(context->context, princ);
 184             goto fail;
 185         }
 186         ret = kadm5_rename_principal(kadm_handle, princ, princ2);
 187         krb5_free_principal(context->context, princ);
 188         krb5_free_principal(context->context, princ2);
 189         sp->seek(sp, 0, SEEK_SET);
 190         krb5_store_int32(sp, ret);
 191         break;
 192     }
 193     case kadm_chpass:{
 194         op = "CHPASS";
 195         ret = krb5_ret_principal(sp, &princ);
 196         if(ret)
 197             goto fail;
 198         ret = krb5_ret_string(sp, &password);
 199         if(ret){
 200             krb5_free_principal(context->context, princ);
 201             goto fail;
 202         }
 203         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
 204         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 205         ret = _kadm5_acl_check_permission(context, KADM5_ACL_CHPASS);
 206         if(ret){
 207             krb5_free_principal(context->context, princ);
 208             goto fail;
 209         }
 210         ret = kadm5_chpass_principal(kadm_handle, princ, password);
 211         krb5_free_principal(context->context, princ);
 212         memset(password, 0, strlen(password));
 213         free(password);
 214         sp->seek(sp, 0, SEEK_SET);
 215         krb5_store_int32(sp, ret);
 216         break;
 217     }
 218     case kadm_randkey:{
 219         op = "RANDKEY";
 220         ret = krb5_ret_principal(sp, &princ);
 221         if(ret)
 222             goto fail;
 223         krb5_unparse_name_fixed(context->context, princ, name, sizeof(name));
 224         krb5_warnx(context->context, "%s: %s %s", client, op, name);
 225         ret = _kadm5_acl_check_permission(context, KADM5_ACL_CHPASS);
 226         if(ret){
 227             krb5_free_principal(context->context, princ);
 228             goto fail;
 229         }
 230         ret = kadm5_randkey_principal(kadm_handle, princ,
 231                                       &new_keys, &n_keys);
 232         krb5_free_principal(context->context, princ);
 233         sp->seek(sp, 0, SEEK_SET);
 234         krb5_store_int32(sp, ret);
 235         if(ret == 0){
 236             int i;
 237             krb5_store_int32(sp, n_keys);
 238             for(i = 0; i < n_keys; i++){
 239                 krb5_store_keyblock(sp, new_keys[i]);
 240                 krb5_free_keyblock(context->context, &new_keys[i]);
 241             }
 242         }
 243         break;
 244     }
 245     default:
 246         krb5_warnx(context->context, "%s: UNKNOWN OP %d", client, cmd);
 247         sp->seek(sp, 0, SEEK_SET);
 248         krb5_store_int32(sp, KADM5_FAILURE);
 249         break;
 250     }
 251     return 0;
 252 fail:
 253     krb5_warnx(context->context, "%s", op);
 254     sp->seek(sp, 0, SEEK_SET);
 255     krb5_store_int32(sp, ret);
 256     return 0;
 257 }