src/mod_auth_gssapi.c

   1 /*
   2    MOD AUTH GSSAPI
   3
   4    Copyright (C) 2014 Simo Sorce <simo@redhat.com>
   5
   6    Permission is hereby granted, free of charge, to any person obtaining a
   7    copy of this software and associated documentation files (the "Software"),
   8    to deal in the Software without restriction, including without limitation
   9    the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10    and/or sell copies of the Software, and to permit persons to whom the
  11    Software is furnished to do so, subject to the following conditions:
  12
  13    The above copyright notice and this permission notice shall be included in
  14    all copies or substantial portions of the Software.
  15
  16    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22    DEALINGS IN THE SOFTWARE.
  23 */
  24
  25 #include "mod_auth_gssapi.h"
  26
  27 const gss_OID_desc gss_mech_ntlmssp = {
  28     GSS_NTLMSSP_OID_LENGTH, GSS_NTLMSSP_OID_STRING
  29 };
  30
  31 const gss_OID_set_desc gss_mech_set_ntlmssp = {
  32     1, discard_const(&gss_mech_ntlmssp)
  33 };
  34
  35 #define MOD_AUTH_GSSAPI_VERSION PACKAGE_NAME "/" PACKAGE_VERSION
  36
  37 module AP_MODULE_DECLARE_DATA auth_gssapi_module;
  38
  39 APLOG_USE_MODULE(auth_gssapi);
  40
  41 static char *mag_status(request_rec *req, int type, uint32_t err)
  42 {
  43     uint32_t maj_ret, min_ret;
  44     gss_buffer_desc text;
  45     uint32_t msg_ctx;
  46     char *msg_ret;
  47     int len;
  48
  49     msg_ret = NULL;
  50     msg_ctx = 0;
  51     do {
  52         maj_ret = gss_display_status(&min_ret, err, type,
  53                                      GSS_C_NO_OID, &msg_ctx, &text);
  54         if (maj_ret != GSS_S_COMPLETE) {
  55             return msg_ret;
  56         }
  57
  58         len = text.length;
  59         if (msg_ret) {
  60             msg_ret = apr_psprintf(req->pool, "%s, %*s",
  61                                    msg_ret, len, (char *)text.value);
  62         } else {
  63             msg_ret = apr_psprintf(req->pool, "%*s", len, (char *)text.value);
  64         }
  65         gss_release_buffer(&min_ret, &text);
  66     } while (msg_ctx != 0);
  67
  68     return msg_ret;
  69 }
  70
  71 static char *mag_error(request_rec *req, const char *msg,
  72                        uint32_t maj, uint32_t min)
  73 {
  74     char *msg_maj;
  75     char *msg_min;
  76
  77     msg_maj = mag_status(req, GSS_C_GSS_CODE, maj);
  78     msg_min = mag_status(req, GSS_C_MECH_CODE, min);
  79     return apr_psprintf(req->pool, "%s: [%s (%s)]", msg, msg_maj, msg_min);
  80 }
  81
  82 static APR_OPTIONAL_FN_TYPE(ssl_is_https) *mag_is_https = NULL;
  83
  84 static int mag_post_config(apr_pool_t *cfgpool, apr_pool_t *log,
  85                            apr_pool_t *temp, server_rec *s)
  86 {
  87     /* FIXME: create mutex to deal with connections and contexts ? */
  88     mag_is_https = APR_RETRIEVE_OPTIONAL_FN(ssl_is_https);
  89     mag_post_config_session();
  90     ap_add_version_component(cfgpool, MOD_AUTH_GSSAPI_VERSION);
  91
  92     return OK;
  93 }
  94
  95 static int mag_pre_connection(conn_rec *c, void *csd)
  96 {
  97     struct mag_conn *mc;
  98
  99     mc = mag_new_conn_ctx(c->pool);
 100     ap_set_module_config(c->conn_config, &auth_gssapi_module, (void*)mc);
 101     return OK;
 102 }
 103
 104 static apr_status_t mag_conn_destroy(void *ptr)
 105 {
 106     struct mag_conn *mc = (struct mag_conn *)ptr;
 107     uint32_t min;
 108
 109     if (mc->ctx) {
 110         (void)gss_delete_sec_context(&min, &mc->ctx, GSS_C_NO_BUFFER);
 111     }
 112     return APR_SUCCESS;
 113 }
 114
 115 struct mag_conn *mag_new_conn_ctx(apr_pool_t *pool)
 116 {
 117     struct mag_conn *mc;
 118
 119     mc = apr_pcalloc(pool, sizeof(struct mag_conn));
 120     apr_pool_create(&mc->pool, pool);
 121     /* register the context in the memory pool, so it can be freed
 122      * when the connection/request is terminated */
 123     apr_pool_cleanup_register(mc->pool, (void *)mc,
 124                               mag_conn_destroy, apr_pool_cleanup_null);
 125
 126     return mc;
 127 }
 128
 129 static void mag_conn_clear(struct mag_conn *mc)
 130 {
 131     (void)mag_conn_destroy(mc);
 132     apr_pool_t *temp;
 133
 134     apr_pool_clear(mc->pool);
 135     temp = mc->pool;
 136     memset(mc, 0, sizeof(struct mag_conn));
 137     mc->pool = temp;
 138 }
 139
 140 static bool mag_conn_is_https(conn_rec *c)
 141 {
 142     if (mag_is_https) {
 143         if (mag_is_https(c)) return true;
 144     }
 145
 146     return false;
 147 }
 148
 149 static bool mag_acquire_creds(request_rec *req,
 150                               struct mag_config *cfg,
 151                               gss_OID_set desired_mechs,
 152                               gss_cred_usage_t cred_usage,
 153                               gss_cred_id_t *creds,
 154                               gss_OID_set *actual_mechs)
 155 {
 156     uint32_t maj, min;
 157 #ifdef HAVE_CRED_STORE
 158     gss_const_key_value_set_t store = cfg->cred_store;
 159
 160     maj = gss_acquire_cred_from(&min, GSS_C_NO_NAME, GSS_C_INDEFINITE,
 161                                 desired_mechs, cred_usage, store, creds,
 162                                 actual_mechs, NULL);
 163 #else
 164     maj = gss_acquire_cred(&min, GSS_C_NO_NAME, GSS_C_INDEFINITE,
 165                            desired_mechs, cred_usage, creds,
 166                            actual_mechs, NULL);
 167 #endif
 168
 169     if (GSS_ERROR(maj)) {
 170         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req, "%s",
 171                       mag_error(req, "gss_acquire_cred[_from]() "
 172                                 "failed to get server creds",
 173                                 maj, min));
 174         return false;
 175     }
 176
 177     return true;
 178 }
 179
 180 #ifdef HAVE_CRED_STORE
 181 static char *escape(apr_pool_t *pool, const char *name,
 182                     char find, const char *replace)
 183 {
 184     char *escaped = NULL;
 185     char *namecopy;
 186     char *n;
 187     char *p;
 188
 189     namecopy = apr_pstrdup(pool, name);
 190
 191     p = strchr(namecopy, find);
 192     if (!p) return namecopy;
 193
 194     /* first segment */
 195     n = namecopy;
 196     while (p) {
 197         /* terminate previous segment */
 198         *p = '\0';
 199         if (escaped) {
 200             escaped = apr_pstrcat(pool, escaped, n, replace, NULL);
 201         } else {
 202             escaped = apr_pstrcat(pool, n, replace, NULL);
 203         }
 204         /* move to next segment */
 205         n = p + 1;
 206         p = strchr(n, find);
 207     }
 208     /* append last segment if any */
 209     if (*n) {
 210         escaped = apr_pstrcat(pool, escaped, n, NULL);
 211     }
 212
 213     return escaped;
 214 }
 215
 216 static char *mag_gss_name_to_ccache_name(request_rec *req,
 217                                          char *dir, const char *gss_name)
 218 {
 219     char *escaped;
 220
 221     /* We need to escape away '/', we can't have path separators in
 222      * a ccache file name */
 223     /* first double escape the esacping char (~) if any */
 224     escaped = escape(req->pool, gss_name, '~', "~~");
 225     /* then escape away the separator (/) if any */
 226     escaped = escape(req->pool, escaped, '/', "~");
 227
 228     return apr_psprintf(req->pool, "%s/%s", dir, escaped);
 229 }
 230
 231 static void mag_set_KRB5CCANME(request_rec *req, char *ccname)
 232 {
 233     apr_status_t status;
 234     apr_finfo_t finfo;
 235     char *value;
 236
 237     status = apr_stat(&finfo, ccname, APR_FINFO_MIN, req->pool);
 238     if (status != APR_SUCCESS && status != APR_INCOMPLETE) {
 239         /* set the file cache anyway, but warn */
 240         ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, req,
 241                       "KRB5CCNAME file (%s) lookup failed!", ccname);
 242     }
 243
 244     value = apr_psprintf(req->pool, "FILE:%s", ccname);
 245     apr_table_set(req->subprocess_env, "KRB5CCNAME", value);
 246 }
 247
 248 static void mag_store_deleg_creds(request_rec *req,
 249                                   char *dir, char *clientname,
 250                                   gss_cred_id_t delegated_cred,
 251                                   char **ccachefile)
 252 {
 253     gss_key_value_element_desc element;
 254     gss_key_value_set_desc store;
 255     char *ccname;
 256     uint32_t maj, min;
 257     element.key = "ccache";
 258     store.elements = &element;
 259     store.count = 1;
 260
 261     ccname = mag_gss_name_to_ccache_name(req, dir, clientname);
 262     element.value = apr_psprintf(req->pool, "FILE:%s", ccname);
 263
 264     maj = gss_store_cred_into(&min, delegated_cred, GSS_C_INITIATE,
 265                               GSS_C_NULL_OID, 1, 1, &store, NULL, NULL);
 266     if (GSS_ERROR(maj)) {
 267         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req, "%s",
 268                       mag_error(req, "failed to store delegated creds",
 269                                 maj, min));
 270     }
 271
 272     *ccachefile = ccname;
 273 }
 274 #endif
 275
 276 static bool parse_auth_header(apr_pool_t *pool, const char **auth_header,
 277                               gss_buffer_t value)
 278 {
 279     char *auth_header_value;
 280
 281     auth_header_value = ap_getword_white(pool, auth_header);
 282     if (!auth_header_value) return false;
 283     value->length = apr_base64_decode_len(auth_header_value) + 1;
 284     value->value = apr_pcalloc(pool, value->length);
 285     if (!value->value) return false;
 286     value->length = apr_base64_decode(value->value, auth_header_value);
 287
 288     return true;
 289 }
 290
 291 static bool is_mech_allowed(struct mag_config *cfg, gss_const_OID mech)
 292 {
 293     if (cfg->allowed_mechs == GSS_C_NO_OID_SET) return true;
 294
 295     for (int i = 0; i < cfg->allowed_mechs->count; i++) {
 296         if (gss_oid_equal(&cfg->allowed_mechs->elements[i], mech)) {
 297             return true;
 298         }
 299     }
 300     return false;
 301 }
 302
 303 #define AUTH_TYPE_NEGOTIATE 0
 304 #define AUTH_TYPE_BASIC 1
 305 #define AUTH_TYPE_RAW_NTLM 2
 306 const char *auth_types[] = {
 307     "Negotiate",
 308     "Basic",
 309     "NTLM",
 310     NULL
 311 };
 312
 313 static void mag_set_req_data(request_rec *req,
 314                              struct mag_config *cfg,
 315                              struct mag_conn *mc)
 316 {
 317     apr_table_set(req->subprocess_env, "GSS_NAME", mc->gss_name);
 318     apr_table_set(req->subprocess_env, "GSS_SESSION_EXPIRATION",
 319                   apr_psprintf(req->pool,
 320                                "%ld", (long)mc->expiration));
 321     req->ap_auth_type = apr_pstrdup(req->pool,
 322                                     auth_types[mc->auth_type]);
 323     req->user = apr_pstrdup(req->pool, mc->user_name);
 324     if (cfg->deleg_ccache_dir && mc->delegated) {
 325         char *ccname;
 326         ccname = mag_gss_name_to_ccache_name(req,
 327                                              cfg->deleg_ccache_dir,
 328                                              mc->gss_name);
 329         if (ccname) {
 330             mag_set_KRB5CCANME(req, ccname);
 331         }
 332     }
 333 }
 334
 335 static int mag_auth(request_rec *req)
 336 {
 337     const char *type;
 338     int auth_type = -1;
 339     struct mag_config *cfg;
 340     const char *auth_header;
 341     char *auth_header_type;
 342     int ret = HTTP_UNAUTHORIZED;
 343     gss_ctx_id_t ctx = GSS_C_NO_CONTEXT;
 344     gss_ctx_id_t *pctx;
 345     gss_buffer_desc input = GSS_C_EMPTY_BUFFER;
 346     gss_buffer_desc output = GSS_C_EMPTY_BUFFER;
 347     gss_buffer_desc name = GSS_C_EMPTY_BUFFER;
 348     gss_buffer_desc ba_user;
 349     gss_buffer_desc ba_pwd;
 350     gss_name_t client = GSS_C_NO_NAME;
 351     gss_cred_id_t user_cred = GSS_C_NO_CREDENTIAL;
 352     gss_cred_id_t acquired_cred = GSS_C_NO_CREDENTIAL;
 353     gss_cred_id_t server_cred = GSS_C_NO_CREDENTIAL;
 354     gss_cred_id_t delegated_cred = GSS_C_NO_CREDENTIAL;
 355     gss_cred_usage_t cred_usage = GSS_C_ACCEPT;
 356     uint32_t flags;
 357     uint32_t vtime;
 358     uint32_t maj, min;
 359     char *reply;
 360     size_t replen;
 361     char *clientname;
 362     gss_OID mech_type = GSS_C_NO_OID;
 363     gss_OID_set desired_mechs = GSS_C_NO_OID_SET;
 364     gss_buffer_desc lname = GSS_C_EMPTY_BUFFER;
 365     struct mag_conn *mc = NULL;
 366     gss_ctx_id_t user_ctx = GSS_C_NO_CONTEXT;
 367     gss_name_t server = GSS_C_NO_NAME;
 368 #ifdef HAVE_GSS_KRB5_CCACHE_NAME
 369     const char *user_ccache = NULL;
 370     const char *orig_ccache = NULL;
 371 #endif
 372     uint32_t init_flags = 0;
 373     time_t expiration;
 374     int i;
 375
 376     type = ap_auth_type(req);
 377     if ((type == NULL) || (strcasecmp(type, "GSSAPI") != 0)) {
 378         return DECLINED;
 379     }
 380
 381     cfg = ap_get_module_config(req->per_dir_config, &auth_gssapi_module);
 382
 383     if (!cfg->allowed_mechs) {
 384         /* Try to fetch the default set if not explicitly configured */
 385         (void)mag_acquire_creds(req, cfg, GSS_C_NO_OID_SET, GSS_C_ACCEPT,
 386                                 &server_cred, &cfg->allowed_mechs);
 387         (void)gss_release_cred(&min, &server_cred);
 388     }
 389
 390     /* implicit auth for subrequests if main auth already happened */
 391     if (!ap_is_initial_req(req) && req->main != NULL) {
 392         type = ap_auth_type(req->main);
 393         if ((type != NULL) && (strcasecmp(type, "GSSAPI") == 0)) {
 394             /* warn if the subrequest location and the main request
 395              * location have different configs */
 396             if (cfg != ap_get_module_config(req->main->per_dir_config,
 397                                             &auth_gssapi_module)) {
 398                 ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0,
 399                               req, "Subrequest authentication bypass on "
 400                                    "location with different configuration!");
 401             }
 402             if (req->main->user) {
 403                 req->user = apr_pstrdup(req->pool, req->main->user);
 404                 return OK;
 405             } else {
 406                 ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 407                               "The main request is tasked to establish the "
 408                               "security context, can't proceed!");
 409                 return HTTP_UNAUTHORIZED;
 410             }
 411         } else {
 412             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, req,
 413                           "Subrequest GSSAPI auth with no auth on the main "
 414                           "request. This operation may fail if other "
 415                           "subrequests already established a context or the "
 416                           "mechanism requires multiple roundtrips.");
 417         }
 418     }
 419
 420     if (cfg->ssl_only) {
 421         if (!mag_conn_is_https(req->connection)) {
 422             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 423                           "Not a TLS connection, refusing to authenticate!");
 424             goto done;
 425         }
 426     }
 427
 428     if (cfg->gss_conn_ctx) {
 429         mc = (struct mag_conn *)ap_get_module_config(
 430                                                 req->connection->conn_config,
 431                                                 &auth_gssapi_module);
 432         if (!mc) {
 433             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, req,
 434                           "Failed to retrieve connection context!");
 435             goto done;
 436         }
 437     }
 438
 439     /* if available, session always supersedes connection bound data */
 440     if (cfg->use_sessions) {
 441         mag_check_session(req, cfg, &mc);
 442     }
 443
 444     auth_header = apr_table_get(req->headers_in, "Authorization");
 445
 446     if (mc) {
 447         if (mc->established && !auth_header) {
 448             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, req,
 449                           "Already established context found!");
 450             mag_set_req_data(req, cfg, mc);
 451             ret = OK;
 452             goto done;
 453         }
 454         pctx = &mc->ctx;
 455     } else {
 456         pctx = &ctx;
 457     }
 458
 459     /* We can proceed only if we do have an auth header */
 460     if (!auth_header) goto done;
 461
 462     auth_header_type = ap_getword_white(req->pool, &auth_header);
 463     if (!auth_header_type) goto done;
 464
 465     for (i = 0; auth_types[i] != NULL; i++) {
 466         if (strcasecmp(auth_header_type, auth_types[i]) == 0) {
 467             auth_type = i;
 468             break;
 469         }
 470     }
 471
 472     switch (auth_type) {
 473     case AUTH_TYPE_NEGOTIATE:
 474         if (!parse_auth_header(req->pool, &auth_header, &input)) {
 475             goto done;
 476         }
 477         break;
 478     case AUTH_TYPE_BASIC:
 479         if (!cfg->use_basic_auth) {
 480             goto done;
 481         }
 482
 483         ba_pwd.value = ap_pbase64decode(req->pool, auth_header);
 484         if (!ba_pwd.value) goto done;
 485         ba_user.value = ap_getword_nulls_nc(req->pool,
 486                                             (char **)&ba_pwd.value, ':');
 487         if (!ba_user.value) goto done;
 488         if (((char *)ba_user.value)[0] == '\0' ||
 489             ((char *)ba_pwd.value)[0] == '\0') {
 490             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 491                           "Invalid empty user or password for Basic Auth");
 492             goto done;
 493         }
 494         ba_user.length = strlen(ba_user.value);
 495         ba_pwd.length = strlen(ba_pwd.value);
 496
 497         if (mc && mc->established &&
 498             mag_basic_check(cfg, mc, ba_user, ba_pwd)) {
 499             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, req,
 500                           "Already established BASIC AUTH context found!");
 501             mag_set_req_data(req, cfg, mc);
 502             ret = OK;
 503             goto done;
 504         }
 505
 506         break;
 507
 508     case AUTH_TYPE_RAW_NTLM:
 509         if (!is_mech_allowed(cfg, &gss_mech_ntlmssp)) {
 510             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, req,
 511                           "NTLM Authentication is not allowed!");
 512             goto done;
 513         }
 514
 515         if (!parse_auth_header(req->pool, &auth_header, &input)) {
 516             goto done;
 517         }
 518
 519         desired_mechs = discard_const(&gss_mech_set_ntlmssp);
 520         break;
 521
 522     default:
 523         goto done;
 524     }
 525
 526     if (mc && mc->established) {
 527         /* if we are re-authenticating make sure the conn context
 528          * is cleaned up so we do not accidentally reuse an existing
 529          * established context */
 530         mag_conn_clear(mc);
 531     }
 532
 533     req->ap_auth_type = apr_pstrdup(req->pool, auth_types[auth_type]);
 534
 535 #ifdef HAVE_CRED_STORE
 536     if (cfg->use_s4u2proxy) {
 537         cred_usage = GSS_C_BOTH;
 538     }
 539 #endif
 540     if (!mag_acquire_creds(req, cfg, desired_mechs,
 541                            cred_usage, &acquired_cred, NULL)) {
 542         goto done;
 543     }
 544
 545     if (auth_type == AUTH_TYPE_BASIC) {
 546         maj = gss_import_name(&min, &ba_user, GSS_C_NT_USER_NAME, &client);
 547         if (GSS_ERROR(maj)) {
 548             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 549                           "In Basic Auth, %s",
 550                           mag_error(req, "gss_import_name() failed",
 551                                     maj, min));
 552             goto done;
 553         }
 554 #ifdef HAVE_GSS_KRB5_CCACHE_NAME
 555         /* Set a per-thread ccache in case we are using kerberos,
 556          * it is not elegant but avoids interference between threads */
 557         long long unsigned int rndname;
 558         apr_status_t rs;
 559         rs = apr_generate_random_bytes((unsigned char *)(&rndname),
 560                                        sizeof(long long unsigned int));
 561         if (rs != APR_SUCCESS) {
 562             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 563                           "Failed to generate random ccache name");
 564             goto done;
 565         }
 566         user_ccache = apr_psprintf(req->pool, "MEMORY:user_%qu", rndname);
 567         maj = gss_krb5_ccache_name(&min, user_ccache, &orig_ccache);
 568         if (GSS_ERROR(maj)) {
 569             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 570                           "In Basic Auth, %s",
 571                           mag_error(req, "gss_krb5_ccache_name() "
 572                                     "failed", maj, min));
 573             goto done;
 574         }
 575 #endif
 576         maj = gss_acquire_cred_with_password(&min, client, &ba_pwd,
 577                                              GSS_C_INDEFINITE,
 578                                              cfg->allowed_mechs,
 579                                              GSS_C_INITIATE,
 580                                              &user_cred, NULL, NULL);
 581         if (GSS_ERROR(maj)) {
 582             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 583                           "In Basic Auth, %s",
 584                           mag_error(req, "gss_acquire_cred_with_password() "
 585                                     "failed", maj, min));
 586             goto done;
 587         }
 588         gss_release_name(&min, &client);
 589
 590         if (cred_usage == GSS_C_BOTH) {
 591             /* If GSS_C_BOTH is used then inquire_cred will return the client
 592              * name instead of the SPN of the server credentials. Therefore we
 593              * need to acquire a different set of credential setting
 594              * GSS_C_ACCEPT explicitly */
 595             if (!mag_acquire_creds(req, cfg, cfg->allowed_mechs,
 596                                    GSS_C_ACCEPT, &server_cred, NULL)) {
 597                 goto done;
 598             }
 599         } else {
 600             server_cred = acquired_cred;
 601         }
 602         maj = gss_inquire_cred(&min, server_cred, &server,
 603                                NULL, NULL, NULL);
 604         if (GSS_ERROR(maj)) {
 605             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 606                           "%s", mag_error(req, "gss_inquired_cred_() "
 607                                           "failed", maj, min));
 608             goto done;
 609         }
 610         if (server_cred != acquired_cred) {
 611             gss_release_cred(&min, &server_cred);
 612         }
 613
 614 #ifdef HAVE_CRED_STORE
 615         if (cfg->deleg_ccache_dir) {
 616             /* delegate ourselves credentials so we store them as requested */
 617             init_flags |= GSS_C_DELEG_FLAG;
 618         }
 619 #endif
 620
 621         do {
 622             /* output and input are inverted here, this is intentional */
 623             maj = gss_init_sec_context(&min, user_cred, &user_ctx, server,
 624                                        GSS_C_NO_OID, init_flags, 300,
 625                                        GSS_C_NO_CHANNEL_BINDINGS, &output,
 626                                        NULL, &input, NULL, NULL);
 627             if (GSS_ERROR(maj)) {
 628                 ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 629                               "%s", mag_error(req, "gss_init_sec_context() "
 630                                               "failed", maj, min));
 631                 goto done;
 632             }
 633             gss_release_buffer(&min, &output);
 634             maj = gss_accept_sec_context(&min, pctx, acquired_cred,
 635                                          &input, GSS_C_NO_CHANNEL_BINDINGS,
 636                                          &client, &mech_type, &output, &flags,
 637                                          &vtime, &delegated_cred);
 638             if (GSS_ERROR(maj)) {
 639                 ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 640                               "%s", mag_error(req, "gss_accept_sec_context()"
 641                                               " failed", maj, min));
 642                 goto done;
 643             }
 644             gss_release_buffer(&min, &input);
 645         } while (maj == GSS_S_CONTINUE_NEEDED);
 646         gss_release_buffer(&min, &output);
 647         goto complete;
 648     }
 649
 650     if (auth_type == AUTH_TYPE_NEGOTIATE &&
 651         cfg->allowed_mechs != GSS_C_NO_OID_SET) {
 652         maj = gss_set_neg_mechs(&min, acquired_cred, cfg->allowed_mechs);
 653         if (GSS_ERROR(maj)) {
 654             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req, "%s",
 655                           mag_error(req, "gss_set_neg_mechs() failed",
 656                                     maj, min));
 657             goto done;
 658         }
 659     }
 660
 661     maj = gss_accept_sec_context(&min, pctx, acquired_cred,
 662                                  &input, GSS_C_NO_CHANNEL_BINDINGS,
 663                                  &client, &mech_type, &output, &flags, &vtime,
 664                                  &delegated_cred);
 665     if (GSS_ERROR(maj)) {
 666         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req, "%s",
 667                       mag_error(req, "gss_accept_sec_context() failed",
 668                                 maj, min));
 669         goto done;
 670     } else if (maj == GSS_S_CONTINUE_NEEDED) {
 671         if (!mc) {
 672             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 673                           "Mechanism needs continuation but neither "
 674                           "GssapiConnectionBound nor "
 675                           "GssapiUseSessions are available");
 676             gss_release_buffer(&min, &output);
 677             output.length = 0;
 678         }
 679         /* auth not complete send token and wait next packet */
 680         goto done;
 681     }
 682
 683 complete:
 684     /* Always set the GSS name in an env var */
 685     maj = gss_display_name(&min, client, &name, NULL);
 686     if (GSS_ERROR(maj)) {
 687         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req, "%s",
 688                       mag_error(req, "gss_display_name() failed",
 689                                 maj, min));
 690         goto done;
 691     }
 692     clientname = apr_pstrndup(req->pool, name.value, name.length);
 693     apr_table_set(req->subprocess_env, "GSS_NAME", clientname);
 694     expiration = time(NULL) + vtime;
 695     apr_table_set(req->subprocess_env, "GSS_SESSION_EXPIRATION",
 696                   apr_psprintf(req->pool, "%ld", (long)expiration));
 697
 698 #ifdef HAVE_CRED_STORE
 699     if (cfg->deleg_ccache_dir && delegated_cred != GSS_C_NO_CREDENTIAL) {
 700         char *ccachefile = NULL;
 701
 702         mag_store_deleg_creds(req, cfg->deleg_ccache_dir, clientname,
 703                               delegated_cred, &ccachefile);
 704
 705         if (ccachefile) {
 706             mag_set_KRB5CCANME(req, ccachefile);
 707         }
 708
 709         if (mc) {
 710             mc->delegated = true;
 711         }
 712     }
 713 #endif
 714
 715     if (cfg->map_to_local) {
 716         maj = gss_localname(&min, client, mech_type, &lname);
 717         if (maj != GSS_S_COMPLETE) {
 718             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req, "%s",
 719                           mag_error(req, "gss_localname() failed", maj, min));
 720             goto done;
 721         }
 722         req->user = apr_pstrndup(req->pool, lname.value, lname.length);
 723     } else {
 724         req->user = clientname;
 725     }
 726
 727     if (mc) {
 728         mc->user_name = apr_pstrdup(mc->pool, req->user);
 729         mc->gss_name = apr_pstrdup(mc->pool, clientname);
 730         mc->established = true;
 731         if (vtime == GSS_C_INDEFINITE || vtime < MIN_SESS_EXP_TIME) {
 732             vtime = MIN_SESS_EXP_TIME;
 733         }
 734         mc->expiration = expiration;
 735         mc->auth_type = auth_type;
 736         if (auth_type == AUTH_TYPE_BASIC) {
 737             mag_basic_cache(cfg, mc, ba_user, ba_pwd);
 738         }
 739         if (cfg->use_sessions) {
 740             mag_attempt_session(req, cfg, mc);
 741         }
 742     }
 743
 744     if (cfg->send_persist)
 745         apr_table_set(req->headers_out, "Persistent-Auth",
 746             cfg->gss_conn_ctx ? "true" : "false");
 747
 748     ret = OK;
 749
 750 done:
 751     if ((auth_type != AUTH_TYPE_BASIC) && (output.length != 0)) {
 752         int prefixlen = strlen(auth_types[auth_type]) + 1;
 753         replen = apr_base64_encode_len(output.length) + 1;
 754         reply = apr_pcalloc(req->pool, prefixlen + replen);
 755         if (reply) {
 756             memcpy(reply, auth_types[auth_type], prefixlen - 1);
 757             reply[prefixlen - 1] = ' ';
 758             apr_base64_encode(&reply[prefixlen], output.value, output.length);
 759             apr_table_add(req->err_headers_out,
 760                           "WWW-Authenticate", reply);
 761         }
 762     } else if (ret == HTTP_UNAUTHORIZED) {
 763         apr_table_add(req->err_headers_out, "WWW-Authenticate", "Negotiate");
 764         if (is_mech_allowed(cfg, &gss_mech_ntlmssp)) {
 765             apr_table_add(req->err_headers_out, "WWW-Authenticate", "NTLM");
 766         }
 767         if (cfg->use_basic_auth) {
 768             apr_table_add(req->err_headers_out,
 769                           "WWW-Authenticate",
 770                           apr_psprintf(req->pool, "Basic realm=\"%s\"",
 771                                        ap_auth_name(req)));
 772         }
 773     }
 774 #ifdef HAVE_GSS_KRB5_CCACHE_NAME
 775     if (user_ccache != NULL) {
 776         maj = gss_krb5_ccache_name(&min, orig_ccache, NULL);
 777         if (maj != GSS_S_COMPLETE) {
 778             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, req,
 779                           "Failed to restore per-thread ccache, %s",
 780                           mag_error(req, "gss_krb5_ccache_name() "
 781                                     "failed", maj, min));
 782         }
 783     }
 784 #endif
 785     if (ctx != GSS_C_NO_CONTEXT)
 786         gss_delete_sec_context(&min, &ctx, GSS_C_NO_BUFFER);
 787     gss_delete_sec_context(&min, &user_ctx, GSS_C_NO_BUFFER);
 788     gss_release_cred(&min, &user_cred);
 789     gss_release_cred(&min, &acquired_cred);
 790     gss_release_cred(&min, &delegated_cred);
 791     gss_release_buffer(&min, &output);
 792     gss_release_name(&min, &client);
 793     gss_release_name(&min, &server);
 794     gss_release_buffer(&min, &name);
 795     gss_release_buffer(&min, &lname);
 796     return ret;
 797 }
 798
 799
 800 static void *mag_create_dir_config(apr_pool_t *p, char *dir)
 801 {
 802     struct mag_config *cfg;
 803
 804     cfg = (struct mag_config *)apr_pcalloc(p, sizeof(struct mag_config));
 805     cfg->pool = p;
 806
 807     return cfg;
 808 }
 809
 810 static const char *mag_ssl_only(cmd_parms *parms, void *mconfig, int on)
 811 {
 812     struct mag_config *cfg = (struct mag_config *)mconfig;
 813     cfg->ssl_only = on ? true : false;
 814     return NULL;
 815 }
 816
 817 static const char *mag_map_to_local(cmd_parms *parms, void *mconfig, int on)
 818 {
 819     struct mag_config *cfg = (struct mag_config *)mconfig;
 820     cfg->map_to_local = on ? true : false;
 821     return NULL;
 822 }
 823
 824 static const char *mag_conn_ctx(cmd_parms *parms, void *mconfig, int on)
 825 {
 826     struct mag_config *cfg = (struct mag_config *)mconfig;
 827     cfg->gss_conn_ctx = on ? true : false;
 828     return NULL;
 829 }
 830
 831 static const char *mag_send_persist(cmd_parms *parms, void *mconfig, int on)
 832 {
 833     struct mag_config *cfg = (struct mag_config *)mconfig;
 834     cfg->send_persist = on ? true : false;
 835     return NULL;
 836 }
 837
 838 static const char *mag_use_sess(cmd_parms *parms, void *mconfig, int on)
 839 {
 840     struct mag_config *cfg = (struct mag_config *)mconfig;
 841     cfg->use_sessions = on ? true : false;
 842     return NULL;
 843 }
 844
 845 #ifdef HAVE_CRED_STORE
 846 static const char *mag_use_s4u2p(cmd_parms *parms, void *mconfig, int on)
 847 {
 848     struct mag_config *cfg = (struct mag_config *)mconfig;
 849     cfg->use_s4u2proxy = on ? true : false;
 850
 851     if (cfg->deleg_ccache_dir == NULL) {
 852         cfg->deleg_ccache_dir = apr_pstrdup(parms->pool, "/tmp");
 853     }
 854     return NULL;
 855 }
 856 #endif
 857
 858 static const char *mag_sess_key(cmd_parms *parms, void *mconfig, const char *w)
 859 {
 860     struct mag_config *cfg = (struct mag_config *)mconfig;
 861     struct databuf keys;
 862     unsigned char *val;
 863     apr_status_t rc;
 864     const char *k;
 865     int l;
 866
 867     if (strncmp(w, "key:", 4) != 0) {
 868         ap_log_error(APLOG_MARK, APLOG_ERR, 0, parms->server,
 869                      "Invalid key format, expected prefix 'key:'");
 870         return NULL;
 871     }
 872     k = w + 4;
 873
 874     l = apr_base64_decode_len(k);
 875     val = apr_palloc(parms->temp_pool, l);
 876
 877     keys.length = (int)apr_base64_decode_binary(val, k);
 878     keys.value = (unsigned char *)val;
 879
 880     if (keys.length != 32) {
 881         ap_log_error(APLOG_MARK, APLOG_ERR, 0, parms->server,
 882                      "Invalid key length, expected 32 got %d", keys.length);
 883         return NULL;
 884     }
 885
 886     rc = SEAL_KEY_CREATE(cfg->pool, &cfg->mag_skey, &keys);
 887     if (rc != OK) {
 888         ap_log_error(APLOG_MARK, APLOG_ERR, 0, parms->server,
 889                      "Failed to import sealing key!");
 890     }
 891     return NULL;
 892 }
 893
 894 #ifdef HAVE_CRED_STORE
 895
 896 #define MAX_CRED_OPTIONS 10
 897
 898 static const char *mag_cred_store(cmd_parms *parms, void *mconfig,
 899                                   const char *w)
 900 {
 901     struct mag_config *cfg = (struct mag_config *)mconfig;
 902     gss_key_value_element_desc *elements;
 903     uint32_t count;
 904     size_t size;
 905     const char *p;
 906     char *value;
 907     char *key;
 908
 909     p = strchr(w, ':');
 910     if (!p) {
 911         ap_log_error(APLOG_MARK, APLOG_ERR, 0, parms->server,
 912                      "%s [%s]", "Invalid syntax for GssapiCredStore option", w);
 913         return NULL;
 914     }
 915
 916     key = apr_pstrndup(parms->pool, w, (p-w));
 917     value = apr_pstrdup(parms->pool, p + 1);
 918
 919     if (!cfg->cred_store) {
 920         cfg->cred_store = apr_pcalloc(parms->pool,
 921                                       sizeof(gss_key_value_set_desc));
 922         size = sizeof(gss_key_value_element_desc) * MAX_CRED_OPTIONS;
 923         cfg->cred_store->elements = apr_palloc(parms->pool, size);
 924     }
 925
 926     elements = cfg->cred_store->elements;
 927     count = cfg->cred_store->count;
 928
 929     if (count >= MAX_CRED_OPTIONS) {
 930         ap_log_error(APLOG_MARK, APLOG_ERR, 0, parms->server,
 931                      "Too many GssapiCredStore options (MAX: %d)",
 932                      MAX_CRED_OPTIONS);
 933         return NULL;
 934     }
 935     cfg->cred_store->count++;
 936
 937     elements[count].key = key;
 938     elements[count].value = value;
 939
 940     return NULL;
 941 }
 942
 943 static const char *mag_deleg_ccache_dir(cmd_parms *parms, void *mconfig,
 944                                         const char *value)
 945 {
 946     struct mag_config *cfg = (struct mag_config *)mconfig;
 947
 948     cfg->deleg_ccache_dir = apr_pstrdup(parms->pool, value);
 949
 950     return NULL;
 951 }
 952 #endif
 953
 954 static const char *mag_use_basic_auth(cmd_parms *parms, void *mconfig, int on)
 955 {
 956     struct mag_config *cfg = (struct mag_config *)mconfig;
 957
 958     cfg->use_basic_auth = on ? true : false;
 959     return NULL;
 960 }
 961
 962 #define MAX_ALLOWED_MECHS 10
 963
 964 static const char *mag_allow_mech(cmd_parms *parms, void *mconfig,
 965                                   const char *w)
 966 {
 967     struct mag_config *cfg = (struct mag_config *)mconfig;
 968     gss_const_OID oid;
 969     size_t size;
 970
 971     if (!cfg->allowed_mechs) {
 972         cfg->allowed_mechs = apr_pcalloc(parms->pool,
 973                                          sizeof(gss_OID_set_desc));
 974         size = sizeof(gss_OID) * MAX_ALLOWED_MECHS;
 975         cfg->allowed_mechs->elements = apr_palloc(parms->pool, size);
 976     }
 977
 978     if (strcmp(w, "krb5") == 0) {
 979         oid = gss_mech_krb5;
 980     } else if (strcmp(w, "iakerb") == 0) {
 981         oid = gss_mech_iakerb;
 982     } else if (strcmp(w, "ntlmssp") == 0) {
 983         oid = &gss_mech_ntlmssp;
 984     } else {
 985         ap_log_error(APLOG_MARK, APLOG_ERR, 0, parms->server,
 986                      "Unrecognized GSSAPI Mechanism: %s", w);
 987         return NULL;
 988     }
 989
 990     if (cfg->allowed_mechs->count >= MAX_ALLOWED_MECHS) {
 991         ap_log_error(APLOG_MARK, APLOG_ERR, 0, parms->server,
 992                      "Too many GssapiAllowedMech options (MAX: %d)",
 993                      MAX_ALLOWED_MECHS);
 994         return NULL;
 995     }
 996     cfg->allowed_mechs->elements[cfg->allowed_mechs->count] = *oid;
 997     cfg->allowed_mechs->count++;
 998
 999     return NULL;
1000 }
1001
1002 static const command_rec mag_commands[] = {
1003     AP_INIT_FLAG("GssapiSSLonly", mag_ssl_only, NULL, OR_AUTHCFG,
1004                   "Work only if connection is SSL Secured"),
1005     AP_INIT_FLAG("GssapiLocalName", mag_map_to_local, NULL, OR_AUTHCFG,
1006                   "Translate principals to local names"),
1007     AP_INIT_FLAG("GssapiConnectionBound", mag_conn_ctx, NULL, OR_AUTHCFG,
1008                   "Authentication is bound to the TCP connection"),
1009     AP_INIT_FLAG("GssapiSignalPersistentAuth", mag_send_persist, NULL, OR_AUTHCFG,
1010                   "Send Persitent-Auth header according to connection bound"),
1011     AP_INIT_FLAG("GssapiUseSessions", mag_use_sess, NULL, OR_AUTHCFG,
1012                   "Authentication uses mod_sessions to hold status"),
1013     AP_INIT_RAW_ARGS("GssapiSessionKey", mag_sess_key, NULL, OR_AUTHCFG,
1014                      "Key Used to seal session data."),
1015 #ifdef HAVE_CRED_STORE
1016     AP_INIT_FLAG("GssapiUseS4U2Proxy", mag_use_s4u2p, NULL, OR_AUTHCFG,
1017                   "Initializes credentials for s4u2proxy usage"),
1018     AP_INIT_ITERATE("GssapiCredStore", mag_cred_store, NULL, OR_AUTHCFG,
1019                     "Credential Store"),
1020     AP_INIT_RAW_ARGS("GssapiDelegCcacheDir", mag_deleg_ccache_dir, NULL,
1021                      OR_AUTHCFG, "Directory to store delegated credentials"),
1022 #endif
1023 #ifdef HAVE_GSS_ACQUIRE_CRED_WITH_PASSWORD
1024     AP_INIT_FLAG("GssapiBasicAuth", mag_use_basic_auth, NULL, OR_AUTHCFG,
1025                      "Allows use of Basic Auth for authentication"),
1026 #endif
1027     AP_INIT_ITERATE("GssapiAllowedMech", mag_allow_mech, NULL, OR_AUTHCFG,
1028                     "Allowed Mechanisms"),
1029     { NULL }
1030 };
1031
1032 static void
1033 mag_register_hooks(apr_pool_t *p)
1034 {
1035     ap_hook_check_user_id(mag_auth, NULL, NULL, APR_HOOK_MIDDLE);
1036     ap_hook_post_config(mag_post_config, NULL, NULL, APR_HOOK_MIDDLE);
1037     ap_hook_pre_connection(mag_pre_connection, NULL, NULL, APR_HOOK_MIDDLE);
1038 }
1039
1040 module AP_MODULE_DECLARE_DATA auth_gssapi_module =
1041 {
1042     STANDARD20_MODULE_STUFF,
1043     mag_create_dir_config,
1044     NULL,
1045     NULL,
1046     NULL,
1047     mag_commands,
1048     mag_register_hooks
1049 };