#include "krb5_locl.h"
#include <assert.h>
static krb5_error_code
make_pa_tgs_req(krb5_context context,
krb5_auth_context ac,
KDC_REQ_BODY *body,
krb5_ccache ccache,
krb5_creds *creds,
krb5_data *tgs_req)
{
krb5_error_code ret;
krb5_data in_data;
size_t buf_size;
size_t len = 0;
uint8_t *buf;
ASN1_MALLOC_ENCODE(KDC_REQ_BODY, buf, buf_size, body, &len, ret);
if (ret)
return ret;
if(buf_size != len)
krb5_abortx(context, "internal error in ASN.1 encoder");
in_data.length = len;
in_data.data = buf;
ret = _krb5_mk_req_internal(context, &ac, 0, &in_data,
ccache, creds,
tgs_req,
KRB5_KU_TGS_REQ_AUTH_CKSUM,
KRB5_KU_TGS_REQ_AUTH);
free (buf);
return ret;
}
static krb5_error_code
set_auth_data (krb5_context context,
KDC_REQ_BODY *req_body,
krb5_authdata *authdata,
krb5_keyblock *subkey)
{
if(authdata->len) {
size_t len = 0, buf_size;
unsigned char *buf;
krb5_crypto crypto;
krb5_error_code ret;
ASN1_MALLOC_ENCODE(AuthorizationData, buf, buf_size, authdata,
&len, ret);
if (ret)
return ret;
if (buf_size != len)
krb5_abortx(context, "internal error in ASN.1 encoder");
ALLOC(req_body->enc_authorization_data, 1);
if (req_body->enc_authorization_data == NULL) {
free (buf);
krb5_set_error_message(context, ENOMEM,
N_("malloc: out of memory", ""));
return ENOMEM;
}
ret = krb5_crypto_init(context, subkey, 0, &crypto);
if (ret) {
free (buf);
free (req_body->enc_authorization_data);
req_body->enc_authorization_data = NULL;
return ret;
}
krb5_encrypt_EncryptedData(context,
crypto,
KRB5_KU_TGS_REQ_AUTH_DAT_SUBKEY,
buf,
len,
0,
req_body->enc_authorization_data);
free (buf);
krb5_crypto_destroy(context, crypto);
} else {
req_body->enc_authorization_data = NULL;
}
return 0;
}
krb5_error_code
_krb5_init_tgs_req(krb5_context context,
krb5_ccache ccache,
struct krb5_fast_state *state,
krb5_addresses *addresses,
krb5_kdc_flags flags,
krb5_const_principal impersonate_principal,
Ticket *second_ticket,
krb5_creds *in_creds,
krb5_creds *krbtgt,
unsigned nonce,
METHOD_DATA *padata,
krb5_keyblock **subkey,
TGS_REQ *t)
{
krb5_auth_context ac = NULL;
krb5_error_code ret = 0;
krb5_data tgs_req;
memset(t, 0, sizeof(*t));
krb5_data_zero(&tgs_req);
flags.b.forwardable = krbtgt->flags.b.forwardable;
flags.b.proxiable = krbtgt->flags.b.proxiable;
if (ccache->ops->tgt_req) {
KERB_TGS_REQ_OUT out;
KERB_TGS_REQ_IN in;
memset(&in, 0, sizeof(in));
memset(&out, 0, sizeof(out));
ret = ccache->ops->tgt_req(context, ccache, &in, &out);
if (ret)
return ret;
free_KERB_TGS_REQ_OUT(&out);
return 0;
}
if (impersonate_principal) {
krb5_crypto crypto;
PA_S4U2Self self;
krb5_data data;
void *buf;
size_t size = 0, len;
self.name = impersonate_principal->name;
self.realm = impersonate_principal->realm;
self.auth = rk_UNCONST("Kerberos");
ret = _krb5_s4u2self_to_checksumdata(context, &self, &data);
if (ret)
goto fail;
ret = krb5_crypto_init(context, &krbtgt->session, 0, &crypto);
if (ret) {
krb5_data_free(&data);
goto fail;
}
ret = krb5_create_checksum(context,
crypto,
KRB5_KU_OTHER_CKSUM,
0,
data.data,
data.length,
&self.cksum);
krb5_crypto_destroy(context, crypto);
krb5_data_free(&data);
if (ret)
goto fail;
ASN1_MALLOC_ENCODE(PA_S4U2Self, buf, len, &self, &size, ret);
free_Checksum(&self.cksum);
if (ret)
goto fail;
if (len != size)
krb5_abortx(context, "internal asn1 error");
ret = krb5_padata_add(context, padata, KRB5_PADATA_FOR_USER, buf, len);
if (ret)
goto fail;
}
t->pvno = 5;
t->msg_type = krb_tgs_req;
if (in_creds->session.keytype) {
ALLOC_SEQ(&t->req_body.etype, 1);
if(t->req_body.etype.val == NULL) {
ret = ENOMEM;
krb5_set_error_message(context, ret,
N_("malloc: out of memory", ""));
goto fail;
}
t->req_body.etype.val[0] = in_creds->session.keytype;
} else {
ret = _krb5_init_etype(context,
KRB5_PDU_TGS_REQUEST,
&t->req_body.etype.len,
&t->req_body.etype.val,
NULL);
}
if (ret)
goto fail;
t->req_body.addresses = addresses;
t->req_body.kdc_options = flags.b;
ret = copy_Realm(&in_creds->server->realm, &t->req_body.realm);
if (ret)
goto fail;
ALLOC(t->req_body.sname, 1);
if (t->req_body.sname == NULL) {
ret = ENOMEM;
krb5_set_error_message(context, ret, N_("malloc: out of memory", ""));
goto fail;
}
ret = copy_PrincipalName(&in_creds->server->name, t->req_body.sname);
if (ret)
goto fail;
ALLOC(t->req_body.till, 1);
if(t->req_body.till == NULL){
ret = ENOMEM;
krb5_set_error_message(context, ret, N_("malloc: out of memory", ""));
goto fail;
}
*t->req_body.till = in_creds->times.endtime;
t->req_body.nonce = nonce;
if(second_ticket){
ALLOC(t->req_body.additional_tickets, 1);
if (t->req_body.additional_tickets == NULL) {
ret = ENOMEM;
krb5_set_error_message(context, ret,
N_("malloc: out of memory", ""));
goto fail;
}
ALLOC_SEQ(t->req_body.additional_tickets, 1);
if (t->req_body.additional_tickets->val == NULL) {
ret = ENOMEM;
krb5_set_error_message(context, ret,
N_("malloc: out of memory", ""));
goto fail;
}
ret = copy_Ticket(second_ticket, t->req_body.additional_tickets->val);
if (ret)
goto fail;
}
if (padata) {
if (t->padata == NULL) {
ALLOC(t->padata, 1);
if (t->padata == NULL) {
ret = krb5_enomem(context);
goto fail;
}
}
ret = copy_METHOD_DATA(padata, t->padata);
if (ret)
goto fail;
}
ret = krb5_auth_con_init(context, &ac);
if(ret)
goto fail;
ret = krb5_auth_con_generatelocalsubkey(context, ac, &krbtgt->session);
if (ret)
goto fail;
ret = set_auth_data(context, &t->req_body,
&in_creds->authdata, ac->local_subkey);
if (ret)
goto fail;
if (t->padata == NULL) {
ALLOC(t->padata, 1);
if (t->padata == NULL) {
ret = krb5_enomem(context);
goto fail;
}
}
ret = make_pa_tgs_req(context,
ac,
&t->req_body,
ccache,
krbtgt,
&tgs_req);
if(ret)
goto fail;
if (state) {
state->armor_ac = ac;
ret = _krb5_fast_create_armor(context, state, NULL);
state->armor_ac = NULL;
if (ret)
goto fail;
ret = _krb5_fast_wrap_req(context, state, &tgs_req, t);
if (ret)
goto fail;
state->flags &= ~KRB5_FAST_EXPECTED;
}
ret = krb5_padata_add(context, t->padata, KRB5_PADATA_TGS_REQ,
tgs_req.data, tgs_req.length);
if (ret)
goto fail;
krb5_data_zero(&tgs_req);
ret = krb5_auth_con_getlocalsubkey(context, ac, subkey);
if (ret)
goto fail;
fail:
if (ac)
krb5_auth_con_free(context, ac);
if (ret) {
t->req_body.addresses = NULL;
free_TGS_REQ(t);
}
krb5_data_free(&tgs_req);
return ret;
}
krb5_error_code KRB5_CALLCONV
_krb5_decrypt_tkt_with_subkey (krb5_context context,
krb5_keyblock *key,
krb5_key_usage usage,
krb5_const_pointer skey,
krb5_kdc_rep *dec_rep)
{
struct krb5_decrypt_tkt_with_subkey_state *state;
krb5_error_code ret = 0;
krb5_data data;
size_t size;
krb5_crypto crypto;
krb5_keyblock extract_key;
state = (struct krb5_decrypt_tkt_with_subkey_state *)skey;
assert(usage == 0);
krb5_data_zero(&data);
krb5_keyblock_zero(&extract_key);
if (state->subkey) {
ret = _krb5_fast_tgs_strengthen_key(context, state->fast_state, state->subkey, &extract_key);
if (ret)
return ret;
ret = krb5_crypto_init(context, &extract_key, 0, &crypto);
krb5_free_keyblock_contents(context, &extract_key);
if (ret)
return ret;
ret = krb5_decrypt_EncryptedData (context,
crypto,
KRB5_KU_TGS_REP_ENC_PART_SUB_KEY,
&dec_rep->kdc_rep.enc_part,
&data);
if (ret && state->subkey->keytype == ETYPE_ARCFOUR_HMAC_MD5) {
ret = krb5_decrypt_EncryptedData(context,
crypto,
8,
&dec_rep->kdc_rep.enc_part,
&data);
}
krb5_crypto_destroy(context, crypto);
}
if (state->subkey == NULL || ret) {
ret = _krb5_fast_tgs_strengthen_key(context, state->fast_state, key, &extract_key);
if (ret)
return ret;
ret = krb5_crypto_init(context, &extract_key, 0, &crypto);
krb5_free_keyblock_contents(context, &extract_key);
if (ret)
return ret;
ret = krb5_decrypt_EncryptedData (context,
crypto,
KRB5_KU_TGS_REP_ENC_PART_SESSION,
&dec_rep->kdc_rep.enc_part,
&data);
krb5_crypto_destroy(context, crypto);
}
if (ret)
return ret;
ret = decode_EncASRepPart(data.data,
data.length,
&dec_rep->enc_part,
&size);
if (ret)
ret = decode_EncTGSRepPart(data.data,
data.length,
&dec_rep->enc_part,
&size);
if (ret)
krb5_set_error_message(context, ret,
N_("Failed to decode encpart in ticket", ""));
krb5_data_free (&data);
return ret;
}
static int
not_found(krb5_context context, krb5_const_principal p, krb5_error_code code)
{
krb5_error_code ret;
char *str;
ret = krb5_unparse_name(context, p, &str);
if(ret) {
krb5_clear_error_message(context);
return code;
}
krb5_set_error_message(context, code,
N_("Matching credential (%s) not found", ""), str);
free(str);
return code;
}
static krb5_error_code
find_cred(krb5_context context,
krb5_ccache id,
krb5_principal server,
krb5_creds **tgts,
krb5_creds *out_creds)
{
krb5_error_code ret;
krb5_creds mcreds;
krb5_cc_clear_mcred(&mcreds);
mcreds.server = server;
ret = krb5_cc_retrieve_cred(context, id, KRB5_TC_DONT_MATCH_REALM,
&mcreds, out_creds);
if(ret == 0)
return 0;
while(tgts && *tgts){
if(krb5_compare_creds(context, KRB5_TC_DONT_MATCH_REALM,
&mcreds, *tgts)){
ret = krb5_copy_creds_contents(context, *tgts, out_creds);
return ret;
}
tgts++;
}
return not_found(context, server, KRB5_CC_NOTFOUND);
}
static krb5_error_code
add_cred(krb5_context context, krb5_creds const *tkt, krb5_creds ***tgts)
{
int i;
krb5_error_code ret;
krb5_creds **tmp = *tgts;
for(i = 0; tmp && tmp[i]; i++);
tmp = realloc(tmp, (i+2)*sizeof(*tmp));
if(tmp == NULL) {
krb5_set_error_message(context, ENOMEM,
N_("malloc: out of memory", ""));
return ENOMEM;
}
*tgts = tmp;
ret = krb5_copy_creds(context, tkt, &tmp[i]);
tmp[i+1] = NULL;
return ret;
}
static void
store_tgts(krb5_context context, krb5_ccache ccache, krb5_creds **tgts)
{
size_t n;
for (n = 0; tgts && tgts[n]; n++) {
krb5_const_principal server = tgts[n]->server;
if (krb5_principal_is_krbtgt(context, server) && strcmp(server->name.name_string.val[1], server->realm) != 0)
krb5_cc_store_cred(context, ccache, tgts[n]);
}
for (n = 0; tgts && tgts[n]; n++)
krb5_free_creds(context, tgts[n]);
}
typedef krb5_error_code
(*tkt_step_state)(krb5_context, krb5_tkt_creds_context,
krb5_data *, krb5_data *, krb5_realm *, unsigned int *);
struct krb5_tkt_creds_context_data {
struct heim_base_uniq base;
krb5_context context;
tkt_step_state state;
unsigned int options;
char *server_name;
krb5_error_code error;
krb5_kdc_flags req_kdc_flags;
krb5_principal impersonate_principal;
krb5_addresses *addreseses;
krb5_ccache ccache;
krb5_creds *in_cred;
krb5_kdc_flags kdc_flags;
int32_t nonce;
krb5_keyblock *subkey;
krb5_creds tgt;
krb5_creds next;
krb5_creds **tickets;
int ok_as_delegate;
struct krb5_fast_state fast_state;
krb5_creds *cred;
};
#define TKT_STEP(funcname) \
static krb5_error_code tkt_##funcname(krb5_context, \
krb5_tkt_creds_context, \
krb5_data *, krb5_data *, krb5_realm *, \
unsigned int *)
TKT_STEP(init);
TKT_STEP(referral_init);
TKT_STEP(referral_recv);
TKT_STEP(referral_send);
TKT_STEP(direct_init);
TKT_STEP(capath_init);
TKT_STEP(store);
#undef TKT_STEP
static krb5_error_code
tkt_init(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_data *in,
krb5_data *out,
krb5_realm *realm,
unsigned int *flags)
{
_krb5_debugx(context, 10, "tkt_init: %s", ctx->server_name);
ctx->state = tkt_referral_init;
return 0;
}
static void
tkt_reset(krb5_context context, krb5_tkt_creds_context ctx)
{
_krb5_fast_free(context, &ctx->fast_state);
krb5_free_cred_contents(context, &ctx->tgt);
krb5_free_cred_contents(context, &ctx->next);
krb5_free_keyblock(context, ctx->subkey);
ctx->subkey = NULL;
}
static krb5_error_code
tkt_referral_init(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_data *in,
krb5_data *out,
krb5_realm *realm,
unsigned int *flags)
{
krb5_error_code ret;
krb5_creds ticket;
krb5_const_realm client_realm;
krb5_principal tgtname;
_krb5_debugx(context, 10, "tkt_step_referrals: %s", ctx->server_name);
memset(&ticket, 0, sizeof(ticket));
memset(&ctx->kdc_flags, 0, sizeof(ctx->kdc_flags));
memset(&ctx->next, 0, sizeof(ctx->next));
ctx->kdc_flags.b.canonicalize = 1;
client_realm = krb5_principal_get_realm(context, ctx->in_cred->client);
ret = krb5_make_principal(context, &tgtname,
client_realm,
KRB5_TGS_NAME,
client_realm,
NULL);
if(ret)
goto out;
ret = find_cred(context, ctx->ccache, tgtname, NULL, &ctx->tgt);
krb5_free_principal(context, tgtname);
if (ret)
goto out;
ret = krb5_copy_principal(context, ctx->in_cred->client, &ctx->next.client);
if (ret)
goto out;
ret = krb5_copy_principal(context, ctx->in_cred->server, &ctx->next.server);
if (ret)
goto out;
ret = krb5_principal_set_realm(context, ctx->next.server, ctx->tgt.server->realm);
if (ret)
goto out;
out:
if (ret) {
ctx->error = ret;
ctx->state = tkt_direct_init;
} else {
ctx->error = 0;
ctx->state = tkt_referral_send;
}
return 0;
}
static krb5_error_code
tkt_referral_send(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_data *in,
krb5_data *out,
krb5_realm *realm,
unsigned int *flags)
{
krb5_error_code ret;
TGS_REQ req;
size_t len = 0;
METHOD_DATA padata;
memset(&req, 0, sizeof(req));
padata.val = NULL;
padata.len = 0;
krb5_generate_random_block(&ctx->nonce, sizeof(ctx->nonce));
ctx->nonce &= 0xffffffff;
if (_krb5_have_debug(context, 10)) {
char *sname, *tgtname;
krb5_unparse_name(context, ctx->tgt.server, &tgtname);
krb5_unparse_name(context, ctx->next.server, &sname);
_krb5_debugx(context, 10, "sending TGS-REQ for %s using %s", sname, tgtname);
}
ret = _krb5_init_tgs_req(context,
ctx->ccache,
&ctx->fast_state,
ctx->addreseses,
ctx->kdc_flags,
ctx->impersonate_principal,
NULL,
&ctx->next,
&ctx->tgt,
ctx->nonce,
&padata,
&ctx->subkey,
&req);
if (ret)
goto out;
ASN1_MALLOC_ENCODE(TGS_REQ, out->data, out->length, &req, &len, ret);
if (ret)
goto out;
if(out->length != len)
krb5_abortx(context, "internal error in ASN.1 encoder");
req.req_body.addresses = NULL;
free_TGS_REQ(&req);
*realm = ctx->tgt.server->name.name_string.val[1];
*flags |= KRB5_TKT_STATE_CONTINUE;
ctx->error = 0;
ctx->state = tkt_referral_recv;
return 0;
out:
ctx->error = ret;
ctx->state = NULL;
return ret;
}
krb5_error_code
_krb5_fast_tgs_strengthen_key(krb5_context context,
struct krb5_fast_state *state,
krb5_keyblock *reply_key,
krb5_keyblock *extract_key)
{
krb5_error_code ret;
if (state && state->strengthen_key) {
_krb5_debugx(context, 5, "_krb5_fast_tgs_strengthen_key");
if (state->strengthen_key->keytype != reply_key->keytype) {
krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
N_("strengthen_key %d not same enctype as reply key %d", ""),
state->strengthen_key->keytype, reply_key->keytype);
return KRB5KRB_AP_ERR_MODIFIED;
}
_krb5_debug_keyblock(context, 10, "tkt: strengthen_key", state->strengthen_key);
_krb5_debug_keyblock(context, 10, "tkt: old reply_key", reply_key);
ret = _krb5_fast_cf2(context,
state->strengthen_key,
"strengthenkey",
reply_key,
"replykey",
extract_key,
NULL);
if (ret)
return ret;
} else {
ret = krb5_copy_keyblock_contents(context, reply_key, extract_key);
if (ret)
return ret;
}
_krb5_debug_keyblock(context, 10, "tkt: extract key", extract_key);
return 0;
}
static krb5_error_code
parse_tgs_rep(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_data *in,
krb5_creds *outcred)
{
krb5_error_code ret;
krb5_kdc_rep rep;
size_t len;
memset(&rep, 0, sizeof(rep));
memset(outcred, 0, sizeof(*outcred));
if (ctx->ccache->ops->tgt_rep) {
return EINVAL;
}
if(decode_TGS_REP(in->data, in->length, &rep.kdc_rep, &len) == 0) {
struct krb5_decrypt_tkt_with_subkey_state state;
unsigned eflags = 0;
ret = _krb5_fast_unwrap_kdc_rep(context, ctx->nonce, NULL,
&ctx->fast_state, &rep.kdc_rep);
if (ret)
return ret;
ret = krb5_copy_principal(context,
ctx->next.client,
&outcred->client);
if(ret)
return ret;
ret = krb5_copy_principal(context,
ctx->next.server,
&outcred->server);
if(ret)
return ret;
outcred->times.endtime = ctx->in_cred->times.endtime;
#define constrained_delegation request_anonymous
if (ctx->kdc_flags.b.constrained_delegation || ctx->impersonate_principal)
eflags |= EXTRACT_TICKET_ALLOW_CNAME_MISMATCH;
#undef constrained_delegation
state.subkey = ctx->subkey;
state.fast_state = &ctx->fast_state;
ret = _krb5_extract_ticket(context,
&rep,
outcred,
&ctx->tgt.session,
0,
&ctx->tgt.addresses,
ctx->nonce,
eflags,
NULL,
_krb5_decrypt_tkt_with_subkey,
&state);
} else if(krb5_rd_error(context, in, &rep.error) == 0) {
METHOD_DATA md;
memset(&md, 0, sizeof(md));
if (rep.error.e_data) {
ret = decode_METHOD_DATA(rep.error.e_data->data,
rep.error.e_data->length,
&md, NULL);
if (ret) {
krb5_set_error_message(context, ret,
N_("Failed to decode METHOD-DATA", ""));
goto out;
}
}
ret = _krb5_fast_unwrap_error(context, &ctx->fast_state,
&md, &rep.error);
free_METHOD_DATA(&md);
if (ret)
goto out;
ret = krb5_error_from_rd_error(context, &rep.error, ctx->in_cred);
if (_krb5_have_debug(context, 5)) {
const char *str = krb5_get_error_message(context, ret);
_krb5_debugx(context, 5, "parse_tgs_rep: KRB-ERROR %d/%s", ret, str);
krb5_free_error_message(context, str);
}
} else {
ret = KRB5KRB_AP_ERR_MSG_TYPE;
krb5_clear_error_message(context);
}
out:
krb5_free_kdc_rep(context, &rep);
return ret;
}
static krb5_error_code
tkt_referral_recv(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_data *in,
krb5_data *out,
krb5_realm *realm,
unsigned int *flags)
{
krb5_error_code ret;
krb5_creds outcred, mcred;
unsigned long n;
_krb5_debugx(context, 10, "tkt_referral_recv: %s", ctx->server_name);
memset(&outcred, 0, sizeof(outcred));
ret = parse_tgs_rep(context, ctx, in, &outcred);
if (ret) {
_krb5_debugx(context, 10, "tkt_referral_recv: parse_tgs_rep %d", ret);
tkt_reset(context, ctx);
ctx->state = tkt_capath_init;
return 0;
}
if (krb5_principal_compare_any_realm(context, ctx->next.server, outcred.server)) {
ret = krb5_copy_creds(context, &outcred, &ctx->cred);
if (ret)
return (ctx->error = ret);
krb5_free_cred_contents(context, &outcred);
ctx->state = tkt_store;
return 0;
}
if (!krb5_principal_is_krbtgt(context, outcred.server)) {
krb5_set_error_message(context, KRB5KRB_AP_ERR_NOT_US,
N_("Got back an non krbtgt "
"ticket referrals", ""));
krb5_free_cred_contents(context, &outcred);
ctx->state = tkt_capath_init;
return 0;
}
_krb5_debugx(context, 10, "KDC for realm %s sends a referrals to %s",
ctx->tgt.server->realm, outcred.server->name.name_string.val[1]);
krb5_cc_clear_mcred(&mcred);
mcred.server = outcred.server;
for (n = 0; ctx->tickets && ctx->tickets[n]; n++) {
if(krb5_compare_creds(context,
KRB5_TC_DONT_MATCH_REALM,
&mcred,
ctx->tickets[n]))
{
_krb5_debugx(context, 5, "Referral from %s loops back to realm %s",
ctx->tgt.server->realm,
outcred.server->realm);
ctx->state = tkt_capath_init;
return 0;
}
}
#define MAX_KDC_REFERRALS_LOOPS 15
if (n > MAX_KDC_REFERRALS_LOOPS) {
ctx->state = tkt_capath_init;
return 0;
}
if (ctx->ok_as_delegate == 0 || outcred.flags.b.ok_as_delegate == 0) {
ctx->ok_as_delegate = 0;
outcred.flags.b.ok_as_delegate = 0;
}
ret = add_cred(context, &outcred, &ctx->tickets);
if (ret) {
ctx->state = tkt_capath_init;
return 0;
}
krb5_free_cred_contents(context, &ctx->tgt);
ctx->tgt = outcred;
ret = krb5_principal_set_realm(context, ctx->next.server,
ctx->tgt.server->realm);
if (ret) {
ctx->state = tkt_capath_init;
return 0;
}
ctx->state = tkt_referral_send;
return 0;
}
static krb5_error_code
tkt_direct_init(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_data *in,
krb5_data *out,
krb5_realm *realm,
unsigned int *flags)
{
_krb5_debugx(context, 10, "tkt_direct_init: %s", ctx->server_name);
tkt_reset(context, ctx);
ctx->error = EINVAL;
ctx->state = tkt_capath_init;
return 0;
}
static krb5_error_code
tkt_capath_init(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_data *in,
krb5_data *out,
krb5_realm *realm,
unsigned int *flags)
{
_krb5_debugx(context, 10, "tkt_step_capath: %s", ctx->server_name);
tkt_reset(context, ctx);
ctx->error = EINVAL;
ctx->state = NULL;
return 0;
}
static krb5_error_code
tkt_store(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_data *in,
krb5_data *out,
krb5_realm *realm,
unsigned int *flags)
{
krb5_boolean bret;
_krb5_debugx(context, 10, "tkt_step_store: %s", ctx->server_name);
ctx->error = 0;
ctx->state = NULL;
if (ctx->options & KRB5_GC_NO_STORE)
return 0;
if (ctx->tickets) {
store_tgts(context, ctx->ccache, ctx->tickets);
free(ctx->tickets);
ctx->tickets = NULL;
}
heim_assert(ctx->cred != NULL, "store but no credential");
krb5_cc_store_cred(context, ctx->ccache, ctx->cred);
bret = krb5_principal_compare_any_realm(context,
ctx->cred->server,
ctx->in_cred->server);
if (!bret) {
krb5_creds ref = *ctx->cred;
krb5_principal_data refp = *ctx->in_cred->server;
refp.realm = "";
ref.server = &refp;
krb5_cc_store_cred(context, ctx->ccache, &ref);
}
return 0;
}
static void
tkt_release(void *ptr)
{
krb5_tkt_creds_context ctx = ptr;
krb5_free_creds(ctx->context, ctx->cred);
tkt_reset(ctx->context, ctx);
if (ctx->tickets) {
size_t n;
for (n = 0; ctx->tickets[n]; n++)
krb5_free_creds(ctx->context, ctx->tickets[n]);
free(ctx->tickets);
}
free(ctx->server_name);
}
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_tkt_creds_init(krb5_context context,
krb5_ccache ccache,
krb5_creds *in_cred,
krb5_flags options,
krb5_tkt_creds_context *pctx)
{
krb5_tkt_creds_context ctx;
krb5_error_code ret;
*pctx = NULL;
ctx = heim_uniq_alloc(sizeof(*ctx), "tkt-ctx", tkt_release);
if (ctx == NULL)
return ENOMEM;
ctx->context = context;
ctx->state = tkt_init;
ctx->options = options;
ctx->ccache = ccache;
if (ctx->options & KRB5_GC_FORWARDABLE)
ctx->req_kdc_flags.b.forwardable = 1;
if (ctx->options & KRB5_GC_USER_USER) {
ctx->req_kdc_flags.b.enc_tkt_in_skey = 1;
ctx->options |= KRB5_GC_NO_STORE;
}
if (options & KRB5_GC_CANONICALIZE)
ctx->req_kdc_flags.b.canonicalize = 1;
ret = krb5_copy_creds(context, in_cred, &ctx->in_cred);
if (ret) {
heim_release(ctx);
return ret;
}
ret = krb5_unparse_name(context, ctx->in_cred->server, &ctx->server_name);
if (ret) {
heim_release(ctx);
return ret;
}
*pctx = ctx;
return 0;
}
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_tkt_creds_step(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_data *in,
krb5_data *out,
krb5_realm *realm,
unsigned int *flags)
{
krb5_error_code ret;
krb5_data_zero(out);
*flags = 0;
*realm = NULL;
ret = ctx->error = 0;
while (out->length == 0 && ctx->state != NULL) {
ret = ctx->state(context, ctx, in, out, realm, flags);
if (ret) {
heim_assert(ctx->error == ret, "error not same as saved");
break;
}
if ((*flags) & KRB5_TKT_STATE_CONTINUE) {
heim_assert(out->length != 0, "no data to send to KDC");
heim_assert(*realm != NULL, "no realm to send data too");
break;
} else {
heim_assert(out->length == 0, "out state but not state continue");
}
}
return ret;
}
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_tkt_creds_get_creds(krb5_context context,
krb5_tkt_creds_context ctx,
krb5_creds **cred)
{
if (ctx->state != NULL)
return EINVAL;
if (ctx->cred)
return krb5_copy_creds(context, ctx->cred, cred);
return ctx->error;
}
KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_tkt_creds_free(krb5_context context,
krb5_tkt_creds_context ctx)
{
heim_release(ctx);
}