source3/libads/kerberos_verify.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    kerberos utility library
   4    Copyright (C) Andrew Tridgell 2001
   5    Copyright (C) Remus Koos 2001
   6    Copyright (C) Luke Howard 2003
   7    Copyright (C) Guenther Deschner 2003
   8    Copyright (C) Jim McDonough (jmcd@us.ibm.com) 2003
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 #include "includes.h"
  26
  27 #ifdef HAVE_KRB5
  28
  29 /**********************************************************************************
  30  Try to verify a ticket using the system keytab... the system keytab has kvno -1 entries, so
  31  it's more like what microsoft does... see comment in utils/net_ads.c in the
  32  ads_keytab_add_entry function for details.
  33 ***********************************************************************************/
  34
  35 static BOOL ads_keytab_verify_ticket(krb5_context context, krb5_auth_context auth_context,
  36                         const DATA_BLOB *ticket, krb5_data *p_packet, krb5_ticket **pp_tkt)
  37 {
  38         krb5_error_code ret = 0;
  39         BOOL auth_ok = False;
  40
  41         krb5_keytab keytab = NULL;
  42         krb5_kt_cursor cursor = NULL;
  43         krb5_keytab_entry kt_entry;
  44         char *princ_name = NULL;
  45
  46         ZERO_STRUCT(kt_entry);
  47         ret = krb5_kt_default(context, &keytab);
  48         if (ret) {
  49                 DEBUG(1, ("ads_keytab_verify_ticket: krb5_kt_default failed (%s)\n", error_message(ret)));
  50                 goto out;
  51         }
  52
  53         ret = krb5_kt_start_seq_get(context, keytab, &cursor);
  54         if (ret) {
  55                 DEBUG(1, ("ads_keytab_verify_ticket: krb5_kt_start_seq_get failed (%s)\n", error_message(ret)));
  56                 goto out;
  57         }
  58
  59         while (!krb5_kt_next_entry(context, keytab, &kt_entry, &cursor)) {
  60                 ret = krb5_unparse_name(context, kt_entry.principal, &princ_name);
  61                 if (ret) {
  62                         DEBUG(1, ("ads_keytab_verify_ticket: krb5_unparse_name failed (%s)\n", error_message(ret)));
  63                         goto out;
  64                 }
  65                 /* Look for a CIFS ticket */
  66                 if (!StrnCaseCmp(princ_name, "cifs/", 5)) {
  67                         krb5_auth_con_setuseruserkey(context, auth_context, &kt_entry.key);
  68
  69                         p_packet->length = ticket->length;
  70                         p_packet->data = (krb5_pointer)ticket->data;
  71
  72                         if (!(ret = krb5_rd_req(context, &auth_context, p_packet, NULL, NULL, NULL, pp_tkt))) {
  73                                 krb5_free_unparsed_name(context, princ_name);
  74                                 princ_name = NULL;
  75                                 DEBUG(10,("ads_keytab_verify_ticket: enc type [%u] decrypted message !\n",
  76                                         (unsigned int) kt_entry.key.enctype));
  77                                 auth_ok = True;
  78                                 break;
  79                         }
  80                 }
  81                 krb5_free_unparsed_name(context, princ_name);
  82                 princ_name = NULL;
  83         }
  84         if (ret && ret != KRB5_KT_END) {
  85                 /* This failed because something went wrong, not because the keytab file was empty. */
  86                 DEBUG(1, ("ads_keytab_verify_ticket: krb5_kt_next_entry failed (%s)\n", error_message(ret)));
  87                 goto out;
  88         }
  89
  90   out:
  91
  92         if (princ_name) {
  93                 krb5_free_unparsed_name(context, princ_name);
  94         }
  95         if (cursor && keytab) {
  96                 krb5_kt_end_seq_get(context, keytab, &cursor);
  97         }
  98         if (keytab) {
  99                 krb5_kt_close(context, keytab);
 100         }
 101
 102         return auth_ok;
 103 }
 104
 105 /**********************************************************************************
 106  Try to verify a ticket using the secrets.tdb.
 107 ***********************************************************************************/
 108
 109 static BOOL ads_secrets_verify_ticket(krb5_context context, krb5_auth_context auth_context,
 110                         krb5_principal host_princ,
 111                         const DATA_BLOB *ticket, krb5_data *p_packet, krb5_ticket **pp_tkt)
 112 {
 113         krb5_error_code ret = 0;
 114         BOOL auth_ok = False;
 115         char *password_s = NULL;
 116         krb5_data password;
 117         krb5_enctype *enctypes = NULL;
 118         int i;
 119
 120         if (!secrets_init()) {
 121                 DEBUG(1,("ads_secrets_verify_ticket: secrets_init failed\n"));
 122                 return False;
 123         }
 124
 125         password_s = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
 126         if (!password_s) {
 127                 DEBUG(1,("ads_secrets_verify_ticket: failed to fetch machine password\n"));
 128                 return False;
 129         }
 130
 131         password.data = password_s;
 132         password.length = strlen(password_s);
 133
 134         /* CIFS doesn't use addresses in tickets. This would break NAT. JRA */
 135
 136         if ((ret = get_kerberos_allowed_etypes(context, &enctypes))) {
 137                 DEBUG(1,("ads_secrets_verify_ticket: krb5_get_permitted_enctypes failed (%s)\n",
 138                          error_message(ret)));
 139                 goto out;
 140         }
 141
 142         p_packet->length = ticket->length;
 143         p_packet->data = (krb5_pointer)ticket->data;
 144
 145         /* We need to setup a auth context with each possible encoding type in turn. */
 146         for (i=0;enctypes[i];i++) {
 147                 krb5_keyblock *key = NULL;
 148
 149                 if (!(key = (krb5_keyblock *)malloc(sizeof(*key)))) {
 150                         goto out;
 151                 }
 152
 153                 if (create_kerberos_key_from_string(context, host_princ, &password, key, enctypes[i])) {
 154                         SAFE_FREE(key);
 155                         continue;
 156                 }
 157
 158                 krb5_auth_con_setuseruserkey(context, auth_context, key);
 159
 160                 krb5_free_keyblock(context, key);
 161
 162                 if (!(ret = krb5_rd_req(context, &auth_context, p_packet,
 163                                         NULL,
 164                                         NULL, NULL, pp_tkt))) {
 165                         DEBUG(10,("ads_secrets_verify_ticket: enc type [%u] decrypted message !\n",
 166                                 (unsigned int)enctypes[i] ));
 167                         auth_ok = True;
 168                         break;
 169                 }
 170
 171                 DEBUG((ret != KRB5_BAD_ENCTYPE) ? 3 : 10,
 172                                 ("ads_secrets_verify_ticket: enc type [%u] failed to decrypt with error %s\n",
 173                                 (unsigned int)enctypes[i], error_message(ret)));
 174         }
 175
 176  out:
 177
 178         free_kerberos_etypes(context, enctypes);
 179         SAFE_FREE(password_s);
 180
 181         return auth_ok;
 182 }
 183
 184 /**********************************************************************************
 185  Verify an incoming ticket and parse out the principal name and
 186  authorization_data if available.
 187 ***********************************************************************************/
 188
 189 NTSTATUS ads_verify_ticket(const char *realm, const DATA_BLOB *ticket,
 190                            char **principal, DATA_BLOB *auth_data,
 191                            DATA_BLOB *ap_rep,
 192                            DATA_BLOB *session_key)
 193 {
 194         NTSTATUS sret = NT_STATUS_LOGON_FAILURE;
 195         krb5_context context = NULL;
 196         krb5_auth_context auth_context = NULL;
 197         krb5_data packet;
 198         krb5_ticket *tkt = NULL;
 199         krb5_rcache rcache = NULL;
 200         int ret;
 201
 202         krb5_principal host_princ = NULL;
 203         char *host_princ_s = NULL;
 204         BOOL got_replay_mutex = False;
 205
 206         fstring myname;
 207         BOOL auth_ok = False;
 208
 209         ZERO_STRUCT(packet);
 210         ZERO_STRUCTP(auth_data);
 211         ZERO_STRUCTP(ap_rep);
 212         ZERO_STRUCTP(session_key);
 213
 214         initialize_krb5_error_table();
 215         ret = krb5_init_context(&context);
 216         if (ret) {
 217                 DEBUG(1,("ads_verify_ticket: krb5_init_context failed (%s)\n", error_message(ret)));
 218                 return NT_STATUS_LOGON_FAILURE;
 219         }
 220
 221         ret = krb5_set_default_realm(context, realm);
 222         if (ret) {
 223                 DEBUG(1,("ads_verify_ticket: krb5_set_default_realm failed (%s)\n", error_message(ret)));
 224                 goto out;
 225         }
 226
 227         /* This whole process is far more complex than I would
 228            like. We have to go through all this to allow us to store
 229            the secret internally, instead of using /etc/krb5.keytab */
 230
 231         ret = krb5_auth_con_init(context, &auth_context);
 232         if (ret) {
 233                 DEBUG(1,("ads_verify_ticket: krb5_auth_con_init failed (%s)\n", error_message(ret)));
 234                 goto out;
 235         }
 236
 237         name_to_fqdn(myname, global_myname());
 238         strlower_m(myname);
 239         asprintf(&host_princ_s, "host/%s@%s", myname, lp_realm());
 240         ret = krb5_parse_name(context, host_princ_s, &host_princ);
 241         if (ret) {
 242                 DEBUG(1,("ads_verify_ticket: krb5_parse_name(%s) failed (%s)\n",
 243                                         host_princ_s, error_message(ret)));
 244                 goto out;
 245         }
 246
 247
 248         /* Lock a mutex surrounding the replay as there is no locking in the MIT krb5
 249          * code surrounding the replay cache... */
 250
 251         if (!grab_server_mutex("replay cache mutex")) {
 252                 DEBUG(1,("ads_verify_ticket: unable to protect replay cache with mutex.\n"));
 253                 goto out;
 254         }
 255
 256         got_replay_mutex = True;
 257
 258         /*
 259          * JRA. We must set the rcache here. This will prevent replay attacks.
 260          */
 261
 262         ret = krb5_get_server_rcache(context, krb5_princ_component(context, host_princ, 0), &rcache);
 263         if (ret) {
 264                 DEBUG(1,("ads_verify_ticket: krb5_get_server_rcache failed (%s)\n", error_message(ret)));
 265                 goto out;
 266         }
 267
 268         ret = krb5_auth_con_setrcache(context, auth_context, rcache);
 269         if (ret) {
 270                 DEBUG(1,("ads_verify_ticket: krb5_auth_con_setrcache failed (%s)\n", error_message(ret)));
 271                 goto out;
 272         }
 273
 274         if (lp_use_kerberos_keytab()) {
 275                 auth_ok = ads_keytab_verify_ticket(context, auth_context, ticket, &packet, &tkt);
 276         }
 277         if (!auth_ok) {
 278                 auth_ok = ads_secrets_verify_ticket(context, auth_context, host_princ,
 279                                                         ticket, &packet, &tkt);
 280         }
 281
 282         release_server_mutex();
 283         got_replay_mutex = False;
 284
 285         if (!auth_ok) {
 286                 DEBUG(3,("ads_verify_ticket: krb5_rd_req with auth failed (%s)\n",
 287                          error_message(ret)));
 288                 goto out;
 289         }
 290
 291         ret = krb5_mk_rep(context, auth_context, &packet);
 292         if (ret) {
 293                 DEBUG(3,("ads_verify_ticket: Failed to generate mutual authentication reply (%s)\n",
 294                         error_message(ret)));
 295                 goto out;
 296         }
 297
 298         *ap_rep = data_blob(packet.data, packet.length);
 299         SAFE_FREE(packet.data);
 300         packet.length = 0;
 301
 302         get_krb5_smb_session_key(context, auth_context, session_key, True);
 303         dump_data_pw("SMB session key (from ticket)\n", session_key->data, session_key->length);
 304
 305 #if 0
 306         file_save("/tmp/ticket.dat", ticket->data, ticket->length);
 307 #endif
 308
 309         get_auth_data_from_tkt(auth_data, tkt);
 310
 311         {
 312                 TALLOC_CTX *ctx = talloc_init("pac data");
 313                 decode_pac_data(auth_data, ctx);
 314                 talloc_destroy(ctx);
 315         }
 316
 317 #if 0
 318         if (tkt->enc_part2) {
 319                 file_save("/tmp/authdata.dat",
 320                           tkt->enc_part2->authorization_data[0]->contents,
 321                           tkt->enc_part2->authorization_data[0]->length);
 322         }
 323 #endif
 324
 325         if ((ret = krb5_unparse_name(context, get_principal_from_tkt(tkt),
 326                                      principal))) {
 327                 DEBUG(3,("ads_verify_ticket: krb5_unparse_name failed (%s)\n",
 328                          error_message(ret)));
 329                 sret = NT_STATUS_LOGON_FAILURE;
 330                 goto out;
 331         }
 332
 333         sret = NT_STATUS_OK;
 334
 335  out:
 336
 337         if (got_replay_mutex) {
 338                 release_server_mutex();
 339         }
 340
 341         if (!NT_STATUS_IS_OK(sret)) {
 342                 data_blob_free(auth_data);
 343         }
 344
 345         if (!NT_STATUS_IS_OK(sret)) {
 346                 data_blob_free(ap_rep);
 347         }
 348
 349         if (host_princ) {
 350                 krb5_free_principal(context, host_princ);
 351         }
 352
 353         if (tkt != NULL) {
 354                 krb5_free_ticket(context, tkt);
 355         }
 356
 357         SAFE_FREE(host_princ_s);
 358
 359         if (auth_context) {
 360                 krb5_auth_con_free(context, auth_context);
 361         }
 362
 363         if (context) {
 364                 krb5_free_context(context);
 365         }
 366
 367         return sret;
 368 }
 369
 370 #endif /* HAVE_KRB5 */