crypto/kerberosIV/lib/krb/verify_user.c

   1 /*
   2  * Copyright (c) 1995 - 2000 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 "krb_locl.h"
  35
  36 RCSID("$Id: verify_user.c,v 1.17.2.2 2000/12/15 14:43:37 assar Exp $");
  37
  38 /*
  39  * Verify user (name.instance@realm) with `password'.
  40  *
  41  * If secure, also verify against local
  42  * service key (`linstance'.hostname) (or rcmd if linstance == NULL),
  43  * this can (usually) only be done by root.
  44  *
  45  * If secure == KRB_VERIFY_SECURE, fail if there's no key.
  46  * If secure == KRB_VERIFY_SECURE_FAIL, don't fail if there's no such
  47  * key in the srvtab.
  48  *
  49  * As a side effect, fresh tickets are obtained.
  50  *
  51  * srvtab is where the key is found.
  52  *
  53  * Returns zero if ok, a positive kerberos error or -1 for system
  54  * errors.
  55  */
  56
  57 static int
  58 krb_verify_user_srvtab_exact(char *name,
  59                              char *instance,
  60                              char *realm,
  61                              char *password,
  62                              int secure,
  63                              char *linstance,
  64                              char *srvtab)
  65 {
  66     int ret;
  67
  68     ret = krb_get_pw_in_tkt(name, instance, realm,
  69                             KRB_TICKET_GRANTING_TICKET,
  70                             realm,
  71                             DEFAULT_TKT_LIFE, password);
  72     if(ret != KSUCCESS)
  73         return ret;
  74
  75     if(secure == KRB_VERIFY_SECURE || secure == KRB_VERIFY_SECURE_FAIL){
  76         struct hostent *hp;
  77         int32_t addr;
  78
  79         KTEXT_ST ticket;
  80         AUTH_DAT auth;
  81         int n;
  82
  83         char lrealm[REALM_SZ];
  84         char hostname[MaxHostNameLen];
  85         char *phost;
  86
  87         if (gethostname(hostname, sizeof(hostname)) == -1) {
  88             dest_tkt();
  89             return -1;
  90         }
  91
  92         hp = gethostbyname(hostname);
  93         if(hp == NULL){
  94             dest_tkt();
  95             return -1;
  96         }
  97         memcpy(&addr, hp->h_addr, sizeof(addr));
  98         phost = krb_get_phost(hostname);
  99         if (linstance == NULL)
 100             linstance = "rcmd";
 101
 102         ret = KFAILURE;
 103
 104         for (n = 1; krb_get_lrealm(lrealm, n) == KSUCCESS; ++n) {
 105             if(secure == KRB_VERIFY_SECURE_FAIL) {
 106                 des_cblock key;
 107                 ret = read_service_key(linstance, phost, lrealm, 0, srvtab,
 108                                        &key);
 109                 memset(key, 0, sizeof(key));
 110                 if(ret == KFAILURE)
 111                     continue;
 112             }
 113
 114             ret = krb_mk_req(&ticket, linstance, phost, lrealm, 0);
 115             if(ret == KSUCCESS) {
 116                 ret = krb_rd_req(&ticket, linstance, phost, addr, &auth,
 117                                  srvtab);
 118                 if (ret == KSUCCESS)
 119                     break;
 120             }
 121         }
 122         if (ret != KSUCCESS) {
 123             dest_tkt();
 124             return ret;
 125         }
 126     }
 127     return 0;
 128 }
 129
 130 /*
 131  * Try to verify the user and password against all the local realms.
 132  */
 133
 134 int
 135 krb_verify_user_srvtab(char *name,
 136                        char *instance,
 137                        char *realm,
 138                        char *password,
 139                        int secure,
 140                        char *linstance,
 141                        char *srvtab)
 142 {
 143   int ret;
 144   int n;
 145   char rlm[256];
 146
 147   /* First try to verify against the supplied realm. */
 148   ret = krb_verify_user_srvtab_exact(name, instance, realm, password,
 149                                      secure, linstance, srvtab);
 150   if (ret == KSUCCESS)
 151     return KSUCCESS;
 152
 153   /* Verify all local realms, except the supplied realm. */
 154   for (n = 1; krb_get_lrealm(rlm, n) == KSUCCESS; n++)
 155     if (strcmp(rlm, realm) != 0) {
 156       ret = krb_verify_user_srvtab_exact(name, instance, rlm, password,
 157                                          secure, linstance, srvtab);
 158       if (ret == KSUCCESS)
 159         return KSUCCESS;
 160     }
 161
 162   return ret;
 163 }
 164
 165 /*
 166  * Compat function without srvtab.
 167  */
 168
 169 int
 170 krb_verify_user(char *name,
 171                 char *instance,
 172                 char *realm,
 173                 char *password,
 174                 int secure,
 175                 char *linstance)
 176 {
 177     return krb_verify_user_srvtab (name,
 178                                    instance,
 179                                    realm,
 180                                    password,
 181                                    secure,
 182                                    linstance,
 183                                    (char *)KEYFILE);
 184 }