src/sessions.c

   1 /* Copyright (C) 2014 mod_auth_gssapi authors - See COPYING for (C) terms */
   2
   3 #include "mod_auth_gssapi.h"
   4 #include "asn1c/GSSSessionData.h"
   5
   6 APLOG_USE_MODULE(auth_gssapi);
   7
   8 static APR_OPTIONAL_FN_TYPE(ap_session_load) *mag_sess_load_fn = NULL;
   9 static APR_OPTIONAL_FN_TYPE(ap_session_get) *mag_sess_get_fn = NULL;
  10 static APR_OPTIONAL_FN_TYPE(ap_session_set) *mag_sess_set_fn = NULL;
  11
  12 void mag_post_config_session(void)
  13 {
  14     mag_sess_load_fn = APR_RETRIEVE_OPTIONAL_FN(ap_session_load);
  15     mag_sess_get_fn = APR_RETRIEVE_OPTIONAL_FN(ap_session_get);
  16     mag_sess_set_fn = APR_RETRIEVE_OPTIONAL_FN(ap_session_set);
  17 }
  18
  19 static apr_status_t mag_session_load(request_rec *req, session_rec **sess)
  20 {
  21     if (mag_sess_load_fn) {
  22         return mag_sess_load_fn(req, sess);
  23     }
  24     return DECLINED;
  25 }
  26
  27 static apr_status_t mag_session_get(request_rec *req, session_rec *sess,
  28                                     const char *key, const char **value)
  29 {
  30     if (mag_sess_get_fn) {
  31         return mag_sess_get_fn(req, sess, key, value);
  32     }
  33     return DECLINED;
  34 }
  35
  36 static apr_status_t mag_session_set(request_rec *req, session_rec *sess,
  37                                     const char *key, const char *value)
  38 {
  39     if (mag_sess_set_fn) {
  40         return mag_sess_set_fn(req, sess, key, value);
  41     }
  42     return DECLINED;
  43 }
  44
  45 static bool encode_GSSSessionData(apr_pool_t *mempool,
  46                                   GSSSessionData_t *gsessdata,
  47                                   unsigned char **buf, int *len)
  48 {
  49     asn_enc_rval_t rval;
  50     unsigned char *buffer = NULL;
  51     size_t buflen;
  52     bool ret = false;
  53
  54     /* dry run to compute the size */
  55     rval = der_encode(&asn_DEF_GSSSessionData, gsessdata, NULL, NULL);
  56     if (rval.encoded == -1) goto done;
  57
  58     buflen = rval.encoded;
  59     buffer = apr_pcalloc(mempool, buflen);
  60
  61     /* now for real */
  62     rval = der_encode_to_buffer(&asn_DEF_GSSSessionData,
  63                                 gsessdata, buffer, buflen);
  64     if (rval.encoded == -1) goto done;
  65
  66     *buf = buffer;
  67     *len = buflen;
  68     ret = true;
  69
  70 done:
  71     return ret;
  72 }
  73
  74 static GSSSessionData_t *decode_GSSSessionData(void *buf, size_t len)
  75 {
  76     GSSSessionData_t *gsessdata = NULL;
  77     asn_dec_rval_t rval;
  78
  79     rval = ber_decode(NULL, &asn_DEF_GSSSessionData,
  80                       (void **)&gsessdata, buf, len);
  81     if (rval.code == RC_OK) {
  82         return gsessdata;
  83     }
  84     return NULL;
  85 }
  86
  87 #define MAG_BEARER_KEY "MagBearerToken"
  88
  89 void mag_check_session(struct mag_req_cfg *cfg, struct mag_conn **conn)
  90 {
  91     request_rec *req = cfg->req;
  92     struct mag_conn *mc;
  93     apr_status_t rc;
  94     session_rec *sess = NULL;
  95     const char *sessval = NULL;
  96     int declen;
  97     struct databuf ctxbuf = { 0 };
  98     struct databuf cipherbuf = { 0 };
  99     GSSSessionData_t *gsessdata;
 100     time_t expiration;
 101
 102     rc = mag_session_load(req, &sess);
 103     if (rc != OK || sess == NULL) {
 104         ap_log_rerror(APLOG_MARK, APLOG_INFO|APLOG_NOERRNO, 0, req,
 105                       "Sessions not available, no cookies!");
 106         return;
 107     }
 108
 109     mc = *conn;
 110     if (!mc) {
 111         *conn = mc = mag_new_conn_ctx(req->pool);
 112         mc->is_preserved = true;
 113     }
 114
 115     rc = mag_session_get(req, sess, MAG_BEARER_KEY, &sessval);
 116     if (rc != OK) {
 117         ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, req,
 118                       "Failed to get session data!");
 119         return;
 120     }
 121     if (!sessval) {
 122         /* no session established, just return */
 123         return;
 124     }
 125
 126     if (!cfg->mag_skey) {
 127         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, req,
 128                       "Session key not available, no cookies!");
 129         /* we do not have a key, just return */
 130         return;
 131     }
 132
 133     /* decode it */
 134     declen = apr_base64_decode_len(sessval);
 135     cipherbuf.value = apr_palloc(req->pool, declen);
 136     if (!cipherbuf.value) return;
 137     cipherbuf.length = (int)apr_base64_decode((char *)cipherbuf.value, sessval);
 138
 139     rc = UNSEAL_BUFFER(req->pool, cfg->mag_skey, &cipherbuf, &ctxbuf);
 140     if (rc != OK) {
 141         ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, req,
 142                       "Failed to unseal session data!");
 143         return;
 144     }
 145
 146     gsessdata = decode_GSSSessionData(ctxbuf.value, ctxbuf.length);
 147     if (!gsessdata) {
 148         ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, req,
 149                       "Failed to unpack session data!");
 150         return;
 151     }
 152
 153     /* booleans */
 154     if (gsessdata->established != 0) mc->established = true;
 155     if (gsessdata->delegated != 0) mc->delegated = true;
 156
 157     /* get time */
 158     expiration = gsessdata->expiration;
 159     if (expiration < time(NULL)) {
 160         /* credentials fully expired, return nothing */
 161         mc->established = false;
 162         goto done;
 163     }
 164
 165     /* user name */
 166     mc->user_name = apr_pstrndup(mc->pool,
 167                                  (char *)gsessdata->username.buf,
 168                                  gsessdata->username.size);
 169     if (!mc->user_name) goto done;
 170
 171     /* gssapi name */
 172     mc->gss_name = apr_pstrndup(mc->pool,
 173                                 (char *)gsessdata->gssname.buf,
 174                                 gsessdata->gssname.size);
 175     if (!mc->gss_name) goto done;
 176
 177     mc->basic_hash.length = gsessdata->basichash.size;
 178     mc->basic_hash.value = apr_palloc(mc->pool, mc->basic_hash.length);
 179     memcpy(mc->basic_hash.value,
 180            gsessdata->basichash.buf, gsessdata->basichash.size);
 181
 182     /* OK we have a valid token */
 183     mc->established = true;
 184
 185 done:
 186     ASN_STRUCT_FREE(asn_DEF_GSSSessionData, gsessdata);
 187 }
 188
 189 void mag_attempt_session(struct mag_req_cfg *cfg, struct mag_conn *mc)
 190 {
 191     request_rec *req = cfg->req;
 192     session_rec *sess = NULL;
 193     struct databuf plainbuf = { 0 };
 194     struct databuf cipherbuf = { 0 };
 195     struct databuf ctxbuf = { 0 };
 196     GSSSessionData_t gsessdata = { 0 };
 197     apr_status_t rc;
 198     bool ret;
 199
 200     /* we save the session only if the authentication is established */
 201
 202     if (!mc->established) return;
 203     rc = mag_session_load(req, &sess);
 204     if (rc != OK || sess == NULL) {
 205         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, req,
 206                       "Sessions not available, can't send cookies!");
 207         return;
 208     }
 209
 210     if (!cfg->mag_skey) {
 211         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, req,
 212                       "Session key not available, aborting.");
 213         return;
 214     }
 215
 216     gsessdata.established = mc->established?1:0;
 217     gsessdata.delegated = mc->delegated?1:0;
 218     gsessdata.expiration = mc->expiration;
 219     if (OCTET_STRING_fromString(&gsessdata.username, mc->user_name) != 0)
 220         goto done;
 221     if (OCTET_STRING_fromString(&gsessdata.gssname, mc->gss_name) != 0)
 222         goto done;
 223     if (OCTET_STRING_fromBuf(&gsessdata.basichash,
 224                              (const char *)mc->basic_hash.value,
 225                              mc->basic_hash.length) != 0)
 226         goto done;
 227     ret = encode_GSSSessionData(req->pool, &gsessdata,
 228                                 &plainbuf.value, &plainbuf.length);
 229     if (ret == false) {
 230         ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, req,
 231                       "Failed to pack session data!");
 232         goto done;
 233     }
 234
 235     rc = SEAL_BUFFER(req->pool, cfg->mag_skey, &plainbuf, &cipherbuf);
 236     if (rc != OK) {
 237         ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, req,
 238                       "Failed to seal session data!");
 239         goto done;
 240     }
 241
 242     ctxbuf.length = apr_base64_encode_len(cipherbuf.length);
 243     ctxbuf.value = apr_pcalloc(req->pool, ctxbuf.length);
 244     if (!ctxbuf.value) goto done;
 245
 246     ctxbuf.length = apr_base64_encode((char *)ctxbuf.value,
 247                                       (char *)cipherbuf.value,
 248                                       cipherbuf.length);
 249
 250     rc = mag_session_set(req, sess, MAG_BEARER_KEY, (char *)ctxbuf.value);
 251     if (rc != OK) {
 252         ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, req,
 253                       "Failed to set session data!");
 254     }
 255
 256 done:
 257     ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_GSSSessionData, &gsessdata);
 258 }
 259
 260 static int mag_basic_hmac(struct seal_key *key, unsigned char *mac,
 261                           gss_buffer_desc user, gss_buffer_desc pwd)
 262 {
 263     struct databuf hmacbuf = { mac, 0 };
 264     int data_size = user.length + pwd.length + 1;
 265     unsigned char data[data_size];
 266     struct databuf databuf = { data, data_size };
 267
 268     memcpy(data, user.value, user.length);
 269     data[user.length] = '\0';
 270     memcpy(&data[user.length + 1], pwd.value, pwd.length);
 271
 272     return HMAC_BUFFER(key, &databuf, &hmacbuf);
 273 }
 274
 275 static int mag_get_mac_size(struct mag_req_cfg *cfg)
 276 {
 277     if (!cfg->mag_skey) {
 278         ap_log_perror(APLOG_MARK, APLOG_INFO, 0, cfg->cfg->pool,
 279                       "Session key not available, aborting!");
 280         return 0;
 281     }
 282
 283     return get_mac_size(cfg->mag_skey);
 284 }
 285
 286 bool mag_basic_check(struct mag_req_cfg *cfg, struct mag_conn *mc,
 287                      gss_buffer_desc user, gss_buffer_desc pwd)
 288 {
 289     int mac_size = mag_get_mac_size(cfg);
 290     unsigned char mac[mac_size];
 291     int ret, i, j;
 292     bool res = false;
 293
 294     if (mac_size == 0) return false;
 295     if (mc->basic_hash.value == NULL) return false;
 296
 297     ret = mag_basic_hmac(cfg->mag_skey, mac, user, pwd);
 298     if (ret != 0) goto done;
 299
 300     for (i = 0, j = 0; i < mac_size; i++) {
 301         if (mc->basic_hash.value[i] != mac[i]) j++;
 302     }
 303     if (j == 0) res = true;
 304
 305 done:
 306     if (res == false) {
 307         mc->basic_hash.value = NULL;
 308         mc->basic_hash.length = 0;
 309     }
 310     return res;
 311 }
 312
 313 void mag_basic_cache(struct mag_req_cfg *cfg, struct mag_conn *mc,
 314                      gss_buffer_desc user, gss_buffer_desc pwd)
 315 {
 316     int mac_size = mag_get_mac_size(cfg);
 317     unsigned char mac[mac_size];
 318     int ret;
 319
 320     ret = mag_basic_hmac(cfg->mag_skey, mac, user, pwd);
 321     if (ret != 0) return;
 322
 323     mc->basic_hash.length = mac_size;
 324     mc->basic_hash.value = apr_palloc(mc->pool, mac_size);
 325     memcpy(mc->basic_hash.value, mac, mac_size);
 326 }