main(int argc, char *argv[])
{
struct eapsim_keys *ek;
ek = &inputkey1;
eapsim_calculate_keys(ek);
eapsim_dump_mk(ek);
ek = &inputkey2;
eapsim_calculate_keys(ek);
eapsim_dump_mk(ek);
}
/** Send the challenge itself
*
* Challenges will come from one of three places eventually:
*
* 1 from attributes like PW_EAP_SIM_RANDx
* (these might be retrived from a database)
*
* 2 from internally implemented SIM authenticators
* (a simple one based upon XOR will be provided)
*
* 3 from some kind of SS7 interface.
*
* For now, they only come from attributes.
* It might be that the best way to do 2/3 will be with a different
* module to generate/calculate things.
*
*/
static int eap_sim_sendchallenge(eap_handler_t *handler)
{
REQUEST *request = handler->request;
eap_sim_state_t *ess;
VALUE_PAIR **invps, **outvps, *newvp;
RADIUS_PACKET *packet;
uint8_t *p;
ess = (eap_sim_state_t *)handler->opaque;
rad_assert(handler->request != NULL);
rad_assert(handler->request->reply);
/*
* Invps is the data from the client but this is for non-protocol data here.
* We should already have consumed any client originated data.
*/
invps = &handler->request->packet->vps;
/*
* Outvps is the data to the client
*/
packet = handler->request->reply;
outvps = &packet->vps;
if (RDEBUG_ENABLED2) {
RDEBUG2("EAP-SIM decoded packet:");
debug_pair_list(*invps);
}
/*
* Okay, we got the challenges! Put them into an attribute.
*/
newvp = paircreate(packet, PW_EAP_SIM_RAND, 0);
newvp->length = 2 + (EAPSIM_RAND_SIZE * 3);
newvp->vp_octets = p = talloc_array(newvp, uint8_t, newvp->length);
memset(p, 0, 2); /* clear reserved bytes */
p += 2;
memcpy(p, ess->keys.rand[0], EAPSIM_RAND_SIZE);
p += EAPSIM_RAND_SIZE;
memcpy(p, ess->keys.rand[1], EAPSIM_RAND_SIZE);
p += EAPSIM_RAND_SIZE;
memcpy(p, ess->keys.rand[2], EAPSIM_RAND_SIZE);
pairadd(outvps, newvp);
/*
* Set the EAP_ID - new value
*/
newvp = paircreate(packet, PW_EAP_ID, 0);
newvp->vp_integer = ess->sim_id++;
pairreplace(outvps, newvp);
/*
* Make a copy of the identity
*/
ess->keys.identitylen = strlen(handler->identity);
memcpy(ess->keys.identity, handler->identity, ess->keys.identitylen);
/*
* Use the SIM identity, if available
*/
newvp = pairfind(*invps, PW_EAP_SIM_IDENTITY, 0, TAG_ANY);
if (newvp && newvp->length > 2) {
uint16_t len;
memcpy(&len, newvp->vp_octets, sizeof(uint16_t));
len = ntohs(len);
if (len <= newvp->length - 2 && len <= MAX_STRING_LEN) {
ess->keys.identitylen = len;
memcpy(ess->keys.identity, newvp->vp_octets + 2, ess->keys.identitylen);
}
}
/*
* All set, calculate keys!
*/
eapsim_calculate_keys(&ess->keys);
#ifdef EAP_SIM_DEBUG_PRF
eapsim_dump_mk(&ess->keys);
#endif
/*
* Need to include an AT_MAC attribute so that it will get
* calculated. The NONCE_MT and the MAC are both 16 bytes, so
* We store the NONCE_MT in the MAC for the encoder, which
* will pull it out before it does the operation.
*/
newvp = paircreate(packet, PW_EAP_SIM_MAC, 0);
pairmemcpy(newvp, ess->keys.nonce_mt, 16);
pairreplace(outvps, newvp);
newvp = paircreate(packet, PW_EAP_SIM_KEY, 0);
pairmemcpy(newvp, ess->keys.K_aut, 16);
pairreplace(outvps, newvp);
/* the SUBTYPE, set to challenge. */
newvp = paircreate(packet, PW_EAP_SIM_SUBTYPE, 0);
newvp->vp_integer = EAPSIM_CHALLENGE;
pairreplace(outvps, newvp);
return 1;
}
/*
* this code sends the challenge itself.
*
* Challenges will come from one of three places eventually:
*
* 1 from attributes like ATTRIBUTE_EAP_SIM_RANDx
* (these might be retrived from a database)
*
* 2 from internally implemented SIM authenticators
* (a simple one based upon XOR will be provided)
*
* 3 from some kind of SS7 interface.
*
* For now, they only come from attributes.
* It might be that the best way to do 2/3 will be with a different
* module to generate/calculate things.
*
*/
static int eap_sim_sendchallenge(EAP_HANDLER *handler)
{
struct eap_sim_server_state *ess;
VALUE_PAIR **invps, **outvps, *newvp;
ess = (struct eap_sim_server_state *)handler->opaque;
rad_assert(handler->request != NULL);
rad_assert(handler->request->reply);
/* invps is the data from the client.
* but, this is for non-protocol data here. We should
* already have consumed any client originated data.
*/
invps = &handler->request->packet->vps;
/* outvps is the data to the client. */
outvps= &handler->request->reply->vps;
if ((debug_flag > 0) && fr_log_fp) {
fprintf(fr_log_fp, "+++> EAP-sim decoded packet:\n");
debug_pair_list(*invps);
}
/* okay, we got the challenges! Put them into an attribute */
newvp = paircreate(ATTRIBUTE_EAP_SIM_BASE+PW_EAP_SIM_RAND,
0, PW_TYPE_OCTETS);
memset(newvp->vp_strvalue, 0, 2); /* clear reserved bytes */
memcpy(newvp->vp_strvalue+2+EAPSIM_RAND_SIZE*0, ess->keys.rand[0], EAPSIM_RAND_SIZE);
memcpy(newvp->vp_strvalue+2+EAPSIM_RAND_SIZE*1, ess->keys.rand[1], EAPSIM_RAND_SIZE);
memcpy(newvp->vp_strvalue+2+EAPSIM_RAND_SIZE*2, ess->keys.rand[2], EAPSIM_RAND_SIZE);
newvp->length = 2+EAPSIM_RAND_SIZE*3;
pairadd(outvps, newvp);
/* set the EAP_ID - new value */
newvp = paircreate(ATTRIBUTE_EAP_ID, 0, PW_TYPE_INTEGER);
newvp->vp_integer = ess->sim_id++;
pairreplace(outvps, newvp);
/* make a copy of the identity */
ess->keys.identitylen = strlen(handler->identity);
memcpy(ess->keys.identity, handler->identity, ess->keys.identitylen);
/* use the SIM identity, if available */
newvp = pairfind(*invps, ATTRIBUTE_EAP_SIM_BASE + PW_EAP_SIM_IDENTITY, 0, TAG_ANY);
if (newvp && newvp->length > 2) {
uint16_t len;
memcpy(&len, newvp->vp_octets, sizeof(uint16_t));
len = ntohs(len);
if (len <= newvp->length - 2 && len <= MAX_STRING_LEN) {
ess->keys.identitylen = len;
memcpy(ess->keys.identity, newvp->vp_octets + 2,
ess->keys.identitylen);
}
}
/* all set, calculate keys! */
eapsim_calculate_keys(&ess->keys);
#ifdef EAP_SIM_DEBUG_PRF
eapsim_dump_mk(&ess->keys);
#endif
/*
* need to include an AT_MAC attribute so that it will get
* calculated. The NONCE_MT and the MAC are both 16 bytes, so
* we store the NONCE_MT in the MAC for the encoder, which
* will pull it out before it does the operation.
*/
newvp = paircreate(ATTRIBUTE_EAP_SIM_BASE+PW_EAP_SIM_MAC,
0, PW_TYPE_OCTETS);
memcpy(newvp->vp_strvalue, ess->keys.nonce_mt, 16);
newvp->length = 16;
pairreplace(outvps, newvp);
newvp = paircreate(ATTRIBUTE_EAP_SIM_KEY, 0, PW_TYPE_OCTETS);
memcpy(newvp->vp_strvalue, ess->keys.K_aut, 16);
newvp->length = 16;
pairreplace(outvps, newvp);
/* the SUBTYPE, set to challenge. */
newvp = paircreate(ATTRIBUTE_EAP_SIM_SUBTYPE, 0, PW_TYPE_INTEGER);
newvp->vp_integer = eapsim_challenge;
pairreplace(outvps, newvp);
return 1;
}
/*
* we got an EAP-Request/Sim/Challenge message in a legal state.
*
* use the RAND challenge to produce the SRES result, and then
* use that to generate a new MAC.
*
* for the moment, we ignore the RANDs, then just plug in the SRES
* values.
*
*/
static int process_eap_challenge(RADIUS_PACKET *req,
RADIUS_PACKET *rep)
{
VALUE_PAIR *newvp;
VALUE_PAIR *mac, *randvp;
VALUE_PAIR *sres1,*sres2,*sres3;
VALUE_PAIR *Kc1, *Kc2, *Kc3;
uint8_t calcmac[20];
/* look for the AT_MAC and the challenge data */
mac = pairfind(req->vps, ATTRIBUTE_EAP_SIM_BASE+PW_EAP_SIM_MAC, 0, TAG_ANY);
randvp= pairfind(req->vps, ATTRIBUTE_EAP_SIM_BASE+PW_EAP_SIM_RAND, 0, TAG_ANY);
if(!mac || !randvp) {
fprintf(stderr, "radeapclient: challenge message needs to contain RAND and MAC\n");
return 0;
}
/*
* compare RAND with randX, to verify this is the right response
* to this challenge.
*/
{
VALUE_PAIR *randcfgvp[3];
uint8_t const *randcfg[3];
randcfg[0] = &randvp->vp_octets[2];
randcfg[1] = &randvp->vp_octets[2+EAPSIM_RAND_SIZE];
randcfg[2] = &randvp->vp_octets[2+EAPSIM_RAND_SIZE*2];
randcfgvp[0] = pairfind(rep->vps, ATTRIBUTE_EAP_SIM_RAND1, 0, TAG_ANY);
randcfgvp[1] = pairfind(rep->vps, ATTRIBUTE_EAP_SIM_RAND2, 0, TAG_ANY);
randcfgvp[2] = pairfind(rep->vps, ATTRIBUTE_EAP_SIM_RAND3, 0, TAG_ANY);
if(!randcfgvp[0] ||
!randcfgvp[1] ||
!randcfgvp[2]) {
fprintf(stderr, "radeapclient: needs to have rand1, 2 and 3 set.\n");
return 0;
}
if(memcmp(randcfg[0], randcfgvp[0]->vp_octets, EAPSIM_RAND_SIZE)!=0 ||
memcmp(randcfg[1], randcfgvp[1]->vp_octets, EAPSIM_RAND_SIZE)!=0 ||
memcmp(randcfg[2], randcfgvp[2]->vp_octets, EAPSIM_RAND_SIZE)!=0) {
int rnum,i,j;
fprintf(stderr, "radeapclient: one of rand 1,2,3 didn't match\n");
for(rnum = 0; rnum < 3; rnum++) {
fprintf(stderr, "received rand %d: ", rnum);
j=0;
for (i = 0; i < EAPSIM_RAND_SIZE; i++) {
if(j==4) {
printf("_");
j=0;
}
j++;
fprintf(stderr, "%02x", randcfg[rnum][i]);
}
fprintf(stderr, "\nconfigured rand %d: ", rnum);
j=0;
for (i = 0; i < EAPSIM_RAND_SIZE; i++) {
if(j==4) {
printf("_");
j=0;
}
j++;
fprintf(stderr, "%02x", randcfgvp[rnum]->vp_octets[i]);
}
fprintf(stderr, "\n");
}
return 0;
}
}
/*
* now dig up the sres values from the response packet,
* which were put there when we read things in.
*
* Really, they should be calculated from the RAND!
*
*/
sres1 = pairfind(rep->vps, ATTRIBUTE_EAP_SIM_SRES1, 0, TAG_ANY);
sres2 = pairfind(rep->vps, ATTRIBUTE_EAP_SIM_SRES2, 0, TAG_ANY);
sres3 = pairfind(rep->vps, ATTRIBUTE_EAP_SIM_SRES3, 0, TAG_ANY);
if(!sres1 ||
!sres2 ||
!sres3) {
fprintf(stderr, "radeapclient: needs to have sres1, 2 and 3 set.\n");
return 0;
}
memcpy(eapsim_mk.sres[0], sres1->vp_strvalue, sizeof(eapsim_mk.sres[0]));
memcpy(eapsim_mk.sres[1], sres2->vp_strvalue, sizeof(eapsim_mk.sres[1]));
memcpy(eapsim_mk.sres[2], sres3->vp_strvalue, sizeof(eapsim_mk.sres[2]));
Kc1 = pairfind(rep->vps, ATTRIBUTE_EAP_SIM_KC1, 0, TAG_ANY);
Kc2 = pairfind(rep->vps, ATTRIBUTE_EAP_SIM_KC2, 0, TAG_ANY);
Kc3 = pairfind(rep->vps, ATTRIBUTE_EAP_SIM_KC3, 0, TAG_ANY);
if(!Kc1 ||
!Kc2 ||
!Kc3) {
fprintf(stderr, "radeapclient: needs to have Kc1, 2 and 3 set.\n");
return 0;
}
memcpy(eapsim_mk.Kc[0], Kc1->vp_strvalue, sizeof(eapsim_mk.Kc[0]));
memcpy(eapsim_mk.Kc[1], Kc2->vp_strvalue, sizeof(eapsim_mk.Kc[1]));
memcpy(eapsim_mk.Kc[2], Kc3->vp_strvalue, sizeof(eapsim_mk.Kc[2]));
/* all set, calculate keys */
eapsim_calculate_keys(&eapsim_mk);
if(debug_flag) {
eapsim_dump_mk(&eapsim_mk);
}
/* verify the MAC, now that we have all the keys. */
if(eapsim_checkmac(NULL, req->vps, eapsim_mk.K_aut,
eapsim_mk.nonce_mt, sizeof(eapsim_mk.nonce_mt),
calcmac)) {
printf("MAC check succeed\n");
} else {
int i, j;
j=0;
printf("calculated MAC (");
for (i = 0; i < 20; i++) {
if(j==4) {
printf("_");
j=0;
}
j++;
printf("%02x", calcmac[i]);
}
printf(" did not match\n");
return 0;
}
/* form new response clear of any EAP stuff */
cleanresp(rep);
/* mark the subtype as being EAP-SIM/Response/Start */
newvp = paircreate(rep, ATTRIBUTE_EAP_SIM_SUBTYPE, 0);
newvp->vp_integer = eapsim_challenge;
pairreplace(&(rep->vps), newvp);
{
uint8_t *p;
/*
* fill the SIM_MAC with a field that will in fact get appended
* to the packet before the MAC is calculated
*/
newvp = paircreate(rep, ATTRIBUTE_EAP_SIM_BASE+PW_EAP_SIM_MAC, 0);
p = talloc_zero_array(newvp, uint8_t, EAPSIM_SRES_SIZE*3);
memcpy(p+EAPSIM_SRES_SIZE * 0, sres1->vp_strvalue, EAPSIM_SRES_SIZE);
memcpy(p+EAPSIM_SRES_SIZE * 1, sres2->vp_strvalue, EAPSIM_SRES_SIZE);
memcpy(p+EAPSIM_SRES_SIZE * 2, sres3->vp_strvalue, EAPSIM_SRES_SIZE);
pairmemsteal(newvp, p);
pairreplace(&(rep->vps), newvp);
}
newvp = paircreate(rep, ATTRIBUTE_EAP_SIM_KEY, 0);
pairmemcpy(newvp, eapsim_mk.K_aut, EAPSIM_AUTH_SIZE);
pairreplace(&(rep->vps), newvp);
return 1;
}