source3/librpc/crypto/gse.c

   1 /*
   2  *  GSSAPI Security Extensions
   3  *  RPC Pipe client and server routines
   4  *  Copyright (C) Simo Sorce 2010.
   5  *  Copyright (C) Andrew Bartlett 2004-2011.
   6  *  Copyright (C) Stefan Metzmacher <metze@samba.org> 2004-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 3 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, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 /* We support only GSSAPI/KRB5 here */
  23
  24 #include "includes.h"
  25 #include "gse.h"
  26 #include "libads/kerberos_proto.h"
  27 #include "auth/common_auth.h"
  28 #include "auth/gensec/gensec.h"
  29 #include "auth/credentials/credentials.h"
  30 #include "../librpc/gen_ndr/dcerpc.h"
  31 #include "auth/kerberos/pac_utils.h"
  32
  33 #if defined(HAVE_KRB5)
  34
  35 #include "gse_krb5.h"
  36
  37 static char *gse_errstr(TALLOC_CTX *mem_ctx, OM_uint32 maj, OM_uint32 min);
  38
  39 struct gse_context {
  40         gss_ctx_id_t gssapi_context;
  41         gss_name_t server_name;
  42         gss_name_t client_name;
  43         OM_uint32 gss_want_flags, gss_got_flags;
  44
  45         gss_cred_id_t delegated_cred_handle;
  46
  47         /* gensec_gse only */
  48         krb5_context k5ctx;
  49         krb5_ccache ccache;
  50         krb5_keytab keytab;
  51
  52         gss_OID_desc gss_mech;
  53         gss_cred_id_t creds;
  54
  55         gss_OID ret_mech;
  56 };
  57
  58 #ifndef HAVE_GSS_OID_EQUAL
  59
  60 static bool gss_oid_equal(const gss_OID o1, const gss_OID o2)
  61 {
  62         if (o1 == o2) {
  63                 return true;
  64         }
  65         if ((o1 == NULL && o2 != NULL) || (o1 != NULL && o2 == NULL)) {
  66                 return false;
  67         }
  68         if (o1->length != o2->length) {
  69                 return false;
  70         }
  71         return memcmp(o1->elements, o2->elements, o1->length) == false;
  72 }
  73
  74 #endif
  75
  76 /* free non talloc dependent contexts */
  77 static int gse_context_destructor(void *ptr)
  78 {
  79         struct gse_context *gse_ctx;
  80         OM_uint32 gss_min;
  81
  82         gse_ctx = talloc_get_type_abort(ptr, struct gse_context);
  83         if (gse_ctx->k5ctx) {
  84                 if (gse_ctx->ccache) {
  85                         krb5_cc_close(gse_ctx->k5ctx, gse_ctx->ccache);
  86                         gse_ctx->ccache = NULL;
  87                 }
  88                 if (gse_ctx->keytab) {
  89                         krb5_kt_close(gse_ctx->k5ctx, gse_ctx->keytab);
  90                         gse_ctx->keytab = NULL;
  91                 }
  92                 krb5_free_context(gse_ctx->k5ctx);
  93                 gse_ctx->k5ctx = NULL;
  94         }
  95         if (gse_ctx->gssapi_context != GSS_C_NO_CONTEXT) {
  96                 (void)gss_delete_sec_context(&gss_min,
  97                                                  &gse_ctx->gssapi_context,
  98                                                  GSS_C_NO_BUFFER);
  99         }
 100         if (gse_ctx->server_name) {
 101                 (void)gss_release_name(&gss_min,
 102                                            &gse_ctx->server_name);
 103         }
 104         if (gse_ctx->client_name) {
 105                 (void)gss_release_name(&gss_min,
 106                                            &gse_ctx->client_name);
 107         }
 108         if (gse_ctx->creds) {
 109                 (void)gss_release_cred(&gss_min,
 110                                            &gse_ctx->creds);
 111         }
 112         if (gse_ctx->delegated_cred_handle) {
 113                 (void)gss_release_cred(&gss_min,
 114                                            &gse_ctx->delegated_cred_handle);
 115         }
 116
 117         /* MIT and Heimdal differ as to if you can call
 118          * gss_release_oid() on this OID, generated by
 119          * gss_{accept,init}_sec_context().  However, as long as the
 120          * oid is gss_mech_krb5 (which it always is at the moment),
 121          * then this is a moot point, as both declare this particular
 122          * OID static, and so no memory is lost.  This assert is in
 123          * place to ensure that the programmer who wishes to extend
 124          * this code to EAP or other GSS mechanisms determines an
 125          * implementation-dependent way of releasing any dynamically
 126          * allocated OID */
 127         SMB_ASSERT(gss_oid_equal(&gse_ctx->gss_mech, GSS_C_NO_OID) || gss_oid_equal(&gse_ctx->gss_mech, gss_mech_krb5));
 128
 129         return 0;
 130 }
 131
 132 static NTSTATUS gse_context_init(TALLOC_CTX *mem_ctx,
 133                                  bool do_sign, bool do_seal,
 134                                  const char *ccache_name,
 135                                  uint32_t add_gss_c_flags,
 136                                  struct gse_context **_gse_ctx)
 137 {
 138         struct gse_context *gse_ctx;
 139         krb5_error_code k5ret;
 140         NTSTATUS status;
 141
 142         gse_ctx = talloc_zero(mem_ctx, struct gse_context);
 143         if (!gse_ctx) {
 144                 return NT_STATUS_NO_MEMORY;
 145         }
 146         talloc_set_destructor((TALLOC_CTX *)gse_ctx, gse_context_destructor);
 147
 148         memcpy(&gse_ctx->gss_mech, gss_mech_krb5, sizeof(gss_OID_desc));
 149
 150         gse_ctx->gss_want_flags = GSS_C_MUTUAL_FLAG |
 151                                 GSS_C_DELEG_FLAG |
 152                                 GSS_C_DELEG_POLICY_FLAG |
 153                                 GSS_C_REPLAY_FLAG |
 154                                 GSS_C_SEQUENCE_FLAG;
 155         if (do_sign) {
 156                 gse_ctx->gss_want_flags |= GSS_C_INTEG_FLAG;
 157         }
 158         if (do_seal) {
 159                 gse_ctx->gss_want_flags |= GSS_C_INTEG_FLAG;
 160                 gse_ctx->gss_want_flags |= GSS_C_CONF_FLAG;
 161         }
 162
 163         gse_ctx->gss_want_flags |= add_gss_c_flags;
 164
 165         /* Initialize Kerberos Context */
 166         initialize_krb5_error_table();
 167
 168         k5ret = krb5_init_context(&gse_ctx->k5ctx);
 169         if (k5ret) {
 170                 DEBUG(0, ("Failed to initialize kerberos context! (%s)\n",
 171                           error_message(k5ret)));
 172                 status = NT_STATUS_INTERNAL_ERROR;
 173                 goto err_out;
 174         }
 175
 176         if (!ccache_name) {
 177                 ccache_name = krb5_cc_default_name(gse_ctx->k5ctx);
 178         }
 179         k5ret = krb5_cc_resolve(gse_ctx->k5ctx, ccache_name,
 180                                 &gse_ctx->ccache);
 181         if (k5ret) {
 182                 DEBUG(1, ("Failed to resolve credential cache! (%s)\n",
 183                           error_message(k5ret)));
 184                 status = NT_STATUS_INTERNAL_ERROR;
 185                 goto err_out;
 186         }
 187
 188         /* TODO: Should we enforce a enc_types list ?
 189         ret = krb5_set_default_tgs_ktypes(gse_ctx->k5ctx, enc_types);
 190         */
 191
 192         *_gse_ctx = gse_ctx;
 193         return NT_STATUS_OK;
 194
 195 err_out:
 196         TALLOC_FREE(gse_ctx);
 197         return status;
 198 }
 199
 200 static NTSTATUS gse_init_client(TALLOC_CTX *mem_ctx,
 201                                 bool do_sign, bool do_seal,
 202                                 const char *ccache_name,
 203                                 const char *server,
 204                                 const char *service,
 205                                 const char *username,
 206                                 const char *password,
 207                                 uint32_t add_gss_c_flags,
 208                                 struct gse_context **_gse_ctx)
 209 {
 210         struct gse_context *gse_ctx;
 211         OM_uint32 gss_maj, gss_min;
 212         gss_buffer_desc name_buffer = {0, NULL};
 213         gss_OID_set_desc mech_set;
 214         NTSTATUS status;
 215
 216         if (!server || !service) {
 217                 return NT_STATUS_INVALID_PARAMETER;
 218         }
 219
 220         status = gse_context_init(mem_ctx, do_sign, do_seal,
 221                                   ccache_name, add_gss_c_flags,
 222                                   &gse_ctx);
 223         if (!NT_STATUS_IS_OK(status)) {
 224                 return NT_STATUS_NO_MEMORY;
 225         }
 226
 227         /* Guess the realm based on the supplied service, and avoid the GSS libs
 228            doing DNS lookups which may fail.
 229
 230            TODO: Loop with the KDC on some more combinations (local
 231            realm in particular), possibly falling back to
 232            GSS_C_NT_HOSTBASED_SERVICE
 233         */
 234         name_buffer.value = kerberos_get_principal_from_service_hostname(
 235                                         gse_ctx, service, server, lp_realm());
 236         if (!name_buffer.value) {
 237                 status = NT_STATUS_NO_MEMORY;
 238                 goto err_out;
 239         }
 240         name_buffer.length = strlen((char *)name_buffer.value);
 241         gss_maj = gss_import_name(&gss_min, &name_buffer,
 242                                   GSS_C_NT_USER_NAME,
 243                                   &gse_ctx->server_name);
 244         if (gss_maj) {
 245                 DEBUG(0, ("gss_import_name failed for %s, with [%s]\n",
 246                           (char *)name_buffer.value,
 247                           gse_errstr(gse_ctx, gss_maj, gss_min)));
 248                 status = NT_STATUS_INTERNAL_ERROR;
 249                 goto err_out;
 250         }
 251
 252         /* TODO: get krb5 ticket using username/password, if no valid
 253          * one already available in ccache */
 254
 255         mech_set.count = 1;
 256         mech_set.elements = &gse_ctx->gss_mech;
 257
 258         gss_maj = gss_acquire_cred(&gss_min,
 259                                    GSS_C_NO_NAME,
 260                                    GSS_C_INDEFINITE,
 261                                    &mech_set,
 262                                    GSS_C_INITIATE,
 263                                    &gse_ctx->creds,
 264                                    NULL, NULL);
 265         if (gss_maj) {
 266                 DEBUG(0, ("gss_acquire_creds failed for %s, with [%s]\n",
 267                           (char *)name_buffer.value,
 268                           gse_errstr(gse_ctx, gss_maj, gss_min)));
 269                 status = NT_STATUS_INTERNAL_ERROR;
 270                 goto err_out;
 271         }
 272
 273         *_gse_ctx = gse_ctx;
 274         TALLOC_FREE(name_buffer.value);
 275         return NT_STATUS_OK;
 276
 277 err_out:
 278         TALLOC_FREE(name_buffer.value);
 279         TALLOC_FREE(gse_ctx);
 280         return status;
 281 }
 282
 283 static NTSTATUS gse_get_client_auth_token(TALLOC_CTX *mem_ctx,
 284                                           struct gse_context *gse_ctx,
 285                                           const DATA_BLOB *token_in,
 286                                           DATA_BLOB *token_out)
 287 {
 288         OM_uint32 gss_maj, gss_min;
 289         gss_buffer_desc in_data;
 290         gss_buffer_desc out_data;
 291         DATA_BLOB blob = data_blob_null;
 292         NTSTATUS status;
 293
 294         in_data.value = token_in->data;
 295         in_data.length = token_in->length;
 296
 297         gss_maj = gss_init_sec_context(&gss_min,
 298                                         gse_ctx->creds,
 299                                         &gse_ctx->gssapi_context,
 300                                         gse_ctx->server_name,
 301                                         &gse_ctx->gss_mech,
 302                                         gse_ctx->gss_want_flags,
 303                                         0, GSS_C_NO_CHANNEL_BINDINGS,
 304                                         &in_data, NULL, &out_data,
 305                                         &gse_ctx->gss_got_flags, NULL);
 306         switch (gss_maj) {
 307         case GSS_S_COMPLETE:
 308                 /* we are done with it */
 309                 status = NT_STATUS_OK;
 310                 break;
 311         case GSS_S_CONTINUE_NEEDED:
 312                 /* we will need a third leg */
 313                 status = NT_STATUS_MORE_PROCESSING_REQUIRED;
 314                 break;
 315         default:
 316                 DEBUG(0, ("gss_init_sec_context failed with [%s]\n",
 317                           gse_errstr(talloc_tos(), gss_maj, gss_min)));
 318                 status = NT_STATUS_INTERNAL_ERROR;
 319                 goto done;
 320         }
 321
 322         /* we may be told to return nothing */
 323         if (out_data.length) {
 324                 blob = data_blob_talloc(mem_ctx, out_data.value, out_data.length);
 325                 if (!blob.data) {
 326                         status = NT_STATUS_NO_MEMORY;
 327                 }
 328
 329                 gss_maj = gss_release_buffer(&gss_min, &out_data);
 330         }
 331
 332 done:
 333         *token_out = blob;
 334         return status;
 335 }
 336
 337 static NTSTATUS gse_init_server(TALLOC_CTX *mem_ctx,
 338                                 bool do_sign, bool do_seal,
 339                                 uint32_t add_gss_c_flags,
 340                                 struct gse_context **_gse_ctx)
 341 {
 342         struct gse_context *gse_ctx;
 343         OM_uint32 gss_maj, gss_min;
 344         krb5_error_code ret;
 345         NTSTATUS status;
 346
 347         status = gse_context_init(mem_ctx, do_sign, do_seal,
 348                                   NULL, add_gss_c_flags, &gse_ctx);
 349         if (!NT_STATUS_IS_OK(status)) {
 350                 return NT_STATUS_NO_MEMORY;
 351         }
 352
 353         ret = gse_krb5_get_server_keytab(gse_ctx->k5ctx,
 354                                          &gse_ctx->keytab);
 355         if (ret) {
 356                 status = NT_STATUS_INTERNAL_ERROR;
 357                 goto done;
 358         }
 359
 360 #ifdef HAVE_GSS_KRB5_IMPORT_CRED
 361
 362         /* This creates a GSSAPI cred_id_t with the keytab set */
 363         gss_maj = gss_krb5_import_cred(&gss_min, NULL, NULL, gse_ctx->keytab,
 364                                        &gse_ctx->creds);
 365
 366         if (gss_maj != 0
 367             && gss_maj != (GSS_S_CALL_BAD_STRUCTURE|GSS_S_BAD_NAME)) {
 368                 DEBUG(0, ("gss_krb5_import_cred failed with [%s]\n",
 369                           gse_errstr(gse_ctx, gss_maj, gss_min)));
 370                 status = NT_STATUS_INTERNAL_ERROR;
 371                 goto done;
 372
 373                 /* This is the error the MIT krb5 1.9 gives when it
 374                  * implements the function, but we do not specify the
 375                  * principal.  However, when we specify the principal
 376                  * as host$@REALM the GSS acceptor fails with 'wrong
 377                  * principal in request'.  Work around the issue by
 378                  * falling back to the alternate approach below. */
 379         } else if (gss_maj == (GSS_S_CALL_BAD_STRUCTURE|GSS_S_BAD_NAME))
 380 #endif
 381         /* FIXME!!!
 382          * This call sets the default keytab for the whole server, not
 383          * just for this context. Need to find a way that does not alter
 384          * the state of the whole server ... */
 385         {
 386                 const char *ktname;
 387                 gss_OID_set_desc mech_set;
 388
 389                 ret = smb_krb5_keytab_name(gse_ctx, gse_ctx->k5ctx,
 390                                    gse_ctx->keytab, &ktname);
 391                 if (ret) {
 392                         status = NT_STATUS_INTERNAL_ERROR;
 393                         goto done;
 394                 }
 395
 396                 ret = gsskrb5_register_acceptor_identity(ktname);
 397                 if (ret) {
 398                         status = NT_STATUS_INTERNAL_ERROR;
 399                         goto done;
 400                 }
 401
 402                 mech_set.count = 1;
 403                 mech_set.elements = &gse_ctx->gss_mech;
 404
 405                 gss_maj = gss_acquire_cred(&gss_min,
 406                                    GSS_C_NO_NAME,
 407                                    GSS_C_INDEFINITE,
 408                                    &mech_set,
 409                                    GSS_C_ACCEPT,
 410                                    &gse_ctx->creds,
 411                                    NULL, NULL);
 412
 413                 if (gss_maj) {
 414                         DEBUG(0, ("gss_acquire_creds failed with [%s]\n",
 415                                   gse_errstr(gse_ctx, gss_maj, gss_min)));
 416                         status = NT_STATUS_INTERNAL_ERROR;
 417                         goto done;
 418                 }
 419         }
 420
 421         status = NT_STATUS_OK;
 422
 423 done:
 424         if (!NT_STATUS_IS_OK(status)) {
 425                 TALLOC_FREE(gse_ctx);
 426         }
 427
 428         *_gse_ctx = gse_ctx;
 429         return status;
 430 }
 431
 432 static NTSTATUS gse_get_server_auth_token(TALLOC_CTX *mem_ctx,
 433                                           struct gse_context *gse_ctx,
 434                                           const DATA_BLOB *token_in,
 435                                           DATA_BLOB *token_out)
 436 {
 437         OM_uint32 gss_maj, gss_min;
 438         gss_buffer_desc in_data;
 439         gss_buffer_desc out_data;
 440         DATA_BLOB blob = data_blob_null;
 441         NTSTATUS status;
 442
 443         in_data.value = token_in->data;
 444         in_data.length = token_in->length;
 445
 446         gss_maj = gss_accept_sec_context(&gss_min,
 447                                          &gse_ctx->gssapi_context,
 448                                          gse_ctx->creds,
 449                                          &in_data,
 450                                          GSS_C_NO_CHANNEL_BINDINGS,
 451                                          &gse_ctx->client_name,
 452                                          &gse_ctx->ret_mech,
 453                                          &out_data,
 454                                          &gse_ctx->gss_got_flags, NULL,
 455                                          &gse_ctx->delegated_cred_handle);
 456         switch (gss_maj) {
 457         case GSS_S_COMPLETE:
 458                 /* we are done with it */
 459                 status = NT_STATUS_OK;
 460                 break;
 461         case GSS_S_CONTINUE_NEEDED:
 462                 /* we will need a third leg */
 463                 status = NT_STATUS_MORE_PROCESSING_REQUIRED;
 464                 break;
 465         default:
 466                 DEBUG(1, ("gss_accept_sec_context failed with [%s]\n",
 467                           gse_errstr(talloc_tos(), gss_maj, gss_min)));
 468
 469                 if (gse_ctx->gssapi_context) {
 470                         gss_delete_sec_context(&gss_min,
 471                                                 &gse_ctx->gssapi_context,
 472                                                 GSS_C_NO_BUFFER);
 473                 }
 474
 475                 status = NT_STATUS_LOGON_FAILURE;
 476                 goto done;
 477         }
 478
 479         /* we may be told to return nothing */
 480         if (out_data.length) {
 481                 blob = data_blob_talloc(mem_ctx, out_data.value, out_data.length);
 482                 if (!blob.data) {
 483                         status = NT_STATUS_NO_MEMORY;
 484                 }
 485                 gss_maj = gss_release_buffer(&gss_min, &out_data);
 486         }
 487
 488
 489 done:
 490         *token_out = blob;
 491         return status;
 492 }
 493
 494 static char *gse_errstr(TALLOC_CTX *mem_ctx, OM_uint32 maj, OM_uint32 min)
 495 {
 496         OM_uint32 gss_min, gss_maj;
 497         gss_buffer_desc msg_min;
 498         gss_buffer_desc msg_maj;
 499         OM_uint32 msg_ctx = 0;
 500
 501         char *errstr = NULL;
 502
 503         ZERO_STRUCT(msg_min);
 504         ZERO_STRUCT(msg_maj);
 505
 506         gss_maj = gss_display_status(&gss_min, maj, GSS_C_GSS_CODE,
 507                                      GSS_C_NO_OID, &msg_ctx, &msg_maj);
 508         if (gss_maj) {
 509                 goto done;
 510         }
 511         errstr = talloc_strndup(mem_ctx,
 512                                 (char *)msg_maj.value,
 513                                         msg_maj.length);
 514         if (!errstr) {
 515                 goto done;
 516         }
 517         gss_maj = gss_display_status(&gss_min, min, GSS_C_MECH_CODE,
 518                                      (gss_OID)discard_const(gss_mech_krb5),
 519                                      &msg_ctx, &msg_min);
 520         if (gss_maj) {
 521                 goto done;
 522         }
 523
 524         errstr = talloc_strdup_append_buffer(errstr, ": ");
 525         if (!errstr) {
 526                 goto done;
 527         }
 528         errstr = talloc_strndup_append_buffer(errstr,
 529                                                 (char *)msg_min.value,
 530                                                         msg_min.length);
 531         if (!errstr) {
 532                 goto done;
 533         }
 534
 535 done:
 536         if (msg_min.value) {
 537                 gss_maj = gss_release_buffer(&gss_min, &msg_min);
 538         }
 539         if (msg_maj.value) {
 540                 gss_maj = gss_release_buffer(&gss_min, &msg_maj);
 541         }
 542         return errstr;
 543 }
 544
 545 static size_t gse_get_signature_length(struct gse_context *gse_ctx,
 546                                        bool seal, size_t payload_size)
 547 {
 548         OM_uint32 gss_min, gss_maj;
 549         gss_iov_buffer_desc iov[2];
 550         int sealed;
 551
 552         /*
 553          * gss_wrap_iov_length() only needs the type and length
 554          */
 555         iov[0].type = GSS_IOV_BUFFER_TYPE_HEADER;
 556         iov[0].buffer.value = NULL;
 557         iov[0].buffer.length = 0;
 558         iov[1].type = GSS_IOV_BUFFER_TYPE_DATA;
 559         iov[1].buffer.value = NULL;
 560         iov[1].buffer.length = payload_size;
 561
 562         gss_maj = gss_wrap_iov_length(&gss_min, gse_ctx->gssapi_context,
 563                                         seal, GSS_C_QOP_DEFAULT,
 564                                         &sealed, iov, 2);
 565         if (gss_maj) {
 566                 DEBUG(0, ("gss_wrap_iov_length failed with [%s]\n",
 567                           gse_errstr(talloc_tos(), gss_maj, gss_min)));
 568                 return 0;
 569         }
 570
 571         return iov[0].buffer.length;
 572 }
 573
 574 static NTSTATUS gse_seal(TALLOC_CTX *mem_ctx, struct gse_context *gse_ctx,
 575                          DATA_BLOB *data, DATA_BLOB *signature)
 576 {
 577         OM_uint32 gss_min, gss_maj;
 578         gss_iov_buffer_desc iov[2];
 579         int req_seal = 1; /* setting to 1 means we request sign+seal */
 580         int sealed = 1;
 581         NTSTATUS status;
 582
 583         /* allocate the memory ourselves so we do not need to talloc_memdup */
 584         signature->length = gse_get_signature_length(gse_ctx, true, data->length);
 585         if (!signature->length) {
 586                 return NT_STATUS_INTERNAL_ERROR;
 587         }
 588         signature->data = (uint8_t *)talloc_size(mem_ctx, signature->length);
 589         if (!signature->data) {
 590                 return NT_STATUS_NO_MEMORY;
 591         }
 592         iov[0].type = GSS_IOV_BUFFER_TYPE_HEADER;
 593         iov[0].buffer.value = signature->data;
 594         iov[0].buffer.length = signature->length;
 595
 596         /* data is encrypted in place, which is ok */
 597         iov[1].type = GSS_IOV_BUFFER_TYPE_DATA;
 598         iov[1].buffer.value = data->data;
 599         iov[1].buffer.length = data->length;
 600
 601         gss_maj = gss_wrap_iov(&gss_min, gse_ctx->gssapi_context,
 602                                 req_seal, GSS_C_QOP_DEFAULT,
 603                                 &sealed, iov, 2);
 604         if (gss_maj) {
 605                 DEBUG(0, ("gss_wrap_iov failed with [%s]\n",
 606                           gse_errstr(talloc_tos(), gss_maj, gss_min)));
 607                 status = NT_STATUS_ACCESS_DENIED;
 608                 goto done;
 609         }
 610
 611         if (!sealed) {
 612                 DEBUG(0, ("gss_wrap_iov says data was not sealed!\n"));
 613                 status = NT_STATUS_ACCESS_DENIED;
 614                 goto done;
 615         }
 616
 617         status = NT_STATUS_OK;
 618
 619         DEBUG(10, ("Sealed %d bytes, and got %d bytes header/signature.\n",
 620                    (int)iov[1].buffer.length, (int)iov[0].buffer.length));
 621
 622 done:
 623         return status;
 624 }
 625
 626 static NTSTATUS gse_unseal(TALLOC_CTX *mem_ctx, struct gse_context *gse_ctx,
 627                            DATA_BLOB *data, const DATA_BLOB *signature)
 628 {
 629         OM_uint32 gss_min, gss_maj;
 630         gss_iov_buffer_desc iov[2];
 631         int sealed;
 632         NTSTATUS status;
 633
 634         iov[0].type = GSS_IOV_BUFFER_TYPE_HEADER;
 635         iov[0].buffer.value = signature->data;
 636         iov[0].buffer.length = signature->length;
 637
 638         /* data is decrypted in place, which is ok */
 639         iov[1].type = GSS_IOV_BUFFER_TYPE_DATA;
 640         iov[1].buffer.value = data->data;
 641         iov[1].buffer.length = data->length;
 642
 643         gss_maj = gss_unwrap_iov(&gss_min, gse_ctx->gssapi_context,
 644                                  &sealed, NULL, iov, 2);
 645         if (gss_maj) {
 646                 DEBUG(0, ("gss_unwrap_iov failed with [%s]\n",
 647                           gse_errstr(talloc_tos(), gss_maj, gss_min)));
 648                 status = NT_STATUS_ACCESS_DENIED;
 649                 goto done;
 650         }
 651
 652         if (!sealed) {
 653                 DEBUG(0, ("gss_unwrap_iov says data is not sealed!\n"));
 654                 status = NT_STATUS_ACCESS_DENIED;
 655                 goto done;
 656         }
 657
 658         status = NT_STATUS_OK;
 659
 660         DEBUG(10, ("Unsealed %d bytes, with %d bytes header/signature.\n",
 661                    (int)iov[1].buffer.length, (int)iov[0].buffer.length));
 662
 663 done:
 664         return status;
 665 }
 666
 667 static NTSTATUS gse_sign(TALLOC_CTX *mem_ctx, struct gse_context *gse_ctx,
 668                          DATA_BLOB *data, DATA_BLOB *signature)
 669 {
 670         OM_uint32 gss_min, gss_maj;
 671         gss_buffer_desc in_data = { 0, NULL };
 672         gss_buffer_desc out_data = { 0, NULL};
 673         NTSTATUS status;
 674
 675         in_data.value = data->data;
 676         in_data.length = data->length;
 677
 678         gss_maj = gss_get_mic(&gss_min, gse_ctx->gssapi_context,
 679                               GSS_C_QOP_DEFAULT,
 680                               &in_data, &out_data);
 681         if (gss_maj) {
 682                 DEBUG(0, ("gss_get_mic failed with [%s]\n",
 683                           gse_errstr(talloc_tos(), gss_maj, gss_min)));
 684                 status = NT_STATUS_ACCESS_DENIED;
 685                 goto done;
 686         }
 687
 688         *signature = data_blob_talloc(mem_ctx,
 689                                         out_data.value, out_data.length);
 690         if (!signature->data) {
 691                 status = NT_STATUS_NO_MEMORY;
 692                 goto done;
 693         }
 694
 695         status = NT_STATUS_OK;
 696
 697 done:
 698         if (out_data.value) {
 699                 gss_maj = gss_release_buffer(&gss_min, &out_data);
 700         }
 701         return status;
 702 }
 703
 704 static NTSTATUS gse_sigcheck(TALLOC_CTX *mem_ctx, struct gse_context *gse_ctx,
 705                              const DATA_BLOB *data, const DATA_BLOB *signature)
 706 {
 707         OM_uint32 gss_min, gss_maj;
 708         gss_buffer_desc in_data = { 0, NULL };
 709         gss_buffer_desc in_token = { 0, NULL};
 710         NTSTATUS status;
 711
 712         in_data.value = data->data;
 713         in_data.length = data->length;
 714         in_token.value = signature->data;
 715         in_token.length = signature->length;
 716
 717         gss_maj = gss_verify_mic(&gss_min, gse_ctx->gssapi_context,
 718                                  &in_data, &in_token, NULL);
 719         if (gss_maj) {
 720                 DEBUG(0, ("gss_verify_mic failed with [%s]\n",
 721                           gse_errstr(talloc_tos(), gss_maj, gss_min)));
 722                 status = NT_STATUS_ACCESS_DENIED;
 723                 goto done;
 724         }
 725
 726         status = NT_STATUS_OK;
 727
 728 done:
 729         return status;
 730 }
 731
 732 static NTSTATUS gensec_gse_client_start(struct gensec_security *gensec_security)
 733 {
 734         struct gse_context *gse_ctx;
 735         struct cli_credentials *creds = gensec_get_credentials(gensec_security);
 736         NTSTATUS nt_status;
 737         OM_uint32 want_flags = 0;
 738         bool do_sign = false, do_seal = false;
 739         const char *hostname = gensec_get_target_hostname(gensec_security);
 740         const char *service = gensec_get_target_service(gensec_security);
 741         const char *username = cli_credentials_get_username(creds);
 742         const char *password = cli_credentials_get_password(creds);
 743
 744         if (!hostname) {
 745                 DEBUG(1, ("Could not determine hostname for target computer, cannot use kerberos\n"));
 746                 return NT_STATUS_INVALID_PARAMETER;
 747         }
 748         if (is_ipaddress(hostname)) {
 749                 DEBUG(2, ("Cannot do GSE to an IP address\n"));
 750                 return NT_STATUS_INVALID_PARAMETER;
 751         }
 752         if (strcmp(hostname, "localhost") == 0) {
 753                 DEBUG(2, ("GSE to 'localhost' does not make sense\n"));
 754                 return NT_STATUS_INVALID_PARAMETER;
 755         }
 756
 757         if (gensec_security->want_features & GENSEC_FEATURE_SIGN) {
 758                 do_sign = true;
 759         }
 760         if (gensec_security->want_features & GENSEC_FEATURE_SEAL) {
 761                 do_seal = true;
 762         }
 763         if (gensec_security->want_features & GENSEC_FEATURE_DCE_STYLE) {
 764                 want_flags |= GSS_C_DCE_STYLE;
 765         }
 766
 767         nt_status = gse_init_client(gensec_security, do_sign, do_seal, NULL,
 768                                     hostname, service,
 769                                     username, password, want_flags,
 770                                     &gse_ctx);
 771         if (!NT_STATUS_IS_OK(nt_status)) {
 772                 return nt_status;
 773         }
 774         gensec_security->private_data = gse_ctx;
 775         return NT_STATUS_OK;
 776 }
 777
 778 static NTSTATUS gensec_gse_server_start(struct gensec_security *gensec_security)
 779 {
 780         struct gse_context *gse_ctx;
 781         NTSTATUS nt_status;
 782         OM_uint32 want_flags = 0;
 783         bool do_sign = false, do_seal = false;
 784
 785         if (gensec_security->want_features & GENSEC_FEATURE_SIGN) {
 786                 do_sign = true;
 787         }
 788         if (gensec_security->want_features & GENSEC_FEATURE_SEAL) {
 789                 do_seal = true;
 790         }
 791         if (gensec_security->want_features & GENSEC_FEATURE_DCE_STYLE) {
 792                 want_flags |= GSS_C_DCE_STYLE;
 793         }
 794
 795         nt_status = gse_init_server(gensec_security, do_sign, do_seal, want_flags,
 796                                     &gse_ctx);
 797         if (!NT_STATUS_IS_OK(nt_status)) {
 798                 return nt_status;
 799         }
 800         gensec_security->private_data = gse_ctx;
 801         return NT_STATUS_OK;
 802 }
 803
 804 /**
 805  * Next state function for the GSE GENSEC mechanism
 806  *
 807  * @param gensec_gse_state GSE State
 808  * @param mem_ctx The TALLOC_CTX for *out to be allocated on
 809  * @param in The request, as a DATA_BLOB
 810  * @param out The reply, as an talloc()ed DATA_BLOB, on *mem_ctx
 811  * @return Error, MORE_PROCESSING_REQUIRED if a reply is sent,
 812  *                or NT_STATUS_OK if the user is authenticated.
 813  */
 814
 815 static NTSTATUS gensec_gse_update(struct gensec_security *gensec_security,
 816                                   TALLOC_CTX *mem_ctx,
 817                                   struct tevent_context *ev,
 818                                   const DATA_BLOB in, DATA_BLOB *out)
 819 {
 820         NTSTATUS status;
 821         struct gse_context *gse_ctx =
 822                 talloc_get_type_abort(gensec_security->private_data,
 823                 struct gse_context);
 824
 825         switch (gensec_security->gensec_role) {
 826         case GENSEC_CLIENT:
 827                 status = gse_get_client_auth_token(mem_ctx, gse_ctx,
 828                                                    &in, out);
 829                 break;
 830         case GENSEC_SERVER:
 831                 status = gse_get_server_auth_token(mem_ctx, gse_ctx,
 832                                                    &in, out);
 833                 break;
 834         }
 835         if (!NT_STATUS_IS_OK(status)) {
 836                 return status;
 837         }
 838
 839         return NT_STATUS_OK;
 840 }
 841
 842 static NTSTATUS gensec_gse_wrap(struct gensec_security *gensec_security,
 843                                 TALLOC_CTX *mem_ctx,
 844                                 const DATA_BLOB *in,
 845                                 DATA_BLOB *out)
 846 {
 847         struct gse_context *gse_ctx =
 848                 talloc_get_type_abort(gensec_security->private_data,
 849                 struct gse_context);
 850         OM_uint32 maj_stat, min_stat;
 851         gss_buffer_desc input_token, output_token;
 852         int conf_state;
 853         input_token.length = in->length;
 854         input_token.value = in->data;
 855
 856         maj_stat = gss_wrap(&min_stat,
 857                             gse_ctx->gssapi_context,
 858                             gensec_have_feature(gensec_security, GENSEC_FEATURE_SEAL),
 859                             GSS_C_QOP_DEFAULT,
 860                             &input_token,
 861                             &conf_state,
 862                             &output_token);
 863         if (GSS_ERROR(maj_stat)) {
 864                 DEBUG(0, ("gensec_gse_wrap: GSS Wrap failed: %s\n",
 865                           gse_errstr(talloc_tos(), maj_stat, min_stat)));
 866                 return NT_STATUS_ACCESS_DENIED;
 867         }
 868
 869         *out = data_blob_talloc(mem_ctx, output_token.value, output_token.length);
 870         gss_release_buffer(&min_stat, &output_token);
 871
 872         if (gensec_have_feature(gensec_security, GENSEC_FEATURE_SEAL)
 873             && !conf_state) {
 874                 return NT_STATUS_ACCESS_DENIED;
 875         }
 876         return NT_STATUS_OK;
 877 }
 878
 879 static NTSTATUS gensec_gse_unwrap(struct gensec_security *gensec_security,
 880                                      TALLOC_CTX *mem_ctx,
 881                                      const DATA_BLOB *in,
 882                                      DATA_BLOB *out)
 883 {
 884         struct gse_context *gse_ctx =
 885                 talloc_get_type_abort(gensec_security->private_data,
 886                 struct gse_context);
 887         OM_uint32 maj_stat, min_stat;
 888         gss_buffer_desc input_token, output_token;
 889         int conf_state;
 890         gss_qop_t qop_state;
 891         input_token.length = in->length;
 892         input_token.value = in->data;
 893
 894         maj_stat = gss_unwrap(&min_stat,
 895                               gse_ctx->gssapi_context,
 896                               &input_token,
 897                               &output_token,
 898                               &conf_state,
 899                               &qop_state);
 900         if (GSS_ERROR(maj_stat)) {
 901                 DEBUG(0, ("gensec_gse_unwrap: GSS UnWrap failed: %s\n",
 902                           gse_errstr(talloc_tos(), maj_stat, min_stat)));
 903                 return NT_STATUS_ACCESS_DENIED;
 904         }
 905
 906         *out = data_blob_talloc(mem_ctx, output_token.value, output_token.length);
 907         gss_release_buffer(&min_stat, &output_token);
 908
 909         if (gensec_have_feature(gensec_security, GENSEC_FEATURE_SEAL)
 910             && !conf_state) {
 911                 return NT_STATUS_ACCESS_DENIED;
 912         }
 913         return NT_STATUS_OK;
 914 }
 915
 916 static NTSTATUS gensec_gse_seal_packet(struct gensec_security *gensec_security,
 917                                        TALLOC_CTX *mem_ctx,
 918                                        uint8_t *data, size_t length,
 919                                        const uint8_t *whole_pdu, size_t pdu_length,
 920                                        DATA_BLOB *sig)
 921 {
 922         struct gse_context *gse_ctx =
 923                 talloc_get_type_abort(gensec_security->private_data,
 924                 struct gse_context);
 925         DATA_BLOB payload = data_blob_const(data, length);
 926         return gse_seal(mem_ctx, gse_ctx, &payload, sig);
 927 }
 928
 929 static NTSTATUS gensec_gse_unseal_packet(struct gensec_security *gensec_security,
 930                                          uint8_t *data, size_t length,
 931                                          const uint8_t *whole_pdu, size_t pdu_length,
 932                                          const DATA_BLOB *sig)
 933 {
 934         struct gse_context *gse_ctx =
 935                 talloc_get_type_abort(gensec_security->private_data,
 936                 struct gse_context);
 937         DATA_BLOB payload = data_blob_const(data, length);
 938         return gse_unseal(talloc_tos() /* unused */, gse_ctx, &payload, sig);
 939 }
 940
 941 static NTSTATUS gensec_gse_sign_packet(struct gensec_security *gensec_security,
 942                                        TALLOC_CTX *mem_ctx,
 943                                        const uint8_t *data, size_t length,
 944                                        const uint8_t *whole_pdu, size_t pdu_length,
 945                                        DATA_BLOB *sig)
 946 {
 947         struct gse_context *gse_ctx =
 948                 talloc_get_type_abort(gensec_security->private_data,
 949                 struct gse_context);
 950         DATA_BLOB payload = data_blob_const(data, length);
 951         return gse_sign(mem_ctx, gse_ctx, &payload, sig);
 952 }
 953
 954 static NTSTATUS gensec_gse_check_packet(struct gensec_security *gensec_security,
 955                                         const uint8_t *data, size_t length,
 956                                         const uint8_t *whole_pdu, size_t pdu_length,
 957                                         const DATA_BLOB *sig)
 958 {
 959         struct gse_context *gse_ctx =
 960                 talloc_get_type_abort(gensec_security->private_data,
 961                 struct gse_context);
 962         DATA_BLOB payload = data_blob_const(data, length);
 963         return gse_sigcheck(NULL, gse_ctx, &payload, sig);
 964 }
 965
 966 /* Try to figure out what features we actually got on the connection */
 967 static bool gensec_gse_have_feature(struct gensec_security *gensec_security,
 968                                     uint32_t feature)
 969 {
 970         struct gse_context *gse_ctx =
 971                 talloc_get_type_abort(gensec_security->private_data,
 972                 struct gse_context);
 973
 974         if (feature & GENSEC_FEATURE_SIGN) {
 975                 return gse_ctx->gss_got_flags & GSS_C_INTEG_FLAG;
 976         }
 977         if (feature & GENSEC_FEATURE_SEAL) {
 978                 return gse_ctx->gss_got_flags & GSS_C_CONF_FLAG;
 979         }
 980         if (feature & GENSEC_FEATURE_SESSION_KEY) {
 981                 /* Only for GSE/Krb5 */
 982                 if (gss_oid_equal(gse_ctx->ret_mech, gss_mech_krb5)) {
 983                         return true;
 984                 }
 985         }
 986         if (feature & GENSEC_FEATURE_DCE_STYLE) {
 987                 return gse_ctx->gss_got_flags & GSS_C_DCE_STYLE;
 988         }
 989         if (feature & GENSEC_FEATURE_NEW_SPNEGO) {
 990                 NTSTATUS status;
 991                 uint32_t keytype;
 992
 993                 if (!(gse_ctx->gss_got_flags & GSS_C_INTEG_FLAG)) {
 994                         return false;
 995                 }
 996
 997                 status = gssapi_get_session_key(talloc_tos(),
 998                                                 gse_ctx->gssapi_context, NULL, &keytype);
 999                 /*
1000                  * We should do a proper sig on the mechListMic unless
1001                  * we know we have to be backwards compatible with
1002                  * earlier windows versions.
1003                  *
1004                  * Negotiating a non-krb5
1005                  * mech for example should be regarded as having
1006                  * NEW_SPNEGO
1007                  */
1008                 if (NT_STATUS_IS_OK(status)) {
1009                         switch (keytype) {
1010                         case ENCTYPE_DES_CBC_CRC:
1011                         case ENCTYPE_DES_CBC_MD5:
1012                         case ENCTYPE_ARCFOUR_HMAC:
1013                         case ENCTYPE_DES3_CBC_SHA1:
1014                                 return false;
1015                         }
1016                 }
1017                 return true;
1018         }
1019         /* We can always do async (rather than strict request/reply) packets.  */
1020         if (feature & GENSEC_FEATURE_ASYNC_REPLIES) {
1021                 return true;
1022         }
1023         return false;
1024 }
1025
1026 /*
1027  * Extract the 'sesssion key' needed by SMB signing and ncacn_np
1028  * (for encrypting some passwords).
1029  *
1030  * This breaks all the abstractions, but what do you expect...
1031  */
1032 static NTSTATUS gensec_gse_session_key(struct gensec_security *gensec_security,
1033                                        TALLOC_CTX *mem_ctx,
1034                                        DATA_BLOB *session_key)
1035 {
1036         struct gse_context *gse_ctx =
1037                 talloc_get_type_abort(gensec_security->private_data,
1038                 struct gse_context);
1039
1040         return gssapi_get_session_key(mem_ctx, gse_ctx->gssapi_context, session_key, NULL);
1041 }
1042
1043 /* Get some basic (and authorization) information about the user on
1044  * this session.  This uses either the PAC (if present) or a local
1045  * database lookup */
1046 static NTSTATUS gensec_gse_session_info(struct gensec_security *gensec_security,
1047                                         TALLOC_CTX *mem_ctx,
1048                                         struct auth_session_info **_session_info)
1049 {
1050         struct gse_context *gse_ctx =
1051                 talloc_get_type_abort(gensec_security->private_data,
1052                 struct gse_context);
1053         NTSTATUS nt_status;
1054         TALLOC_CTX *tmp_ctx;
1055         struct auth_session_info *session_info = NULL;
1056         OM_uint32 maj_stat, min_stat;
1057         DATA_BLOB pac_blob, *pac_blob_ptr = NULL;
1058
1059         gss_buffer_desc name_token;
1060         char *principal_string;
1061
1062         tmp_ctx = talloc_named(mem_ctx, 0, "gensec_gse_session_info context");
1063         NT_STATUS_HAVE_NO_MEMORY(tmp_ctx);
1064
1065         maj_stat = gss_display_name(&min_stat,
1066                                     gse_ctx->client_name,
1067                                     &name_token,
1068                                     NULL);
1069         if (GSS_ERROR(maj_stat)) {
1070                 DEBUG(1, ("GSS display_name failed: %s\n",
1071                           gse_errstr(talloc_tos(), maj_stat, min_stat)));
1072                 talloc_free(tmp_ctx);
1073                 return NT_STATUS_FOOBAR;
1074         }
1075
1076         principal_string = talloc_strndup(tmp_ctx,
1077                                           (const char *)name_token.value,
1078                                           name_token.length);
1079
1080         gss_release_buffer(&min_stat, &name_token);
1081
1082         if (!principal_string) {
1083                 talloc_free(tmp_ctx);
1084                 return NT_STATUS_NO_MEMORY;
1085         }
1086
1087         nt_status = gssapi_obtain_pac_blob(tmp_ctx,  gse_ctx->gssapi_context,
1088                                            gse_ctx->client_name,
1089                                            &pac_blob);
1090
1091         /* IF we have the PAC - otherwise we need to get this
1092          * data from elsewere
1093          */
1094         if (NT_STATUS_IS_OK(nt_status)) {
1095                 pac_blob_ptr = &pac_blob;
1096         }
1097         nt_status = gensec_generate_session_info_pac(tmp_ctx,
1098                                                      gensec_security,
1099                                                      NULL,
1100                                                      pac_blob_ptr, principal_string,
1101                                                      gensec_get_remote_address(gensec_security),
1102                                                      &session_info);
1103         if (!NT_STATUS_IS_OK(nt_status)) {
1104                 talloc_free(tmp_ctx);
1105                 return nt_status;
1106         }
1107
1108         nt_status = gensec_gse_session_key(gensec_security, session_info,
1109                                            &session_info->session_key);
1110         if (!NT_STATUS_IS_OK(nt_status)) {
1111                 talloc_free(tmp_ctx);
1112                 return nt_status;
1113         }
1114
1115         *_session_info = talloc_move(mem_ctx, &session_info);
1116         talloc_free(tmp_ctx);
1117
1118         return NT_STATUS_OK;
1119 }
1120
1121 static size_t gensec_gse_sig_size(struct gensec_security *gensec_security,
1122                                   size_t data_size)
1123 {
1124         struct gse_context *gse_ctx =
1125                 talloc_get_type_abort(gensec_security->private_data,
1126                 struct gse_context);
1127
1128         return gse_get_signature_length(gse_ctx,
1129                                         gensec_security->want_features & GENSEC_FEATURE_SEAL,
1130                                         data_size);
1131 }
1132
1133 static const char *gensec_gse_krb5_oids[] = {
1134         GENSEC_OID_KERBEROS5_OLD,
1135         GENSEC_OID_KERBEROS5,
1136         NULL
1137 };
1138
1139 const struct gensec_security_ops gensec_gse_krb5_security_ops = {
1140         .name           = "gse_krb5",
1141         .auth_type      = DCERPC_AUTH_TYPE_KRB5,
1142         .oid            = gensec_gse_krb5_oids,
1143         .client_start   = gensec_gse_client_start,
1144         .server_start   = gensec_gse_server_start,
1145         .magic          = gensec_magic_check_krb5_oid,
1146         .update         = gensec_gse_update,
1147         .session_key    = gensec_gse_session_key,
1148         .session_info   = gensec_gse_session_info,
1149         .sig_size       = gensec_gse_sig_size,
1150         .sign_packet    = gensec_gse_sign_packet,
1151         .check_packet   = gensec_gse_check_packet,
1152         .seal_packet    = gensec_gse_seal_packet,
1153         .unseal_packet  = gensec_gse_unseal_packet,
1154         .wrap           = gensec_gse_wrap,
1155         .unwrap         = gensec_gse_unwrap,
1156         .have_feature   = gensec_gse_have_feature,
1157         .enabled        = true,
1158         .kerberos       = true,
1159         .priority       = GENSEC_GSSAPI
1160 };
1161
1162 #endif /* HAVE_KRB5 */