src/mod_auth_kerb.c

   1 /*
   2  * Daniel Kouril <kouril@users.sourceforge.net>
   3  *
   4  * Source and Documentation can be found at:
   5  * http://modauthkerb.sourceforge.net/
   6  *
   7  * Based on work by
   8  *   James E. Robinson, III <james@ncstate.net>
   9  *   Daniel Henninger <daniel@ncsu.edu>
  10  *   Ludek Sulak <xsulak@fi.muni.cz>
  11  */
  12
  13 /*
  14  * Copyright (c) 2004 Masarykova universita
  15  * (Masaryk University, Brno, Czech Republic)
  16  * All rights reserved.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions are met:
  20  *
  21  * 1. Redistributions of source code must retain the above copyright notice,
  22  *    this list of conditions and the following disclaimer.
  23  *
  24  * 2. Redistributions in binary form must reproduce the above copyright
  25  *    notice, this list of conditions and the following disclaimer in the
  26  *    documentation and/or other materials provided with the distribution.
  27  *
  28  * 3. Neither the name of the University nor the names of its contributors may
  29  *    be used to endorse or promote products derived from this software
  30  *    without specific prior written permission.
  31  *
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  33  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  34  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  35  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  36  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  37  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  38  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  39  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  40  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  41  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42  * POSSIBILITY OF SUCH DAMAGE.
  43  */
  44
  45 #ident "$Id$"
  46
  47 #include "config.h"
  48
  49 #define MODAUTHKERB_VERSION "5.0-rc4"
  50
  51 #include <httpd.h>
  52 #include <http_config.h>
  53 #include <http_core.h>
  54 #include <http_log.h>
  55 #include <http_protocol.h>
  56 #include <http_request.h>
  57
  58 #ifdef STANDARD20_MODULE_STUFF
  59 #include <ap_compat.h>
  60 #include <apr_strings.h>
  61 #endif
  62
  63
  64 #ifdef KRB5
  65 #include <krb5.h>
  66 #ifdef HEIMDAL
  67 #  include <gssapi.h>
  68 #else
  69 #  include <gssapi/gssapi.h>
  70 #  include <gssapi/gssapi_generic.h>
  71 #  define GSS_C_NT_USER_NAME gss_nt_user_name
  72 #  define GSS_C_NT_HOSTBASED_SERVICE gss_nt_service_name
  73 #  define krb5_get_err_text(context,code) error_message(code)
  74 #endif
  75 #include "spnegokrb5.h"
  76 #endif /* KRB5 */
  77
  78 #ifdef KRB4
  79 /*Prevent warning about closesocket redefinition (Apache's ap_config.h and
  80  * MIT Kerberos' port-sockets.h both define it as close) */
  81 #ifdef closesocket
  82 #  undef closesocket
  83 #endif
  84 #include <krb.h>
  85 #include <netdb.h> /* gethostbyname() */
  86 #endif /* KRB4 */
  87
  88 #ifdef STANDARD20_MODULE_STUFF
  89 module AP_MODULE_DECLARE_DATA auth_kerb_module;
  90 #else
  91 module auth_kerb_module;
  92 #endif
  93
  94 /***************************************************************************
  95  Macros To Ease Compatibility
  96  ***************************************************************************/
  97 #ifdef STANDARD20_MODULE_STUFF
  98 #define MK_POOL apr_pool_t
  99 #define MK_TABLE_GET apr_table_get
 100 #define MK_USER r->user
 101 #define MK_AUTH_TYPE r->ap_auth_type
 102 #else
 103 #define MK_POOL pool
 104 #define MK_TABLE_GET ap_table_get
 105 #define MK_USER r->connection->user
 106 #define MK_AUTH_TYPE r->connection->ap_auth_type
 107 #define PROXYREQ_PROXY STD_PROXY
 108 #endif
 109
 110 /***************************************************************************
 111  Auth Configuration Structure
 112  ***************************************************************************/
 113 typedef struct {
 114         char *krb_auth_realms;
 115         int krb_save_credentials;
 116         int krb_verify_kdc;
 117         char *krb_service_name;
 118         int krb_authoritative;
 119 #ifdef KRB5
 120         char *krb_5_keytab;
 121         int krb_method_gssapi;
 122         int krb_method_k5pass;
 123 #endif
 124 #ifdef KRB4
 125         char *krb_4_srvtab;
 126         int krb_method_k4pass;
 127 #endif
 128 } kerb_auth_config;
 129
 130 static void
 131 set_kerb_auth_headers(request_rec *r, const kerb_auth_config *conf,
 132                       int use_krb4, int use_krb5pwd, char *negotiate_ret_value);
 133
 134 static const char*
 135 krb5_save_realms(cmd_parms *cmd, kerb_auth_config *sec, char *arg);
 136
 137 #ifdef STANDARD20_MODULE_STUFF
 138 #define command(name, func, var, type, usage)           \
 139   AP_INIT_ ## type (name, func,                         \
 140         (void*)APR_XtOffsetOf(kerb_auth_config, var),   \
 141         OR_AUTHCFG, usage)
 142 #else
 143 #define command(name, func, var, type, usage)           \
 144   { name, func,                                         \
 145     (void*)XtOffsetOf(kerb_auth_config, var),           \
 146     OR_AUTHCFG, type, usage }
 147 #endif
 148
 149 static const command_rec kerb_auth_cmds[] = {
 150    command("KrbAuthRealms", krb5_save_realms, krb_auth_realms,
 151      RAW_ARGS, "Realms to attempt authentication against (can be multiple)."),
 152
 153    command("KrbAuthRealm", krb5_save_realms, krb_auth_realms,
 154      RAW_ARGS, "Alias for KrbAuthRealms."),
 155
 156    command("KrbSaveCredentials", ap_set_flag_slot, krb_save_credentials,
 157      FLAG, "Save and store credentials/tickets retrieved during auth."),
 158
 159    command("KrbVerifyKDC", ap_set_flag_slot, krb_verify_kdc,
 160      FLAG, "Verify tickets against keytab to prevent KDC spoofing attacks."),
 161
 162    command("KrbServiceName", ap_set_string_slot, krb_service_name,
 163      TAKE1, "Service name to be used by Apache for authentication."),
 164
 165    command("KrbAuthoritative", ap_set_flag_slot, krb_authoritative,
 166      FLAG, "Set to 'off' to allow access control to be passed along to lower modules if the UserID is not known to this module."),
 167
 168 #ifdef KRB5
 169    command("Krb5Keytab", ap_set_file_slot, krb_5_keytab,
 170      TAKE1, "Location of Kerberos V5 keytab file."),
 171
 172    command("KrbMethodNegotiate", ap_set_flag_slot, krb_method_gssapi,
 173      FLAG, "Enable Negotiate authentication method."),
 174
 175    command("KrbMethodK5Passwd", ap_set_flag_slot, krb_method_k5pass,
 176      FLAG, "Enable Kerberos V5 password authentication."),
 177 #endif
 178
 179 #ifdef KRB4
 180    command("Krb4Srvtab", ap_set_file_slot, krb_4_srvtab,
 181      TAKE1, "Location of Kerberos V4 srvtab file."),
 182
 183    command("KrbMethodK4Passwd", ap_set_flag_slot, krb_method_k4pass,
 184      FLAG, "Enable Kerberos V4 password authentication."),
 185 #endif
 186
 187    { NULL }
 188 };
 189
 190 #ifdef KRB5
 191 typedef struct {
 192    gss_ctx_id_t context;
 193    gss_cred_id_t server_creds;
 194 } gss_connection_t;
 195
 196 static gss_connection_t *gss_connection = NULL;
 197 #endif
 198
 199
 200 /***************************************************************************
 201  Auth Configuration Initialization
 202  ***************************************************************************/
 203 static void *kerb_dir_create_config(MK_POOL *p, char *d)
 204 {
 205         kerb_auth_config *rec;
 206
 207         rec = (kerb_auth_config *) ap_pcalloc(p, sizeof(kerb_auth_config));
 208         ((kerb_auth_config *)rec)->krb_verify_kdc = 1;
 209         ((kerb_auth_config *)rec)->krb_service_name = "HTTP";
 210         ((kerb_auth_config *)rec)->krb_authoritative = 1;
 211 #ifdef KRB5
 212         ((kerb_auth_config *)rec)->krb_method_k5pass = 1;
 213         ((kerb_auth_config *)rec)->krb_method_gssapi = 1;
 214 #endif
 215 #ifdef KRB4
 216         ((kerb_auth_config *)rec)->krb_method_k4pass = 1;
 217 #endif
 218         return rec;
 219 }
 220
 221 static const char*
 222 krb5_save_realms(cmd_parms *cmd, kerb_auth_config *sec, char *arg)
 223 {
 224    sec->krb_auth_realms= ap_pstrdup(cmd->pool, arg);
 225    return NULL;
 226 }
 227
 228 void log_rerror(const char *file, int line, int level, int status,
 229                 const request_rec *r, const char *fmt, ...)
 230 {
 231    char errstr[1024];
 232    va_list ap;
 233
 234    va_start(ap, fmt);
 235    vsnprintf(errstr, sizeof(errstr), fmt, ap);
 236    va_end(ap);
 237
 238
 239 #ifdef STANDARD20_MODULE_STUFF
 240    ap_log_rerror(file, line, level | APLOG_NOERRNO, status, r, "%s", errstr);
 241 #else
 242    ap_log_rerror(file, line, level | APLOG_NOERRNO, r, "%s", errstr);
 243 #endif
 244 }
 245
 246 #ifdef KRB4
 247 /***************************************************************************
 248  Username/Password Validation for Krb4
 249  ***************************************************************************/
 250 static int
 251 verify_krb4_user(request_rec *r, char *name, char *instance, char *realm,
 252                  char *password, char *linstance, char *srvtab, int krb_verify_kdc)
 253 {
 254    int ret;
 255    char *phost;
 256    unsigned long addr;
 257    struct hostent *hp;
 258    const char *hostname;
 259    KTEXT_ST ticket;
 260    AUTH_DAT authdata;
 261    char lrealm[REALM_SZ];
 262
 263    ret = krb_get_pw_in_tkt(name, instance, realm, "krbtgt", realm,
 264                            DEFAULT_TKT_LIFE, password);
 265    if (ret) {
 266       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 267                  "Cannot get krb4 ticket: krb_get_pw_in_tkt() failed: %s",
 268                  krb_get_err_text(ret));
 269       return ret;
 270    }
 271
 272    if (!krb_verify_kdc)
 273       return ret;
 274
 275    hostname = ap_get_server_name(r);
 276
 277    hp = gethostbyname(hostname);
 278    if (hp == NULL) {
 279       dest_tkt();
 280       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 281                  "Cannot verify krb4 ticket: gethostbyname() failed: %s",
 282                  hstrerror(h_errno));
 283       return h_errno;
 284    }
 285    memcpy(&addr, hp->h_addr, sizeof(addr));
 286
 287    phost = krb_get_phost((char *)hostname);
 288
 289    krb_get_lrealm(lrealm, 1);
 290
 291    ret = krb_mk_req(&ticket, linstance, phost, lrealm, 0);
 292    if (ret) {
 293       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 294                  "Cannot verify krb4 ticket: krb_mk_req() failed: %s",
 295                  krb_get_err_text(ret));
 296       dest_tkt();
 297       return ret;
 298    }
 299
 300    ret = krb_rd_req(&ticket, linstance, phost, addr, &authdata, srvtab);
 301    if (ret) {
 302       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 303                  "Cannot verify krb4 ticket: krb_rd_req() failed: %s",
 304                  krb_get_err_text(ret));
 305       dest_tkt();
 306    }
 307
 308    return ret;
 309 }
 310
 311 static int
 312 krb4_cache_cleanup(void *data)
 313 {
 314    char *tkt_file = (char *) data;
 315
 316    krb_set_tkt_string(tkt_file);
 317    dest_tkt();
 318    return OK;
 319 }
 320
 321 static int
 322 authenticate_user_krb4pwd(request_rec *r,
 323                           kerb_auth_config *conf,
 324                           const char *auth_line)
 325 {
 326    int ret;
 327    const char *sent_pw;
 328    const char *sent_name;
 329    char *sent_instance;
 330    char tkt_file[32];
 331    char *tkt_file_p = NULL;
 332    int fd;
 333    const char *realms;
 334    const char *realm;
 335    char *user;
 336    char lrealm[REALM_SZ];
 337    int all_principals_unkown;
 338
 339    sent_pw = ap_pbase64decode(r->pool, auth_line);
 340    sent_name = ap_getword (r->pool, &sent_pw, ':');
 341
 342    /* do not allow user to override realm setting of server */
 343    if (strchr(sent_name, '@')) {
 344       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 345                  "specifying realm in user name is prohibited");
 346       return HTTP_UNAUTHORIZED;
 347    }
 348
 349    sent_instance = strchr(sent_name, '.');
 350    if (sent_instance)
 351       *sent_instance++ = '\0';
 352
 353    snprintf(tkt_file, sizeof(tkt_file), "/tmp/apache_tkt_XXXXXX");
 354    fd = mkstemp(tkt_file);
 355    if (fd < 0) {
 356       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 357                  "Cannot create krb4 ccache: mkstemp() failed: %s",
 358                  strerror(errno));
 359       return HTTP_INTERNAL_SERVER_ERROR;
 360    }
 361
 362    tkt_file_p = ap_pstrdup(r->pool, tkt_file);
 363    ap_register_cleanup(r->pool, tkt_file_p,
 364                        krb4_cache_cleanup, ap_null_cleanup);
 365
 366    krb_set_tkt_string(tkt_file);
 367
 368    all_principals_unkown = 1;
 369    realms = conf->krb_auth_realms;
 370    do {
 371       memset(lrealm, 0, sizeof(lrealm));
 372       realm = NULL;
 373       if (realms)
 374          realm = ap_getword_white(r->pool, &realms);
 375
 376       if (realm == NULL) {
 377          ret = krb_get_lrealm(lrealm, 1);
 378          if (ret)
 379             break;
 380          realm = lrealm;
 381       }
 382
 383       ret = verify_krb4_user(r, (char *)sent_name,
 384                              (sent_instance) ? sent_instance : "",
 385                              (char *)realm, (char *)sent_pw,
 386                              conf->krb_service_name,
 387                              conf->krb_4_srvtab, conf->krb_verify_kdc);
 388       if (!conf->krb_authoritative && ret) {
 389          /* if we're not authoritative, we allow authentication to pass on
 390           * to another modules if (and only if) the user is not known to us */
 391          if (all_principals_unkown && ret != KDC_PR_UNKNOWN)
 392             all_principals_unkown = 0;
 393       }
 394
 395       if (ret == 0)
 396          break;
 397    } while (realms && *realms);
 398
 399    if (ret) {
 400       /* XXX log only in the verify_krb4_user() call */
 401       log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "Verifying krb4 password failed");
 402       ret = (!conf->krb_authoritative && all_principals_unkown == 1 && ret == KDC_PR_UNKNOWN) ?
 403                  DECLINED : HTTP_UNAUTHORIZED;
 404       goto end;
 405    }
 406
 407    user = ap_pstrdup(r->pool, sent_name);
 408    if (sent_instance)
 409       user = ap_pstrcat(r->pool, user, ".", sent_instance, NULL);
 410    user = ap_pstrcat(r->pool, user, "@", realm, NULL);
 411
 412    MK_USER = user;
 413    MK_AUTH_TYPE = "Basic";
 414    ap_table_setn(r->subprocess_env, "KRBTKFILE", tkt_file_p);
 415
 416    if (!conf->krb_save_credentials)
 417       krb4_cache_cleanup(tkt_file);
 418
 419 end:
 420    if (ret)
 421       krb4_cache_cleanup(tkt_file);
 422    close(fd);
 423    tf_close();
 424
 425    return ret;
 426 }
 427 #endif /* KRB4 */
 428
 429 #ifdef KRB5
 430 /***************************************************************************
 431  Username/Password Validation for Krb5
 432  ***************************************************************************/
 433 /* Inspired by krb5_verify_user from Heimdal */
 434 static krb5_error_code
 435 verify_krb5_user(request_rec *r, krb5_context context, krb5_principal principal,
 436                  krb5_ccache ccache, const char *password, const char *service,
 437                  krb5_keytab keytab, int krb_verify_kdc)
 438 {
 439    krb5_creds creds;
 440    krb5_principal server = NULL;
 441    krb5_error_code ret;
 442    krb5_verify_init_creds_opt opt;
 443
 444    /* XXX error messages shouldn't be logged here (and in the while() loop in
 445     * authenticate_user_krb5pwd() as weell), in order to avoid confusing log
 446     * entries when using multiple realms */
 447
 448    memset(&creds, 0, sizeof(creds));
 449
 450    ret = krb5_get_init_creds_password(context, &creds, principal,
 451                                       (char *)password, NULL,
 452                                       NULL, 0, NULL, NULL);
 453    if (ret) {
 454       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 455                  "krb5_get_init_creds_password() failed: %s",
 456                  krb5_get_err_text(context, ret));
 457       return ret;
 458    }
 459
 460    ret = krb5_sname_to_principal(context, ap_get_server_name(r), service,
 461                                  KRB5_NT_UNKNOWN, &server);
 462    if (ret) {
 463       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 464                  "krb5_sname_to_principal() failed: %s",
 465                  krb5_get_err_text(context, ret));
 466       goto end;
 467    }
 468
 469    krb5_verify_init_creds_opt_init(&opt);
 470    krb5_verify_init_creds_opt_set_ap_req_nofail(&opt, krb_verify_kdc);
 471
 472    ret = krb5_verify_init_creds(context, &creds, server, keytab, NULL, &opt);
 473    if (ret) {
 474       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 475                  "krb5_verify_init_creds() failed: %s",
 476                  krb5_get_err_text(context, ret));
 477       goto end;
 478    }
 479
 480    if (ccache) {
 481       ret = krb5_cc_initialize(context, ccache, principal);
 482       if (ret) {
 483          log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 484                     "krb5_cc_initialize() failed: %s",
 485                     krb5_get_err_text(context, ret));
 486          goto end;
 487       }
 488
 489       ret = krb5_cc_store_cred(context, ccache, &creds);
 490       if (ret) {
 491          log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 492                     "krb5_cc_store_cred() failed: %s",
 493                     krb5_get_err_text(context, ret));
 494          goto end;
 495       }
 496    }
 497
 498 end:
 499    krb5_free_cred_contents(context, &creds);
 500    if (server)
 501       krb5_free_principal(context, server);
 502    return ret;
 503 }
 504
 505 static int
 506 krb5_cache_cleanup(void *data)
 507 {
 508    krb5_context context;
 509    krb5_ccache  cache;
 510    krb5_error_code problem;
 511    char *cache_name = (char *) data;
 512
 513    problem = krb5_init_context(&context);
 514    if (problem) {
 515       /* ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, "krb5_init_context() failed"); */
 516       return HTTP_INTERNAL_SERVER_ERROR;
 517    }
 518
 519    problem = krb5_cc_resolve(context, cache_name, &cache);
 520    if (problem) {
 521       /* log_error(APLOG_MARK, APLOG_ERR, 0, NULL,
 522                 "krb5_cc_resolve() failed (%s: %s)",
 523                 cache_name, krb5_get_err_text(context, problem)); */
 524       return HTTP_INTERNAL_SERVER_ERROR;
 525    }
 526
 527    krb5_cc_destroy(context, cache);
 528    krb5_free_context(context);
 529    return OK;
 530 }
 531
 532 static int
 533 create_krb5_ccache(krb5_context kcontext,
 534                    request_rec *r,
 535                    kerb_auth_config *conf,
 536                    krb5_principal princ,
 537                    krb5_ccache *ccache)
 538 {
 539    char *ccname;
 540    int fd;
 541    krb5_error_code problem;
 542    int ret;
 543    krb5_ccache tmp_ccache = NULL;
 544
 545    ccname = ap_psprintf(r->pool, "FILE:%s/krb5cc_apache_XXXXXX", P_tmpdir);
 546    fd = mkstemp(ccname + strlen("FILE:"));
 547    if (fd < 0) {
 548       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 549                  "mkstemp() failed: %s", strerror(errno));
 550       ret = HTTP_INTERNAL_SERVER_ERROR;
 551       goto end;
 552    }
 553    close(fd);
 554
 555    problem = krb5_cc_resolve(kcontext, ccname, &tmp_ccache);
 556    if (problem) {
 557       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 558                  "krb5_cc_resolve() failed: %s",
 559                  krb5_get_err_text(kcontext, problem));
 560       ret = HTTP_INTERNAL_SERVER_ERROR;
 561       unlink(ccname);
 562       goto end;
 563    }
 564
 565    problem = krb5_cc_initialize(kcontext, tmp_ccache, princ);
 566    if (problem) {
 567       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 568                  "Cannot initialize krb5 ccache %s: krb5_cc_initialize() failed: %s",
 569                  ccname, krb5_get_err_text(kcontext, problem));
 570       ret = HTTP_INTERNAL_SERVER_ERROR;
 571       goto end;
 572    }
 573
 574    ap_table_setn(r->subprocess_env, "KRB5CCNAME", ccname);
 575    ap_register_cleanup(r->pool, ccname,
 576                        krb5_cache_cleanup, ap_null_cleanup);
 577
 578    *ccache = tmp_ccache;
 579    tmp_ccache = NULL;
 580
 581    ret = OK;
 582
 583 end:
 584    if (tmp_ccache)
 585       krb5_cc_destroy(kcontext, tmp_ccache);
 586
 587    return ret;
 588 }
 589
 590 static int
 591 store_krb5_creds(krb5_context kcontext,
 592                  request_rec *r,
 593                  kerb_auth_config *conf,
 594                  krb5_ccache delegated_cred)
 595 {
 596    char errstr[1024];
 597    krb5_error_code problem;
 598    krb5_principal princ;
 599    krb5_ccache ccache;
 600    int ret;
 601
 602    problem = krb5_cc_get_principal(kcontext, delegated_cred, &princ);
 603    if (problem) {
 604       snprintf(errstr, sizeof(errstr), "krb5_cc_get_principal() failed: %s",
 605                krb5_get_err_text(kcontext, problem));
 606       return HTTP_INTERNAL_SERVER_ERROR;
 607    }
 608
 609    ret = create_krb5_ccache(kcontext, r, conf, princ, &ccache);
 610    if (ret) {
 611       krb5_free_principal(kcontext, princ);
 612       return ret;
 613    }
 614
 615 #ifdef HEIMDAL
 616    problem = krb5_cc_copy_cache(kcontext, delegated_cred, ccache);
 617 #else
 618    problem = krb5_cc_copy_creds(kcontext, delegated_cred, ccache);
 619 #endif
 620    krb5_free_principal(kcontext, princ);
 621    if (problem) {
 622       snprintf(errstr, sizeof(errstr), "Failed to store credentials: %s",
 623                krb5_get_err_text(kcontext, problem));
 624       krb5_cc_destroy(kcontext, ccache);
 625       return HTTP_INTERNAL_SERVER_ERROR;
 626    }
 627
 628    krb5_cc_close(kcontext, ccache);
 629    return OK;
 630 }
 631
 632
 633 int authenticate_user_krb5pwd(request_rec *r,
 634                               kerb_auth_config *conf,
 635                               const char *auth_line)
 636 {
 637    const char      *sent_pw = NULL;
 638    const char      *sent_name = NULL;
 639    const char      *realms = NULL;
 640    krb5_context    kcontext = NULL;
 641    krb5_error_code code;
 642    krb5_principal  client = NULL;
 643    krb5_ccache     ccache = NULL;
 644    krb5_keytab     keytab = NULL;
 645    int             ret;
 646    char            *name = NULL;
 647    int             all_principals_unkown;
 648    char            *ccname = NULL;
 649    int             fd;
 650
 651    code = krb5_init_context(&kcontext);
 652    if (code) {
 653       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 654                  "Cannot initialize Kerberos5 context (%d)", code);
 655       return HTTP_INTERNAL_SERVER_ERROR;
 656    }
 657
 658    sent_pw = ap_pbase64decode(r->pool, auth_line);
 659    sent_name = ap_getword (r->pool, &sent_pw, ':');
 660    /* do not allow user to override realm setting of server */
 661    if (strchr(sent_name, '@')) {
 662       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 663                  "specifying realm in user name is prohibited");
 664       ret = HTTP_UNAUTHORIZED;
 665       goto end;
 666    }
 667
 668    if (sent_pw == NULL || *sent_pw == '\0') {
 669       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 670                  "empty passwords are not accepted");
 671       ret = HTTP_UNAUTHORIZED;
 672       goto end;
 673    }
 674
 675    code = krb5_cc_resolve(kcontext, "MEMORY:", &ccache);
 676    if (code) {
 677       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 678                  "generating new memory ccache failed: %s",
 679                  krb5_get_err_text(kcontext, code));
 680       ret = HTTP_INTERNAL_SERVER_ERROR;
 681       unlink(ccname);
 682       goto end;
 683    }
 684
 685    if (conf->krb_5_keytab)
 686       krb5_kt_resolve(kcontext, conf->krb_5_keytab, &keytab);
 687
 688    all_principals_unkown = 1;
 689    realms = conf->krb_auth_realms;
 690    do {
 691       if (realms && (code = krb5_set_default_realm(kcontext,
 692                                            ap_getword_white(r->pool, &realms)))){
 693          log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 694                     "krb5_set_default_realm() failed: %s",
 695                     krb5_get_err_text(kcontext, code));
 696          continue;
 697       }
 698
 699       if (client) {
 700          krb5_free_principal(kcontext, client);
 701          client = NULL;
 702       }
 703       code = krb5_parse_name(kcontext, sent_name, &client);
 704       if (code) {
 705          log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 706                     "krb5_parse_name() failed: %s",
 707                     krb5_get_err_text(kcontext, code));
 708          continue;
 709       }
 710
 711       code = verify_krb5_user(r, kcontext, client, ccache, sent_pw,
 712                               conf->krb_service_name,
 713                               keytab, conf->krb_verify_kdc);
 714       if (!conf->krb_authoritative && code) {
 715          /* if we're not authoritative, we allow authentication to pass on
 716           * to another modules if (and only if) the user is not known to us */
 717          if (all_principals_unkown && code != KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN)
 718             all_principals_unkown = 0;
 719       }
 720
 721       if (code == 0)
 722          break;
 723
 724       /* ap_getword_white() used above shifts the parameter, so it's not
 725          needed to touch the realms variable */
 726    } while (realms && *realms);
 727
 728    memset((char *)sent_pw, 0, strlen(sent_pw));
 729
 730    if (code) {
 731       if (!conf->krb_authoritative && all_principals_unkown == 1 && code == KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN)
 732          ret = DECLINED;
 733       else
 734          ret = HTTP_UNAUTHORIZED;
 735
 736       goto end;
 737    }
 738
 739    code = krb5_unparse_name(kcontext, client, &name);
 740    if (code) {
 741       log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "krb5_unparse_name() failed: %s",
 742                  krb5_get_err_text(kcontext, code));
 743       ret = HTTP_UNAUTHORIZED;
 744       goto end;
 745    }
 746    MK_USER = ap_pstrdup (r->pool, name);
 747    MK_AUTH_TYPE = "Basic";
 748    free(name);
 749
 750    if (conf->krb_save_credentials)
 751       store_krb5_creds(kcontext, r, conf, ccache);
 752
 753    ret = OK;
 754
 755 end:
 756    if (client)
 757       krb5_free_principal(kcontext, client);
 758    if (ccache)
 759       krb5_cc_destroy(kcontext, ccache);
 760    if (keytab)
 761       krb5_kt_close(kcontext, keytab);
 762    krb5_free_context(kcontext);
 763
 764    return ret;
 765 }
 766
 767 /*********************************************************************
 768  * GSSAPI Authentication
 769  ********************************************************************/
 770
 771 static const char *
 772 get_gss_error(MK_POOL *p, OM_uint32 err_maj, OM_uint32 err_min, char *prefix)
 773 {
 774    OM_uint32 maj_stat, min_stat;
 775    OM_uint32 msg_ctx = 0;
 776    gss_buffer_desc status_string;
 777    char *err_msg;
 778    size_t len;
 779
 780    err_msg = ap_pstrdup(p, prefix);
 781    do {
 782       maj_stat = gss_display_status (&min_stat,
 783                                      err_maj,
 784                                      GSS_C_GSS_CODE,
 785                                      GSS_C_NO_OID,
 786                                      &msg_ctx,
 787                                      &status_string);
 788       if (GSS_ERROR(maj_stat))
 789          break;
 790       err_msg = ap_pstrcat(p, err_msg, ": ", (char*) status_string.value, NULL);
 791       gss_release_buffer(&min_stat, &status_string);
 792
 793       maj_stat = gss_display_status (&min_stat,
 794                                      err_min,
 795                                      GSS_C_MECH_CODE,
 796                                      GSS_C_NULL_OID,
 797                                      &msg_ctx,
 798                                      &status_string);
 799       if (!GSS_ERROR(maj_stat)) {
 800          err_msg = ap_pstrcat(p, err_msg,
 801                               " (", (char*) status_string.value, ")", NULL);
 802          gss_release_buffer(&min_stat, &status_string);
 803       }
 804    } while (!GSS_ERROR(maj_stat) && msg_ctx != 0);
 805
 806    return err_msg;
 807 }
 808
 809 static int
 810 cleanup_gss_connection(void *data)
 811 {
 812    OM_uint32 minor_status;
 813    gss_connection_t *gss_conn = (gss_connection_t *)data;
 814
 815    if (data == NULL)
 816       return OK;
 817    if (gss_conn->context != GSS_C_NO_CONTEXT)
 818       gss_delete_sec_context(&minor_status, &gss_conn->context,
 819                              GSS_C_NO_BUFFER);
 820    if (gss_conn->server_creds != GSS_C_NO_CREDENTIAL)
 821       gss_release_cred(&minor_status, &gss_conn->server_creds);
 822
 823    gss_connection = NULL;
 824
 825    return OK;
 826 }
 827
 828 static int
 829 store_gss_creds(request_rec *r, kerb_auth_config *conf, char *princ_name,
 830                 gss_cred_id_t delegated_cred)
 831 {
 832    OM_uint32 maj_stat, min_stat;
 833    krb5_principal princ = NULL;
 834    krb5_ccache ccache = NULL;
 835    krb5_error_code problem;
 836    krb5_context context;
 837    int ret = HTTP_INTERNAL_SERVER_ERROR;
 838
 839    problem = krb5_init_context(&context);
 840    if (problem) {
 841       log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "Cannot initialize krb5 context");
 842       return HTTP_INTERNAL_SERVER_ERROR;
 843    }
 844
 845    problem = krb5_parse_name(context, princ_name, &princ);
 846    if (problem) {
 847       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 848          "Cannot parse delegated username (%s)", krb5_get_err_text(context, problem));
 849       goto end;
 850    }
 851
 852    problem = create_krb5_ccache(context, r, conf, princ, &ccache);
 853    if (problem) {
 854       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 855          "Cannot create krb5 ccache (%s)", krb5_get_err_text(context, problem));
 856       goto end;
 857    }
 858
 859    maj_stat = gss_krb5_copy_ccache(&min_stat, delegated_cred, ccache);
 860    if (GSS_ERROR(maj_stat)) {
 861       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 862          "Cannot store delegated credential (%s)",
 863          get_gss_error(r->pool, maj_stat, min_stat, "gss_krb5_copy_ccache"));
 864       goto end;
 865    }
 866
 867    krb5_cc_close(context, ccache);
 868    ccache = NULL;
 869    ret = 0;
 870
 871 end:
 872    if (princ)
 873       krb5_free_principal(context, princ);
 874    if (ccache)
 875       krb5_cc_destroy(context, ccache);
 876    krb5_free_context(context);
 877    return ret;
 878 }
 879
 880 static int
 881 get_gss_creds(request_rec *r,
 882               kerb_auth_config *conf,
 883               gss_cred_id_t *server_creds)
 884 {
 885    gss_buffer_desc input_token = GSS_C_EMPTY_BUFFER;
 886    OM_uint32 major_status, minor_status, minor_status2;
 887    gss_name_t server_name = GSS_C_NO_NAME;
 888    char buf[1024];
 889
 890 #if 0
 891    /* Don't specify service name. This makes MIT 1.3 not to use replay caches,
 892     * which causes large problems with the Microsoft krb5 implementation. MS
 893     * obviously uses a format of the krb5 authenticator that is considered by
 894     * the MIT as replay (Two valid MS authenticators may contain the same time
 895     * and utime fields and only differ in the sequential numbers).
 896     */
 897    snprintf(buf, sizeof(buf), "%s@%s", conf->krb_service_name,
 898          ap_get_server_name(r));
 899
 900    input_token.value = buf;
 901    input_token.length = strlen(buf) + 1;
 902
 903    major_status = gss_import_name(&minor_status, &input_token,
 904                                   GSS_C_NT_HOSTBASED_SERVICE,
 905                                   &server_name);
 906    if (GSS_ERROR(major_status)) {
 907       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 908                  "%s", get_gss_error(r->pool, major_status, minor_status,
 909                  "gss_import_name() failed"));
 910       return HTTP_INTERNAL_SERVER_ERROR;
 911    }
 912 #endif
 913
 914    major_status = gss_acquire_cred(&minor_status, server_name, GSS_C_INDEFINITE,
 915                                    GSS_C_NO_OID_SET, GSS_C_ACCEPT,
 916                                    server_creds, NULL, NULL);
 917    gss_release_name(&minor_status2, &server_name);
 918    if (GSS_ERROR(major_status)) {
 919       log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 920                  "%s", get_gss_error(r->pool, major_status, minor_status,
 921                                      "gss_acquire_cred() failed"));
 922       return HTTP_INTERNAL_SERVER_ERROR;
 923    }
 924
 925    return 0;
 926 }
 927
 928 static int
 929 cmp_gss_type(gss_buffer_t token, gss_OID oid)
 930 {
 931    unsigned char *p;
 932    size_t len;
 933
 934    if (token->length == 0)
 935       return GSS_S_DEFECTIVE_TOKEN;
 936
 937    p = token->value;
 938    if (*p++ != 0x60)
 939       return GSS_S_DEFECTIVE_TOKEN;
 940    len = *p++;
 941    if (len & 0x80) {
 942       if ((len & 0x7f) > 4)
 943          return GSS_S_DEFECTIVE_TOKEN;
 944       p += len & 0x7f;
 945    }
 946    if (*p++ != 0x06)
 947       return GSS_S_DEFECTIVE_TOKEN;
 948
 949    if (((OM_uint32) *p++) != oid->length)
 950       return GSS_S_DEFECTIVE_TOKEN;
 951
 952    return memcmp(p, oid->elements, oid->length);
 953 }
 954
 955 static int
 956 authenticate_user_gss(request_rec *r, kerb_auth_config *conf,
 957                       const char *auth_line, char **negotiate_ret_value)
 958 {
 959   OM_uint32 major_status, minor_status, minor_status2;
 960   gss_buffer_desc input_token = GSS_C_EMPTY_BUFFER;
 961   gss_buffer_desc output_token = GSS_C_EMPTY_BUFFER;
 962   const char *auth_param = NULL;
 963   int ret;
 964   gss_name_t client_name = GSS_C_NO_NAME;
 965   gss_cred_id_t delegated_cred = GSS_C_NO_CREDENTIAL;
 966   OM_uint32 (*accept_sec_token)();
 967   gss_OID_desc spnego_oid;
 968
 969   *negotiate_ret_value = "\0";
 970
 971   spnego_oid.length = 6;
 972   spnego_oid.elements = (void *)"\x2b\x06\x01\x05\x05\x02";
 973
 974   if (gss_connection == NULL) {
 975      gss_connection = ap_pcalloc(r->connection->pool, sizeof(*gss_connection));
 976      if (gss_connection == NULL) {
 977         log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 978                    "ap_pcalloc() failed (not enough memory)");
 979         ret = HTTP_INTERNAL_SERVER_ERROR;
 980         goto end;
 981      }
 982      memset(gss_connection, 0, sizeof(*gss_connection));
 983      ap_register_cleanup(r->connection->pool, gss_connection, cleanup_gss_connection, ap_null_cleanup);
 984   }
 985
 986   if (conf->krb_5_keytab) {
 987      char *ktname;
 988      /* we don't use the ap_* calls here, since the string passed to putenv()
 989       * will become part of the enviroment and shouldn't be free()ed by apache
 990       */
 991      ktname = malloc(strlen("KRB5_KTNAME=") + strlen(conf->krb_5_keytab) + 1);
 992      if (ktname == NULL) {
 993         log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "malloc() failed: not enough memory");
 994         ret = HTTP_INTERNAL_SERVER_ERROR;
 995         goto end;
 996      }
 997      sprintf(ktname, "KRB5_KTNAME=%s", conf->krb_5_keytab);
 998      putenv(ktname);
 999   }
