#define _XOPEN_SOURCE /* glibc2 needs this to declare strptime() */
#include <time.h>
#include <string.h>
-#include <ctype.h>
#include <openssl/ssl.h>
#include <openssl/evp.h>
#define valid_cksumtype kssl_valid_cksumtype
#define krb5_checksum_size kssl_krb5_checksum_size
#define krb5_kt_free_entry kssl_krb5_kt_free_entry
+#define krb5_auth_con_setrcache kssl_krb5_auth_con_setrcache
+#define krb5_auth_con_getrcache kssl_krb5_auth_con_getrcache
+#define krb5_get_server_rcache kssl_krb5_get_server_rcache
/* Prototypes for built in stubs */
void kssl_krb5_free_data_contents(krb5_context, krb5_data *);
size_t kssl_krb5_checksum_size(krb5_context context,krb5_cksumtype ctype);
krb5_boolean kssl_valid_cksumtype(krb5_cksumtype ctype);
krb5_error_code krb5_kt_free_entry(krb5_context,krb5_keytab_entry FAR * );
+krb5_error_code kssl_krb5_auth_con_setrcache(krb5_context,
+ krb5_auth_context,
+ krb5_rcache);
+krb5_error_code kssl_krb5_get_server_rcache(krb5_context,
+ krb5_const krb5_data *,
+ krb5_rcache *);
+krb5_error_code kssl_krb5_auth_con_getrcache(krb5_context,
+ krb5_auth_context,
+ krb5_rcache *);
/* Function pointers (almost all Kerberos functions are _stdcall) */
static void (_stdcall *p_krb5_free_data_contents)(krb5_context, krb5_data *)
static krb5_boolean (_stdcall *p_valid_cksumtype)(krb5_cksumtype ctype)=NULL;
static krb5_error_code (_stdcall *p_krb5_kt_free_entry)
(krb5_context,krb5_keytab_entry * )=NULL;
+static krb5_error_code (_stdcall * p_krb5_auth_con_setrcache)(krb5_context,
+ krb5_auth_context,
+ krb5_rcache)=NULL;
+static krb5_error_code (_stdcall * p_krb5_get_server_rcache)(krb5_context,
+ krb5_const krb5_data *,
+ krb5_rcache *)=NULL;
+static krb5_error_code (* p_krb5_auth_con_getrcache)(krb5_context,
+ krb5_auth_context,
+ krb5_rcache *)=NULL;
static int krb5_loaded = 0; /* only attempt to initialize func ptrs once */
/* Function to Load the Kerberos 5 DLL and initialize function pointers */
GetProcAddress( hKRB5_32, "krb5_checksum_size" );
(FARPROC) p_krb5_kt_free_entry =
GetProcAddress( hKRB5_32, "krb5_kt_free_entry" );
+ (FARPROC) p_krb5_auth_con_setrcache =
+ GetProcAddress( hKRB5_32, "krb5_auth_con_setrcache" );
+ (FARPROC) p_krb5_get_server_rcache =
+ GetProcAddress( hKRB5_32, "krb5_get_server_rcache" );
+ (FARPROC) p_krb5_auth_con_getrcache =
+ GetProcAddress( hKRB5_32, "krb5_auth_con_getrcache" );
}
/* Stubs for each function to be dynamicly loaded */
return(krb5_x
((cache)->ops->get_princ,(context, cache, principal)));
}
-#else
+
+krb5_error_code
+kssl_krb5_auth_con_setrcache(krb5_context con, krb5_auth_context acon,
+ krb5_rcache rcache)
+ {
+ if ( p_krb5_auth_con_setrcache )
+ return(p_krb5_auth_con_setrcache(con,acon,rcache));
+ else
+ return KRB5KRB_ERR_GENERIC;
+ }
+
+krb5_error_code
+kssl_krb5_get_server_rcache(krb5_context con, krb5_const krb5_data * data,
+ krb5_rcache * rcache)
+ {
+ if ( p_krb5_get_server_rcache )
+ return(p_krb5_get_server_rcache(con,data,rcache));
+ else
+ return KRB5KRB_ERR_GENERIC;
+ }
+
+krb5_error_code
+kssl_krb5_auth_con_getrcache(krb5_context con, krb5_auth_context acon,
+ krb5_rcache * prcache)
+ {
+ if ( p_krb5_auth_con_getrcache )
+ return(p_krb5_auth_con_getrcache(con,acon, prcache));
+ else
+ return KRB5KRB_ERR_GENERIC;
+ }
#endif /* OPENSSL_SYS_WINDOWS || OPENSSL_SYS_WIN32 */
char
}
-/* Given KRB5 enctype (basically DES or 3DES), return
+/* Given KRB5 enctype (basically DES or 3DES),
+** return closest match openssl EVP_ encryption algorithm.
+** Return NULL for unknown or problematic (krb5_dk_encrypt) enctypes.
+** Assume ENCTYPE_*_RAW (krb5_raw_encrypt) are OK.
*/
EVP_CIPHER *
kssl_map_enc(krb5_enctype enctype)
{
switch (enctype)
{
+ case ENCTYPE_DES_HMAC_SHA1: /* EVP_des_cbc(); */
case ENCTYPE_DES_CBC_CRC:
case ENCTYPE_DES_CBC_MD4:
case ENCTYPE_DES_CBC_MD5:
case ENCTYPE_DES_CBC_RAW:
-#if ! defined(KRB5_MIT_OLD11)
- case ENCTYPE_DES_HMAC_SHA1:
-#endif
return (EVP_CIPHER *) EVP_des_cbc();
break;
+ case ENCTYPE_DES3_CBC_SHA1: /* EVP_des_ede3_cbc(); */
case ENCTYPE_DES3_CBC_SHA:
case ENCTYPE_DES3_CBC_RAW:
-#if ! defined(KRB5_MIT_OLD11)
- case ENCTYPE_DES3_CBC_SHA1:
-#endif
return (EVP_CIPHER *) EVP_des_ede3_cbc();
break;
default: return (EVP_CIPHER *) NULL;
** what the highest assigned CKSUMTYPE_ constant is. As of 1.2.2
** it is 0x000c (CKSUMTYPE_HMAC_SHA1_DES3). So we will use 0x0010.
*/
-int *populate_cksumlens(void)
+size_t *populate_cksumlens(void)
{
- int i, j, n = 0x0010+1;
+ int i, j, n;
static size_t *cklens = NULL;
+#ifdef KRB5_MIT_OLD11
+ n = krb5_max_cksum;
+#else
+ n = 0x0010;
+#endif /* KRB5_MIT_OLD11 */
+
#ifdef KRB5CHECKAUTH
- if (!cklens && !(cklens = (size_t *) calloc(sizeof(int), n))) return NULL;
+ if (!cklens && !(cklens = (size_t *) calloc(sizeof(int),n+1))) return NULL;
for (i=0; i < n; i++) {
if (!valid_cksumtype(i)) continue; /* array has holes */
*/
unsigned char *kssl_skip_confound(krb5_enctype etype, unsigned char *a)
{
- int i, cklen, conlen;
- static int *cksumlens = NULL;
+ int i, conlen;
+ size_t cklen;
+ static size_t *cksumlens = NULL;
unsigned char *test_auth;
conlen = (etype)? 8: 0;
}
arlen = krb5_app_req.length;
- p = krb5_app_req.data;
+ p = (unsigned char *)krb5_app_req.data;
ap_req = (KRB5_APREQBODY *) d2i_KRB5_APREQ(NULL, &p, arlen);
if (ap_req)
{
if (authenp->length &&
(authenp->data = malloc(authenp->length)))
{
- unsigned char *p = authenp->data;
+ unsigned char *adp = (unsigned char *)authenp->data;
authenp->length = i2d_KRB5_ENCDATA(
- ap_req->authenticator, &p);
+ ap_req->authenticator, &adp);
}
}
if (ap_req) KRB5_APREQ_free((KRB5_APREQ *) ap_req);
if (krb5_app_req.length)
- krb5_free_data_contents(krb5context,&krb5_app_req);
+ kssl_krb5_free_data_contents(krb5context,&krb5_app_req);
}
#ifdef KRB5_HEIMDAL
if (kssl_ctx_setkey(kssl_ctx, &krb5credsp->session))
krb5_keytab krb5keytab = NULL;
krb5_keytab_entry kt_entry;
krb5_principal krb5server;
+ krb5_rcache rcache = NULL;
kssl_err_set(kssl_err, 0, "");
if (!kssl_ctx)
{
kssl_err_set(kssl_err, SSL_R_KRB5_S_INIT,
- "No kssl_ctx defined.\n");
+ "No kssl_ctx defined.\n");
goto err;
}
goto err;
}
+
+ if ((krb5rc = krb5_auth_con_getrcache(krb5context, krb5auth_context,
+ &rcache)))
+ {
+ kssl_err_set(kssl_err, SSL_R_KRB5_S_INIT,
+ "krb5_auth_con_getrcache() fails.\n");
+ goto err;
+ }
+
if ((krb5rc = krb5_sname_to_principal(krb5context, NULL,
(kssl_ctx->service_name)? kssl_ctx->service_name: KRB5SVC,
KRB5_NT_SRV_HST, &krb5server)) != 0)
goto err;
}
+ if (rcache == NULL)
+ {
+ if ((krb5rc = krb5_get_server_rcache(krb5context,
+ krb5_princ_component(krb5context, krb5server, 0),
+ &rcache)))
+ {
+ kssl_err_set(kssl_err, SSL_R_KRB5_S_INIT,
+ "krb5_get_server_rcache() fails.\n");
+ goto err;
+ }
+ }
+
+ if ((krb5rc = krb5_auth_con_setrcache(krb5context, krb5auth_context, rcache)))
+ {
+ kssl_err_set(kssl_err, SSL_R_KRB5_S_INIT,
+ "krb5_auth_con_setrcache() fails.\n");
+ goto err;
+ }
+
+
/* kssl_ctx->keytab_file == NULL ==> use Kerberos default
*/
if (kssl_ctx->keytab_file)
** &ap_option, &krb5ticket)) != 0) { Error }
*/
- p = indata->data;
+ p = (unsigned char *)indata->data;
if ((asn1ticket = (KRB5_TKTBODY *) d2i_KRB5_TICKET(NULL, &p,
(long) indata->length)) == NULL)
{
printf("\tcaddrs: %p, authdata: %p\n",
krb5ticket->enc_part2->caddrs,
krb5ticket->enc_part2->authorization_data);
- printf("\tcaddrs:\n");
- for (i=0; paddr[i] != NULL; i++)
- { krb5_data d;
- d.length=paddr[i]->length; d.data=paddr[i]->contents;
- print_krb5_data("\t\tIP: ", &d);
+ if (paddr)
+ {
+ printf("\tcaddrs:\n");
+ for (i=0; paddr[i] != NULL; i++)
+ {
+ krb5_data d;
+ d.length=paddr[i]->length;
+ d.data=paddr[i]->contents;
+ print_krb5_data("\t\tIP: ", &d);
+ }
}
printf("\tstart/auth/end times: %d / %d / %d\n",
krb5ticket->enc_part2->times.starttime,
void
kssl_ctx_show(KSSL_CTX *kssl_ctx)
{
- unsigned int i;
+ int i;
printf("kssl_ctx: ");
if (kssl_ctx == NULL)
return;
}
+ int
+ kssl_keytab_is_available(KSSL_CTX *kssl_ctx)
+{
+ krb5_context krb5context = NULL;
+ krb5_keytab krb5keytab = NULL;
+ krb5_keytab_entry entry;
+ krb5_principal princ = NULL;
+ krb5_error_code krb5rc = KRB5KRB_ERR_GENERIC;
+ int rc = 0;
+
+ if ((krb5rc = krb5_init_context(&krb5context)))
+ return(0);
+
+ /* kssl_ctx->keytab_file == NULL ==> use Kerberos default
+ */
+ if (kssl_ctx->keytab_file)
+ {
+ krb5rc = krb5_kt_resolve(krb5context, kssl_ctx->keytab_file,
+ &krb5keytab);
+ if (krb5rc)
+ goto exit;
+ }
+ else
+ {
+ krb5rc = krb5_kt_default(krb5context,&krb5keytab);
+ if (krb5rc)
+ goto exit;
+ }
+
+ /* the host key we are looking for */
+ krb5rc = krb5_sname_to_principal(krb5context, NULL,
+ kssl_ctx->service_name ? kssl_ctx->service_name: KRB5SVC,
+ KRB5_NT_SRV_HST, &princ);
+
+ krb5rc = krb5_kt_get_entry(krb5context, krb5keytab,
+ princ,
+ 0 /* IGNORE_VNO */,
+ 0 /* IGNORE_ENCTYPE */,
+ &entry);
+ if ( krb5rc == KRB5_KT_NOTFOUND ) {
+ rc = 1;
+ goto exit;
+ } else if ( krb5rc )
+ goto exit;
+
+ krb5_kt_free_entry(krb5context, &entry);
+ rc = 1;
+
+ exit:
+ if (krb5keytab) krb5_kt_close(krb5context, krb5keytab);
+ if (princ) krb5_free_principal(krb5context, princ);
+ if (krb5context) krb5_free_context(krb5context);
+ return(rc);
+}
+
+int
+kssl_tgt_is_available(KSSL_CTX *kssl_ctx)
+ {
+ krb5_error_code krb5rc = KRB5KRB_ERR_GENERIC;
+ krb5_context krb5context = NULL;
+ krb5_ccache krb5ccdef = NULL;
+ krb5_creds krb5creds, *krb5credsp = NULL;
+ int rc = 0;
+
+ memset((char *)&krb5creds, 0, sizeof(krb5creds));
+
+ if (!kssl_ctx)
+ return(0);
+
+ if (!kssl_ctx->service_host)
+ return(0);
+
+ if ((krb5rc = krb5_init_context(&krb5context)) != 0)
+ goto err;
+
+ if ((krb5rc = krb5_sname_to_principal(krb5context,
+ kssl_ctx->service_host,
+ (kssl_ctx->service_name)? kssl_ctx->service_name: KRB5SVC,
+ KRB5_NT_SRV_HST, &krb5creds.server)) != 0)
+ goto err;
+
+ if ((krb5rc = krb5_cc_default(krb5context, &krb5ccdef)) != 0)
+ goto err;
+
+ if ((krb5rc = krb5_cc_get_principal(krb5context, krb5ccdef,
+ &krb5creds.client)) != 0)
+ goto err;
+
+ if ((krb5rc = krb5_get_credentials(krb5context, 0, krb5ccdef,
+ &krb5creds, &krb5credsp)) != 0)
+ goto err;
+
+ rc = 1;
+
+ err:
+#ifdef KSSL_DEBUG
+ kssl_ctx_show(kssl_ctx);
+#endif /* KSSL_DEBUG */
+
+ if (krb5creds.client) krb5_free_principal(krb5context, krb5creds.client);
+ if (krb5creds.server) krb5_free_principal(krb5context, krb5creds.server);
+ if (krb5context) krb5_free_context(krb5context);
+ return(rc);
+ }
+
#if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_WIN32)
void kssl_krb5_free_data_contents(krb5_context context, krb5_data *data)
{
#ifdef KRB5_HEIMDAL
data->length = 0;
- free(data->if (data->data) data);
+ if (data->data)
+ free(data->data);
#elif defined(KRB5_MIT_OLD11)
if (data->data) {
krb5_xfree(data->data);
}
#endif /* !OPENSSL_SYS_WINDOWS && !OPENSSL_SYS_WIN32 */
+
+/* Given pointers to KerberosTime and struct tm structs, convert the
+** KerberosTime string to struct tm. Note that KerberosTime is a
+** ASN1_GENERALIZEDTIME value, constrained to GMT with no fractional
+** seconds as defined in RFC 1510.
+** Return pointer to the (partially) filled in struct tm on success,
+** return NULL on failure.
+*/
+struct tm *k_gmtime(ASN1_GENERALIZEDTIME *gtime, struct tm *k_tm)
+ {
+ char c, *p;
+
+ if (!k_tm) return NULL;
+ if (gtime == NULL || gtime->length < 14) return NULL;
+ if (gtime->data == NULL) return NULL;
+
+ p = (char *)>ime->data[14];
+
+ c = *p; *p = '\0'; p -= 2; k_tm->tm_sec = atoi(p); *(p+2) = c;
+ c = *p; *p = '\0'; p -= 2; k_tm->tm_min = atoi(p); *(p+2) = c;
+ c = *p; *p = '\0'; p -= 2; k_tm->tm_hour = atoi(p); *(p+2) = c;
+ c = *p; *p = '\0'; p -= 2; k_tm->tm_mday = atoi(p); *(p+2) = c;
+ c = *p; *p = '\0'; p -= 2; k_tm->tm_mon = atoi(p)-1; *(p+2) = c;
+ c = *p; *p = '\0'; p -= 4; k_tm->tm_year = atoi(p)-1900; *(p+4) = c;
+
+ return k_tm;
+ }
+
+
/* Helper function for kssl_validate_times().
** We need context->clockskew, but krb5_context is an opaque struct.
** So we try to sneek the clockskew out through the replay cache.
EVP_CIPHER_CTX ciph_ctx;
EVP_CIPHER *enc = NULL;
unsigned char iv[EVP_MAX_IV_LENGTH];
- unsigned char *p, *unenc_authent, *tbuf = NULL;
+ unsigned char *p, *unenc_authent;
int padl, outl, unencbufsize;
+ struct tm tm_time, *tm_l, *tm_g;
+ time_t now, tl, tg, tr, tz_offset;
*atimep = 0;
kssl_err_set(kssl_err, 0, "");
if (authentp == NULL || authentp->length == 0) return 0;
#ifdef KSSL_DEBUG
+ {
+ unsigned int ui;
printf("kssl_check_authent: authenticator[%d]:\n",authentp->length);
p = authentp->data;
- for (padl=0; padl < authentp->length; padl++) printf("%02x ",p[padl]);
+ for (ui=0; ui < authentp->length; ui++) printf("%02x ",p[ui]);
printf("\n");
+ }
#endif /* KSSL_DEBUG */
unencbufsize = 2 * authentp->length;
goto err;
}
- p = authentp->data;
+ p = (unsigned char *)authentp->data;
if ((dec_authent = d2i_KRB5_ENCDATA(NULL, &p,
(long) authentp->length)) == NULL)
{
}
enctype = dec_authent->etype->data[0]; /* should = kssl_ctx->enctype */
+#if !defined(KRB5_MIT_OLD11)
+ switch ( enctype ) {
+ case ENCTYPE_DES3_CBC_SHA1: /* EVP_des_ede3_cbc(); */
+ case ENCTYPE_DES3_CBC_SHA:
+ case ENCTYPE_DES3_CBC_RAW:
+ krb5rc = 0; /* Skip, can't handle derived keys */
+ goto err;
+ }
+#endif
enc = kssl_map_enc(enctype);
memset(iv, 0, EVP_MAX_IV_LENGTH); /* per RFC 1510 */
- EVP_DecryptInit(&ciph_ctx, enc, kssl_ctx->key, iv);
- EVP_DecryptUpdate(&ciph_ctx, unenc_authent, &outl,
- dec_authent->cipher->data, dec_authent->cipher->length);
+ if (enc == NULL)
+ {
+ /* Disable kssl_check_authent for ENCTYPE_DES3_CBC_SHA1.
+ ** This enctype indicates the authenticator was encrypted
+ ** using key-usage derived keys which openssl cannot decrypt.
+ */
+ goto err;
+ }
+ if (!EVP_DecryptInit(&ciph_ctx, enc, kssl_ctx->key, iv))
+ {
+ kssl_err_set(kssl_err, SSL_R_KRB5_S_INIT,
+ "EVP_DecryptInit error decrypting authenticator.\n");
+ krb5rc = KRB5KRB_AP_ERR_BAD_INTEGRITY;
+ goto err;
+ }
+ if (!EVP_DecryptUpdate(&ciph_ctx, unenc_authent, &outl,
+ dec_authent->cipher->data, dec_authent->cipher->length))
+ {
+ kssl_err_set(kssl_err, SSL_R_KRB5_S_INIT,
+ "EVP_DecryptUpdate error decrypting authenticator.\n");
+ krb5rc = KRB5KRB_AP_ERR_BAD_INTEGRITY;
+ goto err;
+ }
if (outl > unencbufsize)
{
kssl_err_set(kssl_err, SSL_R_KRB5_S_INIT,
krb5rc = KRB5KRB_AP_ERR_BAD_INTEGRITY;
goto err;
}
- EVP_DecryptFinal(&ciph_ctx, &(unenc_authent[outl]), &padl);
+ if (!EVP_DecryptFinal(&ciph_ctx, &(unenc_authent[outl]), &padl))
+ {
+ kssl_err_set(kssl_err, SSL_R_KRB5_S_INIT,
+ "EVP_DecryptFinal error decrypting authenticator.\n");
+ krb5rc = KRB5KRB_AP_ERR_BAD_INTEGRITY;
+ goto err;
+ }
outl += padl;
if (outl > unencbufsize)
{
krb5rc = KRB5KRB_AP_ERR_BAD_INTEGRITY;
goto err;
}
- if ((tbuf = calloc(1, auth->ctime->length + 1)) == NULL)
- {
- kssl_err_set(kssl_err, SSL_R_KRB5_S_INIT,
- "Unable to allocate atime buffer.\n");
- krb5rc = KRB5KRB_ERR_GENERIC;
- goto err;
- }
- else strncpy(tbuf, auth->ctime->data, auth->ctime->length);
-
- if ( auth->ctime->length >= 9 && auth->ctime->length <= 14 )
- /* tbuf == "%Y%m%d%H%M%S" */
- {
- struct tm tm_time, *tm_l, *tm_g;
- time_t now, tl, tg, tr, tz_offset;
- int i;
- char *p = tbuf;
-
- memset(&tm_time,0,sizeof(struct tm));
- for ( i=0;
- i<4 && isdigit(*p);
- i++, p++ )
- tm_time.tm_year = tm_time.tm_year*10 + (*p-'0');
- for ( i=0;
- i<2 && isdigit(*p) && tm_time.tm_mon <= 1;
- i++, p++ )
- tm_time.tm_mon = tm_time.tm_mon*10 + (*p-'0');
- for ( i=0;
- i<2 && isdigit(*p) && tm_time.tm_mday <= 3;
- i++, p++ )
- tm_time.tm_mday = tm_time.tm_mday*10 + (*p-'0');
- for ( i=0;
- i<2 && isdigit(*p) && tm_time.tm_hour <= 2;
- i++, p++ )
- tm_time.tm_hour = tm_time.tm_hour*10 + (*p-'0');
- for ( i=0;
- i<2 && isdigit(*p) && tm_time.tm_min <= 6;
- i++, p++ )
- tm_time.tm_min = tm_time.tm_min*10 + (*p-'0');
- for ( i=0;
- i<2 && isdigit(*p) && tm_time.tm_sec <= 6;
- i++, p++ )
- tm_time.tm_sec = tm_time.tm_sec*10 + (*p-'0');
-
- now = time(&now);
- tm_l = localtime(&now); tl = mktime(tm_l);
- tm_g = gmtime(&now); tg = mktime(tm_g);
- tz_offset = tg - tl;
- tr = mktime(&tm_time);
-
- if (tr != (time_t)(-1))
- *atimep = mktime(&tm_time) - tz_offset;
- }
+
+ memset(&tm_time,0,sizeof(struct tm));
+ if (k_gmtime(auth->ctime, &tm_time) &&
+ ((tr = mktime(&tm_time)) != (time_t)(-1)))
+ {
+ now = time(&now);
+ tm_l = localtime(&now); tl = mktime(tm_l);
+ tm_g = gmtime(&now); tg = mktime(tm_g);
+ tz_offset = tg - tl;
+
+ *atimep = tr - tz_offset;
+ }
+
#ifdef KSSL_DEBUG
- printf("kssl_check_authent: client time %s = %d\n", tbuf, *atimep);
+ printf("kssl_check_authent: returns %d for client time ", *atimep);
+ if (auth && auth->ctime && auth->ctime->length && auth->ctime->data)
+ printf("%.*s\n", auth->ctime->length, auth->ctime->data);
+ else printf("NULL\n");
#endif /* KSSL_DEBUG */
err:
- if (tbuf) free(tbuf);
if (auth) KRB5_AUTHENT_free((KRB5_AUTHENT *) auth);
if (dec_authent) KRB5_ENCDATA_free(dec_authent);
if (unenc_authent) free(unenc_authent);
projects / openssl.git / blobdiff