int
main(int argc, char **argv)
{
DKIM_STAT status;
u_int verifycnt = 0;
int c;
int w;
int rate;
size_t msgsize = DEFMSGSIZE;
size_t msgrem;
size_t wsz;
time_t start = DEFTESTINT;
time_t testint = DEFTESTINT;
dkim_canon_t hcanon = DKIM_CANON_RELAXED;
dkim_canon_t bcanon = DKIM_CANON_SIMPLE;
dkim_alg_t signalg = DKIM_SIGN_UNKNOWN;
dkim_query_t qtype = DKIM_QUERY_FILE;
char *p;
DKIM *dkim;
DKIM_LIB *lib;
dkim_sigkey_t key;
unsigned char hdr[MAXHEADER + 1];
unsigned char body[BODYBUFRSZ];
progname = (p = strrchr(argv[0], '/')) == NULL ? argv[0] : p + 1;
while ((c = getopt(argc, argv, "b:h:m:s:t:")) != -1)
{
switch (c)
{
case 'b':
bcanon = canon_code(optarg);
if (bcanon == (dkim_canon_t) -1)
{
fprintf(stderr,
"%s: unknown canonicalization '%s'\n",
progname, optarg);
return EX_USAGE;
}
break;
case 'h':
hcanon = canon_code(optarg);
if (hcanon == (dkim_canon_t) -1)
{
fprintf(stderr,
"%s: unknown canonicalization '%s'\n",
progname, optarg);
return EX_USAGE;
}
break;
case 'm':
msgsize = strtoul(optarg, &p, 10);
if (*p != '\0')
{
fprintf(stderr, "%s: invalid size '%s'\n",
progname, optarg);
return EX_USAGE;
}
break;
case 's':
signalg = alg_code(optarg);
if (signalg == (dkim_alg_t) -1)
{
fprintf(stderr,
"%s: unknown signing algorithm '%s'\n",
progname, optarg);
return EX_USAGE;
}
break;
case 't':
testint = strtoul(optarg, &p, 10);
if (*p != '\0')
{
fprintf(stderr, "%s: invalid seconds '%s'\n",
progname, optarg);
return EX_USAGE;
}
break;
default:
return usage();
}
}
#ifdef USE_GNUTLS
(void) gnutls_global_init();
#endif /* USE_GNUTLS */
/* instantiate the library */
lib = dkim_init(NULL, NULL);
if (signalg == DKIM_SIGN_UNKNOWN)
{
if (dkim_libfeature(lib, DKIM_FEATURE_SHA256))
signalg = DKIM_SIGN_RSASHA256;
else
signalg = DKIM_SIGN_RSASHA1;
}
else if (signalg == DKIM_SIGN_RSASHA256 &&
!dkim_libfeature(lib, DKIM_FEATURE_SHA256))
{
fprintf(stdout,
"### requested signing algorithm not available\n");
dkim_close(lib);
return 1;
}
fprintf(stdout,
"*** VERIFYING SPEED TEST: %s/%s with %s, size %u for %lds\n",
canon_name(hcanon), canon_name(bcanon), alg_name(signalg),
(unsigned int) msgsize, (long) testint);
key = KEY;
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_QUERYMETHOD,
&qtype, sizeof qtype);
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_QUERYINFO,
KEYFILE, strlen(KEYFILE));
srandom(time(NULL));
/* prepare a random body buffer */
for (c = 0, w = 0; c < sizeof body; c++)
{
if (w >= 75 && c < sizeof body - 2)
{
body[c++] = '\r';
body[c++] = '\n';
w = 0;
}
body[c++] = (random() + 32) % 127;
w++;
}
/* generate the signature */
dkim = dkim_sign(lib, JOBID, NULL, key, SELECTOR, DOMAIN,
hcanon, bcanon, signalg, -1L, &status);
status = dkim_header(dkim, HEADER02, strlen(HEADER02));
status = dkim_header(dkim, HEADER03, strlen(HEADER03));
status = dkim_header(dkim, HEADER04, strlen(HEADER04));
status = dkim_header(dkim, HEADER05, strlen(HEADER05));
status = dkim_header(dkim, HEADER06, strlen(HEADER06));
status = dkim_header(dkim, HEADER07, strlen(HEADER07));
status = dkim_header(dkim, HEADER08, strlen(HEADER08));
status = dkim_header(dkim, HEADER09, strlen(HEADER09));
status = dkim_eoh(dkim);
msgrem = msgsize;
while (msgrem > 0)
{
wsz = MIN(msgrem, sizeof body);
status = dkim_body(dkim, body, wsz);
msgrem -= wsz;
}
status = dkim_eom(dkim, NULL);
memset(hdr, '\0', sizeof hdr);
snprintf(hdr, sizeof hdr, "%s: ", DKIM_SIGNHEADER);
status = dkim_getsighdr(dkim, hdr + strlen(hdr),
sizeof hdr - strlen(hdr),
strlen(hdr) + 1);
status = dkim_free(dkim);
(void) time(&start);
/* begin the verify loop */
while (time(NULL) < start + testint)
{
dkim = dkim_verify(lib, JOBID, NULL, &status);
status = dkim_header(dkim, hdr, strlen(hdr));
status = dkim_header(dkim, HEADER02, strlen(HEADER02));
status = dkim_header(dkim, HEADER03, strlen(HEADER03));
status = dkim_header(dkim, HEADER04, strlen(HEADER04));
status = dkim_header(dkim, HEADER05, strlen(HEADER05));
status = dkim_header(dkim, HEADER06, strlen(HEADER06));
status = dkim_header(dkim, HEADER07, strlen(HEADER07));
status = dkim_header(dkim, HEADER08, strlen(HEADER08));
status = dkim_header(dkim, HEADER09, strlen(HEADER09));
status = dkim_eoh(dkim);
msgrem = DEFMSGSIZE;
while (msgrem > 0)
{
wsz = MIN(msgrem, sizeof body);
status = dkim_body(dkim, body, wsz);
msgrem -= wsz;
}
status = dkim_eom(dkim, NULL);
status = dkim_free(dkim);
verifycnt++;
}
dkim_close(lib);
rate = verifycnt / testint;
fprintf(stdout, "*** %u messages verified (%d msgs/sec)\n",
verifycnt, rate);
return 0;
}
int main(int argc, char **argv)
{
key_data key;
int inc = 10;
int num_trials = 1;
// Initialize the microblaze platform...
init_platform();
// Set up the attack incremement
if (inc > 0)
{
inc = 1 << inc;
}
printf("\nStudy increment: %d", inc);
// Display the algorithm.
printf("\nUsing algorithm \"%s\"", alg_name());
printf("\nAttacking key \"%s\"", argv[1]);
// Display the number of trials...
if (num_trials != 1)
{
printf("\nNumber of trials: %d", num_trials);
}
/*
else if (out_file)
printf("\nOutputting to file: %s", out_file);
else if (in_file)
printf("\nReading from file: %s", in_file);
*/
#ifdef NONE_AES
printf("\nAttacking NONE_AES_CORE implementation");
#elif defined(SMALL_AES)
printf("\nAttacking SMALL_AES_CORE implementation");
#else
printf("\nAttacking traditional AES_CORE implementation");
#endif
#ifdef DECRYPT_MODE
printf("\nDECRYPT MODE");
#else
printf("\nENCRYPT MODE");
#endif
cache_evict_init();
int * results = malloc(num_trials * sizeof(int));
timing_pair * buffer = malloc(BUF_SIZE * sizeof(timing_pair));
timing_data * data = malloc(sizeof(timing_data));
if (data == 0x0)
{
printf("Data couldn't allocate.\n");
return;
}
if (buffer == 0x0)
{
printf("Buffer couldn't allocate.\n");
return;
}
FILE * in;
//if (!USE_RANDOM_KEY)
{
printf("Initializing random key...\n");
re_key(&key, argv[1]);
}
fflush(stdout);
/*
if (out_file)
{
output_timings(out_file, buffer, inc, &key);
return 1;
}
if (in_file)
{
char open_type = 'r';
in = fopen(in_file, &open_type);
if (in == NULL)
{
printf("\nCould not open file: %s", in_file);
return -1;
}
}
*/
int round, i;
for (round = 1; round <= num_trials; round++)
{
printf("\nBeginning Attack #%d\n", round);
init_data(data);
//if (USE_RANDOM_KEY)
// reseed with a random key
re_key(&key, "/dev/random");
long long num_studies = 0;
double clip_time = 0;
int success = 0;
long long max = MAX_STUDY;
while (num_studies < max && !success)
{
printf("num_studies = %d\n", num_studies);
int offset = num_studies % BUF_SIZE;
if (inc > BUF_SIZE)
{
int read = 0;
int num_read = BUF_SIZE;
while (read < inc)
{
//printf("read = %d\n", read);
generate_samples(buffer, &key);
printf("buffer address %x:\n", buffer);
printf("data address = %x\n", data);
clip_time = calculate_clip_time(buffer, num_read);
for (i = 0; i < BUF_SIZE && read < inc; i++)
{
//printf("i = %d\n", i);
if (buffer[offset + i].time < clip_time)
record_timing(data, &buffer[offset + i]);
read++;
}
}
}
else
{
printf("inc <= BUF_SIZE\n");
if (offset == 0)
{
int num_read = BUF_SIZE;
//if (!in_file)
generate_samples(buffer, &key);
printf("generate_samples done\n");
/*else
{
num_read = fread(buffer, sizeof(timing_pair), BUF_SIZE,
in);
if (num_read < BUF_SIZE)
max = num_studies + num_read;
printf("\nRead in %d samples ", num_read);
}*/
clip_time = calculate_clip_time(buffer, num_read);
printf("clip_time done\n");
}
for (i = 0; i < inc; i++)
printf("i (inc) = %d\n", i);
if (buffer[offset + i].time < clip_time)
record_timing(data, &buffer[offset + i]);
}
num_studies += inc;
printf("\nchecking data!\n");
if (check_data(data, &key))
{
printf(
"\nKey recovered after studying %lld samples (< 2^%d)\n",
num_studies, bound(num_studies));
success = 1;
}
else
printf("\nNo success after studying %d samples", num_studies);
}
if (!success)
printf("Attack failed after %d encryptions", num_studies);
else
{
int j = round - 1;
while (j > 0 && results[j - 1] > num_studies)
{
results[j] = results[j - 1];
j--;
}
results[j] = num_studies;
printf("\nResults: ");
int total = 0;
for (j = 0; j < round; j++)
{
printf(" %d ", results[j]);
total += results[j];
}
printf("\nMin: %d", results[0]);
printf("\nMax: %d", results[round - 1]);
printf("\nMed: %d", results[round / 2]);
printf("\nMean: %.2f", ((double) total) / round);
}
}
// Clean up and terminate...
cleanup_platform();
}