1000
1001   if (gss_connection->server_creds == GSS_C_NO_CREDENTIAL) {
1002      ret = get_gss_creds(r, conf, &gss_connection->server_creds);
1003      if (ret)
1004         goto end;
1005   }
1006
1007   /* ap_getword() shifts parameter */
1008   auth_param = ap_getword_white(r->pool, &auth_line);
1009   if (auth_param == NULL) {
1010      log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
1011                 "No Authorization parameter in request from client");
1012      ret = HTTP_UNAUTHORIZED;
1013      goto end;
1014   }
1015
1016   input_token.length = ap_base64decode_len(auth_param) + 1;
1017   input_token.value = ap_pcalloc(r->connection->pool, input_token.length);
1018   if (input_token.value == NULL) {
1019      log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
1020                 "ap_pcalloc() failed (not enough memory)");
1021      ret = HTTP_INTERNAL_SERVER_ERROR;
1022      goto end;
1023   }
1024   input_token.length = ap_base64decode(input_token.value, auth_param);
1025
1026   accept_sec_token = (cmp_gss_type(&input_token, &spnego_oid) == 0) ?
1027                         gss_accept_sec_context_spnego : gss_accept_sec_context;
1028
1029   major_status = accept_sec_token(&minor_status,
1030                                   &gss_connection->context,
1031                                   gss_connection->server_creds,
1032                                   &input_token,
1033                                   GSS_C_NO_CHANNEL_BINDINGS,
1034                                   &client_name,
1035                                   NULL,
1036                                   &output_token,
1037                                   NULL,
1038                                   NULL,
1039                                   &delegated_cred);
1040   if (output_token.length) {
1041      char *token = NULL;
1042      size_t len;
1043
1044      len = ap_base64encode_len(output_token.length) + 1;
1045      token = ap_pcalloc(r->connection->pool, len + 1);
1046      if (token == NULL) {
1047         log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
1048                    "ap_pcalloc() failed (not enough memory)");
1049         ret = HTTP_INTERNAL_SERVER_ERROR;
1050         gss_release_buffer(&minor_status2, &output_token);
1051         goto end;
1052      }
1053      ap_base64encode(token, output_token.value, output_token.length);
1054      token[len] = '\0';
1055      *negotiate_ret_value = token;
1056      gss_release_buffer(&minor_status2, &output_token);
1057   }
1058
1059   if (GSS_ERROR(major_status)) {
1060      log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
1061                 "%s", get_gss_error(r->pool, major_status, minor_status,
1062                                     "gss_accept_sec_context() failed"));
1063      /* Don't offer the Negotiate method again if call to GSS layer failed */
1064      *negotiate_ret_value = NULL;
1065      ret = HTTP_UNAUTHORIZED;
1066      goto end;
1067   }
1068
1069   if (major_status & GSS_S_CONTINUE_NEEDED) {
1070      /* Some GSSAPI mechanism (eg GSI from Globus) may require multiple
1071       * iterations to establish authentication */
1072      ret = HTTP_UNAUTHORIZED;
1073      goto end;
1074   }
1075
1076   major_status = gss_display_name(&minor_status, client_name, &output_token, NULL);
1077   gss_release_name(&minor_status, &client_name);
1078   if (GSS_ERROR(major_status)) {
1079     log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
1080                "%s", get_gss_error(r->pool, major_status, minor_status,
1081                                    "gss_export_name() failed"));
1082     ret = HTTP_INTERNAL_SERVER_ERROR;
1083     goto end;
1084   }
1085
1086   MK_AUTH_TYPE = "Negotiate";
1087   MK_USER = ap_pstrdup(r->pool, output_token.value);
1088
1089   if (conf->krb_save_credentials && delegated_cred != GSS_C_NO_CREDENTIAL)
1090      store_gss_creds(r, conf, (char *)output_token.value, delegated_cred);
1091
1092   if (*negotiate_ret_value)
1093      set_kerb_auth_headers(r, conf, 0, 0, *negotiate_ret_value);
1094
1095   gss_release_buffer(&minor_status, &output_token);
1096
1097   ret = OK;
1098
1099 end:
1100   if (delegated_cred)
1101      gss_release_cred(&minor_status, &delegated_cred);
1102
1103   if (output_token.length)
1104      gss_release_buffer(&minor_status, &output_token);
1105
1106   if (client_name != GSS_C_NO_NAME)
1107      gss_release_name(&minor_status, &client_name);
1108
1109   if (! major_status & GSS_S_CONTINUE_NEEDED)
1110      cleanup_gss_connection(gss_connection);
1111
1112   return ret;
1113 }
1114 #endif /* KRB5 */
1115
1116 static int
1117 already_succeeded(request_rec *r)
1118 {
1119    if (ap_is_initial_req(r) || MK_AUTH_TYPE == NULL)
1120       return 0;
1121    if (strcmp(MK_AUTH_TYPE, "Negotiate") ||
1122        (strcmp(MK_AUTH_TYPE, "Basic") && strchr(MK_USER, '@')))
1123       return 1;
1124    return 0;
1125 }
1126
1127 static void
1128 set_kerb_auth_headers(request_rec *r, const kerb_auth_config *conf,
1129                       int use_krb4, int use_krb5pwd, char *negotiate_ret_value)
1130 {
1131    const char *auth_name = NULL;
1132    int set_basic = 0;
1133    char *negoauth_param;
1134    const char *header_name =
1135       (r->proxyreq == PROXYREQ_PROXY) ? "Proxy-Authenticate" : "WWW-Authenticate";
1136
1137    /* get the user realm specified in .htaccess */
1138    auth_name = ap_auth_name(r);
1139
1140    /* XXX should the WWW-Authenticate header be cleared first? */
1141 #ifdef KRB5
1142    if (negotiate_ret_value != NULL && conf->krb_method_gssapi) {
1143       negoauth_param = (*negotiate_ret_value == '\0') ? "Negotiate" :
1144                   ap_pstrcat(r->pool, "Negotiate ", negotiate_ret_value, NULL);
1145       ap_table_add(r->err_headers_out, header_name, negoauth_param);
1146    }
1147    if (use_krb5pwd && conf->krb_method_k5pass) {
1148       ap_table_add(r->err_headers_out, header_name,
1149                    ap_pstrcat(r->pool, "Basic realm=\"", auth_name, "\"", NULL));
1150       set_basic = 1;
1151    }
1152 #endif
1153
1154 #ifdef KRB4
1155    if (use_krb4 && conf->krb_method_k4pass && !set_basic)
1156       ap_table_add(r->err_headers_out, header_name,
1157                   ap_pstrcat(r->pool, "Basic realm=\"", auth_name, "\"", NULL));
1158 #endif
1159 }
1160
1161 int kerb_authenticate_user(request_rec *r)
1162 {
1163    kerb_auth_config *conf =
1164       (kerb_auth_config *) ap_get_module_config(r->per_dir_config,
1165                                                 &auth_kerb_module);
1166    const char *auth_type = NULL;
1167    const char *auth_line = NULL;
1168    const char *type = NULL;
1169    int use_krb5 = 0, use_krb4 = 0;
1170    int ret;
1171    static int last_return = HTTP_UNAUTHORIZED;
1172    char *negotiate_ret_value = NULL;
1173
1174    /* get the type specified in .htaccess */
1175    type = ap_auth_type(r);
1176
1177    if (type && strcasecmp(type, "Kerberos") == 0)
1178       use_krb5 = use_krb4 = 1;
1179    else if(type && strcasecmp(type, "KerberosV5") == 0)
1180       use_krb4 = 0;
1181    else if(type && strcasecmp(type, "KerberosV4") == 0)
1182       use_krb5 = 0;
1183    else
1184       return DECLINED;
1185
1186    /* get what the user sent us in the HTTP header */
1187    auth_line = MK_TABLE_GET(r->headers_in, "Authorization");
1188    if (!auth_line) {
1189        auth_line = MK_TABLE_GET(r->headers_in, "Proxy-Authorization");
1190        if (!auth_line) {
1191                set_kerb_auth_headers(r, conf, use_krb4, use_krb5,
1192                                      (use_krb5) ? "\0" : NULL);
1193                return HTTP_UNAUTHORIZED;
1194        }
1195    }
1196    auth_type = ap_getword_white(r->pool, &auth_line);
1197
1198    if (already_succeeded(r))
1199       return last_return;
1200
1201    ret = HTTP_UNAUTHORIZED;
1202
1203 #ifdef KRB5
1204    if (use_krb5 && conf->krb_method_gssapi &&
1205        strcasecmp(auth_type, "Negotiate") == 0) {
1206       ret = authenticate_user_gss(r, conf, auth_line, &negotiate_ret_value);
1207    } else if (use_krb5 && conf->krb_method_k5pass &&
1208               strcasecmp(auth_type, "Basic") == 0) {
1209        ret = authenticate_user_krb5pwd(r, conf, auth_line);
1210    }
1211 #endif
1212
1213 #ifdef KRB4
1214    if (ret == HTTP_UNAUTHORIZED && use_krb4 && conf->krb_method_k4pass &&
1215        strcasecmp(auth_type, "Basic") == 0)
1216       ret = authenticate_user_krb4pwd(r, conf, auth_line);
1217 #endif
1218
1219    if (ret == HTTP_UNAUTHORIZED)
1220       set_kerb_auth_headers(r, conf, use_krb4, use_krb5, negotiate_ret_value);
1221
1222    last_return = ret;
1223    return ret;
1224 }
1225
1226
1227 /***************************************************************************
1228  Module Setup/Configuration
1229  ***************************************************************************/
1230 #ifndef STANDARD20_MODULE_STUFF
1231 module MODULE_VAR_EXPORT auth_kerb_module = {
1232         STANDARD_MODULE_STUFF,
1233         NULL,                           /*      module initializer            */
1234         kerb_dir_create_config,         /*      per-directory config creator  */
1235         NULL,                           /*      per-directory config merger   */
1236         NULL,                           /*      per-server    config creator  */
1237         NULL,                           /*      per-server    config merger   */
1238         kerb_auth_cmds,                 /*      command table                 */
1239         NULL,                           /* [ 9] content handlers              */
1240         NULL,                           /* [ 2] URI-to-filename translation   */
1241         kerb_authenticate_user,         /* [ 5] check/validate user_id        */
1242         NULL,                           /* [ 6] check user_id is valid *here* */
1243         NULL,                           /* [ 4] check access by host address  */
1244         NULL,                           /* [ 7] MIME type checker/setter      */
1245         NULL,                           /* [ 8] fixups                        */
1246         NULL,                           /* [10] logger                        */
1247         NULL,                           /* [ 3] header parser                 */
1248         NULL,                           /*      process initialization        */
1249         NULL,                           /*      process exit/cleanup          */
1250         NULL                            /* [ 1] post read_request handling    */
1251 };
1252 #else
1253 static int
1254 kerb_init_handler(apr_pool_t *p, apr_pool_t *plog,
1255                   apr_pool_t *ptemp, server_rec *s)
1256 {
1257    ap_add_version_component(p, "mod_auth_kerb/" MODAUTHKERB_VERSION);
1258    return OK;
1259 }
1260
1261 void kerb_register_hooks(apr_pool_t *p)
1262 {
1263    ap_hook_post_config(kerb_init_handler, NULL, NULL, APR_HOOK_MIDDLE);
1264    ap_hook_check_user_id(kerb_authenticate_user, NULL, NULL, APR_HOOK_MIDDLE);
1265 }
1266
1267 module AP_MODULE_DECLARE_DATA auth_kerb_module =
1268 {
1269    STANDARD20_MODULE_STUFF,
1270    kerb_dir_create_config,      /* create per-dir    conf structures  */
1271    NULL,                        /* merge  per-dir    conf structures  */
1272    NULL,                        /* create per-server conf structures  */
1273    NULL,                        /* merge  per-server conf structures  */
1274    kerb_auth_cmds,              /* table of configuration directives  */
1275    kerb_register_hooks          /* register hooks                     */
1276 };
1277 #endif