source4/auth/kerberos/clikrb5.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    simple kerberos5 routines for active directory
   4    Copyright (C) Andrew Tridgell 2001
   5    Copyright (C) Luke Howard 2002-2003
   6    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "system/network.h"
  25 #include "system/kerberos.h"
  26 #include "system/time.h"
  27 #include "auth/kerberos/kerberos.h"
  28
  29 #ifdef HAVE_KRB5
  30
  31 #ifndef HAVE_KRB5_SET_REAL_TIME
  32 /*
  33  * This function is not in the Heimdal mainline.
  34  */
  35  krb5_error_code krb5_set_real_time(krb5_context context, int32_t seconds, int32_t microseconds)
  36 {
  37         krb5_error_code ret;
  38         int32_t sec, usec;
  39
  40         ret = krb5_us_timeofday(context, &sec, &usec);
  41         if (ret)
  42                 return ret;
  43
  44         context->kdc_sec_offset = seconds - sec;
  45         context->kdc_usec_offset = microseconds - usec;
  46
  47         return 0;
  48 }
  49 #endif
  50
  51 #if defined(HAVE_KRB5_SET_DEFAULT_IN_TKT_ETYPES) && !defined(HAVE_KRB5_SET_DEFAULT_TGS_KTYPES)
  52  krb5_error_code krb5_set_default_tgs_ktypes(krb5_context ctx, const krb5_enctype *enc)
  53 {
  54         return krb5_set_default_in_tkt_etypes(ctx, enc);
  55 }
  56 #endif
  57
  58 #if defined(HAVE_ADDR_TYPE_IN_KRB5_ADDRESS)
  59 /* HEIMDAL */
  60  void setup_kaddr( krb5_address *pkaddr, struct sockaddr *paddr)
  61 {
  62         pkaddr->addr_type = KRB5_ADDRESS_INET;
  63         pkaddr->address.length = sizeof(((struct sockaddr_in *)paddr)->sin_addr);
  64         pkaddr->address.data = (char *)&(((struct sockaddr_in *)paddr)->sin_addr);
  65 }
  66 #elif defined(HAVE_ADDRTYPE_IN_KRB5_ADDRESS)
  67 /* MIT */
  68  void setup_kaddr( krb5_address *pkaddr, struct sockaddr *paddr)
  69 {
  70         pkaddr->addrtype = ADDRTYPE_INET;
  71         pkaddr->length = sizeof(((struct sockaddr_in *)paddr)->sin_addr);
  72         pkaddr->contents = (krb5_octet *)&(((struct sockaddr_in *)paddr)->sin_addr);
  73 }
  74 #else
  75 #error UNKNOWN_ADDRTYPE
  76 #endif
  77
  78 #if defined(HAVE_KRB5_PRINCIPAL2SALT) && defined(HAVE_KRB5_USE_ENCTYPE) && defined(HAVE_KRB5_STRING_TO_KEY) && defined(HAVE_KRB5_ENCRYPT_BLOCK)
  79  int create_kerberos_key_from_string_direct(krb5_context context,
  80                                         krb5_principal host_princ,
  81                                         krb5_data *password,
  82                                         krb5_keyblock *key,
  83                                         krb5_enctype enctype)
  84 {
  85         int ret;
  86         krb5_data salt;
  87         krb5_encrypt_block eblock;
  88
  89         ret = krb5_principal2salt(context, host_princ, &salt);
  90         if (ret) {
  91                 DEBUG(1,("krb5_principal2salt failed (%s)\n", error_message(ret)));
  92                 return ret;
  93         }
  94         krb5_use_enctype(context, &eblock, enctype);
  95         ret = krb5_string_to_key(context, &eblock, key, password, &salt);
  96         SAFE_FREE(salt.data);
  97         return ret;
  98 }
  99 #elif defined(HAVE_KRB5_GET_PW_SALT) && defined(HAVE_KRB5_STRING_TO_KEY_SALT)
 100  int create_kerberos_key_from_string_direct(krb5_context context,
 101                                         krb5_principal host_princ,
 102                                         krb5_data *password,
 103                                         krb5_keyblock *key,
 104                                         krb5_enctype enctype)
 105 {
 106         int ret;
 107         krb5_salt salt;
 108
 109         ret = krb5_get_pw_salt(context, host_princ, &salt);
 110         if (ret) {
 111                 DEBUG(1,("krb5_get_pw_salt failed (%s)\n", error_message(ret)));
 112                 return ret;
 113         }
 114         return krb5_string_to_key_salt(context, enctype, password->data,
 115                 salt, key);
 116 }
 117 #else
 118 #error UNKNOWN_CREATE_KEY_FUNCTIONS
 119 #endif
 120
 121  int create_kerberos_key_from_string(krb5_context context,
 122                                         krb5_principal host_princ,
 123                                         krb5_data *password,
 124                                         krb5_keyblock *key,
 125                                         krb5_enctype enctype)
 126 {
 127         krb5_principal salt_princ = NULL;
 128         int ret;
 129         /*
 130          * Check if we've determined that the KDC is salting keys for this
 131          * principal/enctype in a non-obvious way.  If it is, try to match
 132          * its behavior.
 133          */
 134         salt_princ = kerberos_fetch_salt_princ_for_host_princ(context, host_princ, enctype);
 135         ret = create_kerberos_key_from_string_direct(context, salt_princ ? salt_princ : host_princ, password, key, enctype);
 136         if (salt_princ) {
 137                 krb5_free_principal(context, salt_princ);
 138         }
 139         return ret;
 140 }
 141
 142 #if defined(HAVE_KRB5_GET_PERMITTED_ENCTYPES)
 143  krb5_error_code get_kerberos_allowed_etypes(krb5_context context,
 144                                             krb5_enctype **enctypes)
 145 {
 146         return krb5_get_permitted_enctypes(context, enctypes);
 147 }
 148 #elif defined(HAVE_KRB5_GET_DEFAULT_IN_TKT_ETYPES)
 149  krb5_error_code get_kerberos_allowed_etypes(krb5_context context,
 150                                             krb5_enctype **enctypes)
 151 {
 152         return krb5_get_default_in_tkt_etypes(context, enctypes);
 153 }
 154 #else
 155 #error UNKNOWN_GET_ENCTYPES_FUNCTIONS
 156 #endif
 157
 158  void free_kerberos_etypes(krb5_context context,
 159                            krb5_enctype *enctypes)
 160 {
 161 #if defined(HAVE_KRB5_FREE_KTYPES)
 162         krb5_free_ktypes(context, enctypes);
 163         return;
 164 #else
 165         SAFE_FREE(enctypes);
 166         return;
 167 #endif
 168 }
 169
 170 #if defined(HAVE_KRB5_AUTH_CON_SETKEY) && !defined(HAVE_KRB5_AUTH_CON_SETUSERUSERKEY)
 171  krb5_error_code krb5_auth_con_setuseruserkey(krb5_context context,
 172                                         krb5_auth_context auth_context,
 173                                         krb5_keyblock *keyblock)
 174 {
 175         return krb5_auth_con_setkey(context, auth_context, keyblock);
 176 }
 177 #endif
 178
 179  DATA_BLOB get_auth_data_from_tkt(TALLOC_CTX *mem_ctx,
 180                             krb5_ticket *tkt)
 181 {
 182         DATA_BLOB auth_data = data_blob(NULL, 0);
 183 #if defined(HAVE_KRB5_TKT_ENC_PART2)
 184         if (tkt && tkt->enc_part2
 185             && tkt->enc_part2->authorization_data
 186             && tkt->enc_part2->authorization_data[0]
 187             && tkt->enc_part2->authorization_data[0]->length)
 188                 auth_data = data_blob(tkt->enc_part2->authorization_data[0]->contents,
 189                         tkt->enc_part2->authorization_data[0]->length);
 190 #else
 191         if (tkt && tkt->ticket.authorization_data && tkt->ticket.authorization_data->len)
 192                 auth_data = data_blob(tkt->ticket.authorization_data->val->ad_data.data,
 193                         tkt->ticket.authorization_data->val->ad_data.length);
 194 #endif
 195         return auth_data;
 196 }
 197
 198  krb5_const_principal get_principal_from_tkt(krb5_ticket *tkt)
 199 {
 200 #if defined(HAVE_KRB5_TKT_ENC_PART2)
 201         return tkt->enc_part2->client;
 202 #else
 203         return tkt->client;
 204 #endif
 205 }
 206
 207 #if !defined(HAVE_KRB5_LOCATE_KDC)
 208  krb5_error_code krb5_locate_kdc(krb5_context ctx, const krb5_data *realm, struct sockaddr **addr_pp, int *naddrs, int get_masters)
 209 {
 210         krb5_krbhst_handle hnd;
 211         krb5_krbhst_info *hinfo;
 212         krb5_error_code rc;
 213         int num_kdcs, i;
 214         struct sockaddr *sa;
 215         struct addrinfo *ai;
 216
 217         *addr_pp = NULL;
 218         *naddrs = 0;
 219
 220         rc = krb5_krbhst_init(ctx, realm->data, KRB5_KRBHST_KDC, &hnd);
 221         if (rc) {
 222                 DEBUG(0, ("krb5_locate_kdc: krb5_krbhst_init failed (%s)\n", error_message(rc)));
 223                 return rc;
 224         }
 225
 226         for ( num_kdcs = 0; (rc = krb5_krbhst_next(ctx, hnd, &hinfo) == 0); num_kdcs++)
 227                 ;
 228
 229         krb5_krbhst_reset(ctx, hnd);
 230
 231         if (!num_kdcs) {
 232                 DEBUG(0, ("krb5_locate_kdc: zero kdcs found !\n"));
 233                 krb5_krbhst_free(ctx, hnd);
 234                 return -1;
 235         }
 236
 237         sa = malloc_array_p(struct sockaddr, num_kdcs);
 238         if (!sa) {
 239                 DEBUG(0, ("krb5_locate_kdc: malloc failed\n"));
 240                 krb5_krbhst_free(ctx, hnd);
 241                 naddrs = 0;
 242                 return -1;
 243         }
 244
 245         memset(sa, '\0', sizeof(struct sockaddr) * num_kdcs );
 246
 247         for (i = 0; i < num_kdcs && (rc = krb5_krbhst_next(ctx, hnd, &hinfo) == 0); i++) {
 248
 249 #if defined(HAVE_KRB5_KRBHST_GET_ADDRINFO)
 250                 rc = krb5_krbhst_get_addrinfo(ctx, hinfo, &ai);
 251                 if (rc) {
 252                         DEBUG(0,("krb5_krbhst_get_addrinfo failed: %s\n", error_message(rc)));
 253                         continue;
 254                 }
 255 #endif
 256                 if (hinfo->ai && hinfo->ai->ai_family == AF_INET)
 257                         memcpy(&sa[i], hinfo->ai->ai_addr, sizeof(struct sockaddr));
 258         }
 259
 260         krb5_krbhst_free(ctx, hnd);
 261
 262         *naddrs = num_kdcs;
 263         *addr_pp = sa;
 264         return 0;
 265 }
 266 #endif
 267
 268 #if !defined(HAVE_KRB5_FREE_UNPARSED_NAME)
 269  void krb5_free_unparsed_name(krb5_context context, char *val)
 270 {
 271         SAFE_FREE(val);
 272 }
 273 #endif
 274
 275  void kerberos_free_data_contents(krb5_context context, krb5_data *pdata)
 276 {
 277 #if defined(HAVE_KRB5_FREE_DATA_CONTENTS)
 278         if (pdata->data) {
 279                 krb5_free_data_contents(context, pdata);
 280         }
 281 #else
 282         SAFE_FREE(pdata->data);
 283 #endif
 284 }
 285
 286  void kerberos_set_creds_enctype(krb5_creds *pcreds, int enctype)
 287 {
 288 #if defined(HAVE_KRB5_KEYBLOCK_IN_CREDS)
 289         KRB5_KEY_TYPE((&pcreds->keyblock)) = enctype;
 290 #elif defined(HAVE_KRB5_SESSION_IN_CREDS)
 291         KRB5_KEY_TYPE((&pcreds->session)) = enctype;
 292 #else
 293 #error UNKNOWN_KEYBLOCK_MEMBER_IN_KRB5_CREDS_STRUCT
 294 #endif
 295 }
 296
 297  BOOL kerberos_compatible_enctypes(krb5_context context,
 298                                   krb5_enctype enctype1,
 299                                   krb5_enctype enctype2)
 300 {
 301 #if defined(HAVE_KRB5_C_ENCTYPE_COMPARE)
 302         krb5_boolean similar = 0;
 303
 304         krb5_c_enctype_compare(context, enctype1, enctype2, &similar);
 305         return similar ? True : False;
 306 #elif defined(HAVE_KRB5_ENCTYPES_COMPATIBLE_KEYS)
 307         return krb5_enctypes_compatible_keys(context, enctype1, enctype2) ? True : False;
 308 #endif
 309 }
 310
 311 static BOOL ads_cleanup_expired_creds(krb5_context context,
 312                                       krb5_ccache  ccache,
 313                                       krb5_creds  *credsp)
 314 {
 315         krb5_error_code retval;
 316         TALLOC_CTX *mem_ctx = talloc_init("ticket expied time");
 317         if (!mem_ctx) {
 318                 return False;
 319         }
 320
 321         DEBUG(3, ("Ticket in ccache[%s] expiration %s\n",
 322                   krb5_cc_default_name(context),
 323                   http_timestring(mem_ctx, credsp->times.endtime)));
 324
 325         talloc_free(mem_ctx);
 326
 327         /* we will probably need new tickets if the current ones
 328            will expire within 10 seconds.
 329         */
 330         if (credsp->times.endtime >= (time(NULL) + 10))
 331                 return False;
 332
 333         /* heimdal won't remove creds from a file ccache, and
 334            perhaps we shouldn't anyway, since internally we
 335            use memory ccaches, and a FILE one probably means that
 336            we're using creds obtained outside of our exectuable
 337         */
 338         if (StrCaseCmp(krb5_cc_get_type(context, ccache), "FILE") == 0) {
 339                 DEBUG(5, ("ads_cleanup_expired_creds: We do not remove creds from a FILE ccache\n"));
 340                 return False;
 341         }
 342
 343         retval = krb5_cc_remove_cred(context, ccache, 0, credsp);
 344         if (retval) {
 345                 DEBUG(1, ("ads_cleanup_expired_creds: krb5_cc_remove_cred failed, err %s\n",
 346                           error_message(retval)));
 347                 /* If we have an error in this, we want to display it,
 348                    but continue as though we deleted it */
 349         }
 350         return True;
 351 }
 352
 353 /*
 354   we can't use krb5_mk_req because w2k wants the service to be in a particular format
 355 */
 356 krb5_error_code ads_krb5_mk_req(krb5_context context,
 357                                 krb5_auth_context *auth_context,
 358                                 const krb5_flags ap_req_options,
 359                                 const char *principal,
 360                                 krb5_ccache ccache,
 361                                 krb5_data *outbuf)
 362 {
 363         krb5_error_code           retval;
 364         krb5_principal    server;
 365         krb5_creds              * credsp;
 366         krb5_creds                creds;
 367         krb5_data in_data;
 368         BOOL creds_ready = False;
 369
 370         TALLOC_CTX *mem_ctx = NULL;
 371
 372         retval = krb5_parse_name(context, principal, &server);
 373         if (retval) {
 374                 DEBUG(1,("ads_krb5_mk_req: Failed to parse principal %s\n", principal));
 375                 return retval;
 376         }
 377
 378         /* obtain ticket & session key */
 379         ZERO_STRUCT(creds);
 380         if ((retval = krb5_copy_principal(context, server, &creds.server))) {
 381                 DEBUG(1,("krb5_copy_principal failed (%s)\n",
 382                          error_message(retval)));
 383                 goto cleanup_princ;
 384         }
 385
 386         if ((retval = krb5_cc_get_principal(context, ccache, &creds.client))) {
 387                 /* This can commonly fail on smbd startup with no ticket in the cache.
 388                  * Report at higher level than 1. */
 389                 DEBUG(3,("ads_krb5_mk_req: krb5_cc_get_principal failed (%s)\n",
 390                          error_message(retval)));
 391                 goto cleanup_creds;
 392         }
 393
 394         while(!creds_ready) {
 395                 if ((retval = krb5_get_credentials(context, 0, ccache,
 396                                                    &creds, &credsp))) {
 397                         DEBUG(1,("ads_krb5_mk_req: krb5_get_credentials failed for %s (%s)\n",
 398                                  principal, error_message(retval)));
 399                         goto cleanup_creds;
 400                 }
 401
 402                 /* cope with ticket being in the future due to clock skew */
 403                 if ((unsigned)credsp->times.starttime > time(NULL)) {
 404                         time_t t = time(NULL);
 405                         int time_offset =(unsigned)credsp->times.starttime-t;
 406                         DEBUG(4,("ads_krb5_mk_req: Advancing clock by %d seconds to cope with clock skew\n", time_offset));
 407                         krb5_set_real_time(context, t + time_offset + 1, 0);
 408                 }
 409
 410                 if (!ads_cleanup_expired_creds(context, ccache, credsp))
 411                         creds_ready = True;
 412         }
 413
 414         mem_ctx = talloc_init("ticket expied time");
 415         if (!mem_ctx) {
 416                 retval = ENOMEM;
 417                 goto cleanup_creds;
 418         }
 419         DEBUG(10,("Ticket (%s) in ccache (%s) is valid until: (%s - %d)\n",
 420                   principal, krb5_cc_default_name(context),
 421                   http_timestring(mem_ctx, (unsigned)credsp->times.endtime),
 422                   (unsigned)credsp->times.endtime));
 423
 424         in_data.length = 0;
 425         retval = krb5_mk_req_extended(context, auth_context, ap_req_options,
 426                                       &in_data, credsp, outbuf);
 427         if (retval) {
 428                 DEBUG(1,("ads_krb5_mk_req: krb5_mk_req_extended failed (%s)\n",
 429                          error_message(retval)));
 430         }
 431
 432         krb5_free_creds(context, credsp);
 433
 434 cleanup_creds:
 435         krb5_free_cred_contents(context, &creds);
 436
 437 cleanup_princ:
 438         krb5_free_principal(context, server);
 439
 440         return retval;
 441 }
 442
 443  krb5_error_code smb_krb5_kt_free_entry(krb5_context context, krb5_keytab_entry *kt_entry)
 444 {
 445 #if defined(HAVE_KRB5_KT_FREE_ENTRY)
 446         return krb5_kt_free_entry(context, kt_entry);
 447 #elif defined(HAVE_KRB5_FREE_KEYTAB_ENTRY_CONTENTS)
 448         return krb5_free_keytab_entry_contents(context, kt_entry);
 449 #else
 450 #error UNKNOWN_KT_FREE_FUNCTION
 451 #endif
 452 }
 453
 454  char *smb_get_krb5_error_message(krb5_context context, krb5_error_code code, TALLOC_CTX *mem_ctx)
 455 {
 456         char *ret;
 457
 458 #if defined(HAVE_KRB5_GET_ERROR_STRING) && defined(HAVE_KRB5_FREE_ERROR_STRING)
 459         char *context_error = krb5_get_error_string(context);
 460         ret = talloc_asprintf(mem_ctx, "%s: %s", error_message(code), context_error);
 461         krb5_free_error_string(context, context_error);
 462 #else
 463         ret = talloc_strdup(mem_ctx, error_message(code));
 464 #endif
 465         return ret;
 466 }
 467
 468
 469 static int smb_krb5_context_destory_1(void *ptr)
 470 {
 471         struct smb_krb5_context *ctx = ptr;
 472         krb5_free_context(ctx->krb5_context);
 473         return 0;
 474 }
 475
 476 #ifdef HAVE_KRB5_LOG_CONTROL
 477 static int smb_krb5_context_destory_2(void *ptr)
 478 {
 479         struct smb_krb5_context *ctx = ptr;
 480
 481         /* Otherwise krb5_free_context will try and close what we have already free()ed */
 482         krb5_set_warn_dest(ctx->krb5_context, NULL);
 483         krb5_closelog(ctx->krb5_context, ctx->logf);
 484         smb_krb5_context_destory_1(ptr);
 485         return 0;
 486 }
 487
 488 /* We never close down the DEBUG system, and no need to unreference the use */
 489 static void smb_krb5_debug_close(void *private) {
 490         return;
 491 }
 492
 493 static void smb_krb5_debug_wrapper(const char *timestr, const char *msg, void *private)
 494 {
 495         DEBUG(3, ("Kerberos: %s\n", msg));
 496 }
 497
 498 #endif
 499
 500  krb5_error_code smb_krb5_init_context(TALLOC_CTX *parent_ctx,
 501                                        struct smb_krb5_context **smb_krb5_context)
 502 {
 503         krb5_error_code ret;
 504         TALLOC_CTX *tmp_ctx;
 505
 506         *smb_krb5_context = talloc(parent_ctx, struct smb_krb5_context);
 507         tmp_ctx = talloc_new(*smb_krb5_context);
 508
 509         if (!*smb_krb5_context || !tmp_ctx) {
 510                 talloc_free(*smb_krb5_context);
 511                 talloc_free(tmp_ctx);
 512                 return ENOMEM;
 513         }
 514
 515         ret = krb5_init_context(&(*smb_krb5_context)->krb5_context);
 516         if (ret) {
 517                 DEBUG(1,("krb5_init_context failed (%s)\n",
 518                          error_message(ret)));
 519                 return ret;
 520         }
 521
 522         talloc_set_destructor(*smb_krb5_context, smb_krb5_context_destory_1);
 523
 524         if (lp_realm() && *lp_realm()) {
 525                 char *upper_realm = strupper_talloc(tmp_ctx, lp_realm());
 526                 if (!upper_realm) {
 527                         DEBUG(1,("gensec_krb5_start: could not uppercase realm: %s\n", lp_realm()));
 528                         return ENOMEM;
 529                 }
 530                 ret = krb5_set_default_realm((*smb_krb5_context)->krb5_context, lp_realm());
 531                 if (ret) {
 532                         DEBUG(1,("krb5_set_default_realm failed (%s)\n",
 533                                  smb_get_krb5_error_message((*smb_krb5_context)->krb5_context, ret, tmp_ctx)));
 534                         talloc_free(*smb_krb5_context);
 535                         return ret;
 536                 }
 537         }
 538
 539 #ifdef HAVE_KRB5_LOG_CONTROL
 540         /* TODO: Should we have a different name here? */
 541         ret = krb5_initlog((*smb_krb5_context)->krb5_context, "Samba", &(*smb_krb5_context)->logf);
 542
 543         if (ret) {
 544                 DEBUG(1,("krb5_initlog failed (%s)\n",
 545                          smb_get_krb5_error_message((*smb_krb5_context)->krb5_context, ret, tmp_ctx)));
 546                 talloc_free(*smb_krb5_context);
 547                 return ret;
 548         }
 549
 550         talloc_set_destructor(*smb_krb5_context, smb_krb5_context_destory_2);
 551
 552         ret = krb5_addlog_func((*smb_krb5_context)->krb5_context, (*smb_krb5_context)->logf, 0 /* min */, -1 /* max */,
 553                                smb_krb5_debug_wrapper, smb_krb5_debug_close, NULL);
 554         if (ret) {
 555                 DEBUG(1,("krb5_addlog_func failed (%s)\n",
 556                          smb_get_krb5_error_message((*smb_krb5_context)->krb5_context, ret, tmp_ctx)));
 557                 talloc_free(*smb_krb5_context);
 558                 return ret;
 559         }
 560         krb5_set_warn_dest((*smb_krb5_context)->krb5_context, (*smb_krb5_context)->logf);
 561
 562 #endif
 563         talloc_free(tmp_ctx);
 564         return 0;
 565 }
 566
 567 #endif