void pluto_do_crypto_op(struct pluto_crypto_req *r)
{
switch(r->pcr_type)
{
case pcr_build_kenonce:
calc_ke(r);
calc_nonce(r);
break;
case pcr_build_nonce:
calc_nonce(r);
break;
case pcr_compute_dh_iv:
calc_dh_iv(r);
break;
case pcr_compute_dh:
calc_dh(r);
break;
case pcr_compute_dh_v2:
calc_dh_v2(r);
break;
case pcr_rsa_sign:
case pcr_rsa_check:
case pcr_x509cert_fetch:
case pcr_x509crl_fetch:
break;
}
}
void pluto_do_crypto_op(struct pluto_crypto_req *r, int helpernum)
{
DBG(DBG_CONTROL
, DBG_log("helper %d doing %s op id: %u"
, helpernum
, enum_show(&pluto_cryptoop_names, r->pcr_type)
, r->pcr_id));
#else
void pluto_do_crypto_op(struct pluto_crypto_req *r)
{
DBG(DBG_CONTROL
, DBG_log("helper %d doing %s op id: %u"
, pc_helper_num
, enum_show(&pluto_cryptoop_names, r->pcr_type)
, r->pcr_id));
#endif
#ifdef DEBUG
{
char *d = getenv("PLUTO_CRYPTO_HELPER_DELAY");
if(d != NULL) {
int delay=atoi(d);
DBG_log("helper is pausing for %d seconds", delay);
sleep(delay);
}
}
#endif
/* now we have the entire request in the buffer, process it */
switch(r->pcr_type) {
case pcr_build_kenonce:
calc_ke(r);
calc_nonce(r);
break;
case pcr_build_nonce:
calc_nonce(r);
break;
case pcr_compute_dh_iv:
calc_dh_iv(r);
break;
case pcr_compute_dh:
calc_dh(r);
break;
case pcr_compute_dh_v2:
calc_dh_v2(r);
break;
case pcr_rsa_sign:
case pcr_rsa_check:
case pcr_x509cert_fetch:
case pcr_x509crl_fetch:
break;
}
}
static void pluto_do_crypto_op(struct pluto_crypto_req *r, int helpernum)
{
struct timeval tv0;
gettimeofday(&tv0, NULL);
const char *story = NULL;
DBG(DBG_CONTROL,
DBG_log("crypto helper %d doing %s; request ID %u",
helpernum,
enum_show(&pluto_cryptoop_names, r->pcr_type),
r->pcr_id));
if (crypto_helper_delay > 0) {
DBG_log("crypto helper is pausing for %u seconds",
crypto_helper_delay);
sleep(crypto_helper_delay);
}
/* now we have the entire request in the buffer, process it */
switch (r->pcr_type) {
case pcr_build_ke_and_nonce:
calc_ke(r);
/* FALL THROUGH */
case pcr_build_nonce:
calc_nonce(r);
break;
case pcr_compute_dh_iv:
calc_dh_iv(r);
break;
case pcr_compute_dh:
calc_dh(r);
break;
case pcr_compute_dh_v2:
calc_dh_v2(r, &story);
break;
}
DBG(DBG_CONTROL, {
struct timeval tv1;
unsigned long tv_diff;
gettimeofday(&tv1, NULL);
tv_diff = (tv1.tv_sec - tv0.tv_sec) * 1000000 + (tv1.tv_usec - tv0.tv_usec);
DBG_log("crypto helper %d finished %s%s; request ID %u time elapsed %ld usec",
helpernum,
enum_show(&pluto_cryptoop_names, r->pcr_type),
(story != NULL) ? story : "",
r->pcr_id, tv_diff));
}
}
int main(int argc, char *argv[])
{
struct pluto_crypto_req r;
struct pcr_skeycalc_v2 *skr = &r.pcr_d.dhv2;
struct pcr_skeyid_q *skq = &r.pcr_d.dhq;
progname = argv[0];
cur_debugging = DBG_CRYPT;
/* initialize list of moduli */
init_crypto();
skq->thespace.start = 0;
skq->thespace.len = sizeof(skq->space);
skq->auth = tc2_auth;
skq->prf_hash = tc2_hash;
skq->integ_hash = tc2_hash;
skq->oakley_group = tc2_oakleygroup;
skq->init = tc2_init;
skq->keysize = tc2_encrypter->keydeflen/BITS_PER_BYTE;
#define copydatlen(field, data, len) do { \
chunk_t tchunk; \
setchunk(tchunk, data, len); \
pluto_crypto_copychunk(&skq->thespace, skq->space \
, &skq->field, tchunk); } \
while(0)
copydatlen(ni, tc2_ni, tc2_ni_len);
copydatlen(nr, tc2_nr, tc2_nr_len);
copydatlen(gi, tc2_gi, tc2_gi_len);
copydatlen(gr, tc2_gr, tc2_gr_len);
copydatlen(secret, tc2_secret, tc2_secret_len);
copydatlen(icookie, tc2_icookie, tc2_icookie_len);
copydatlen(rcookie, tc2_rcookie, tc2_rcookie_len);
#define dumpdat(field) \
libreswan_DBG_dump(#field, \
wire_chunk_ptr(skq, &skq->field), \
skq->field.len);
dumpdat(icookie);
dumpdat(rcookie);
dumpdat(ni);
dumpdat(nr);
dumpdat(gi);
dumpdat(gr);
dumpdat(secret);
fflush(stdout);
fflush(stderr);
calc_dh_v2(&r);
printf("\noutput:\n");
fflush(stdout);
fflush(stderr);
#define dumpskr(FOO) { void *FOO = wire_chunk_ptr(skr, &skr->FOO);\
libreswan_DBG_dump(#FOO, FOO, skr->FOO.len); \
}
dumpskr(shared);
dumpskr(skeyseed);
dumpskr(skeyid_d);
dumpskr(skeyid_ai);
dumpskr(skeyid_ar);
dumpskr(skeyid_ei);
dumpskr(skeyid_er);
dumpskr(skeyid_pi);
dumpskr(skeyid_pr);
exit(0);
}
int main(int argc, char *argv[])
{
struct pluto_crypto_req r;
struct pcr_skeycalc_v2_r *skr = &r.pcr_d.dhv2;
struct pcr_skeyid_q *skq = &r.pcr_d.dhq;
char *story;
progname = argv[0];
cur_debugging = DBG_CRYPT;
/* initialize list of moduli */
init_crypto();
INIT_WIRE_ARENA(*skq);
skq->auth = tc2_auth;
skq->prf_hash = tc2_hash;
skq->integ_hash = tc2_hash;
skq->oakley_group = tc2_oakleygroup;
skq->init = tc2_init;
skq->keysize = tc2_encrypter->keydeflen / BITS_PER_BYTE;
#define copydatlen(field, data, len) { \
chunk_t tchunk; \
setchunk(tchunk, data, len); \
WIRE_CLONE_CHUNK(*skq, field, tchunk); \
}
copydatlen(ni, tc2_ni, tc2_ni_len);
copydatlen(nr, tc2_nr, tc2_nr_len);
copydatlen(gi, tc2_gi, tc2_gi_len);
copydatlen(gr, tc2_gr, tc2_gr_len);
copydatlen(secret, tc2_secret, tc2_secret_len);
copydatlen(icookie, tc2_icookie, tc2_icookie_len);
copydatlen(rcookie, tc2_rcookie, tc2_rcookie_len);
#define dumpdat(field) \
libreswan_DBG_dump(#field, \
WIRE_CHUNK_PTR(*skq, field), \
skq->field.len);
dumpdat(icookie);
dumpdat(rcookie);
dumpdat(ni);
dumpdat(nr);
dumpdat(gi);
dumpdat(gr);
dumpdat(secret);
fflush(stdout);
fflush(stderr);
calc_dh_v2(&r, &story);
printf("\noutput: %s\n", story);
fflush(stdout);
fflush(stderr);
#define dumpskr(FOO) { void *FOO = WIRE_CHUNK_PTR(*skr, FOO); \
libreswan_DBG_dump(#FOO, FOO, skr->FOO.len); \
}
dumpskr(shared);
dumpskr(skeyseed);
dumpskr(skeyid_d);
dumpskr(skeyid_ai);
dumpskr(skeyid_ar);
dumpskr(skeyid_ei);
dumpskr(skeyid_er);
dumpskr(skeyid_pi);
dumpskr(skeyid_pr);
exit(0);
}