IRuleRet & CDKIMRule::evaluate( CEmail & email )
{
#ifdef __DEBUG
std::cout << "CDKIMRule::evaluate( const CEmail & email )" << std::endl;
#endif
DKIM_LIB *dkim = dkim_init(NULL,NULL);
DKIM_STAT stat;
DKIM *verify = dkim_verify( dkim, NULL, NULL, &stat );
const char * email_body = email.body_raw();
#ifdef __DEBUG
std::cout << "Calling dkim_chunk" << std::endl;
#endif
stat = dkim_chunk( verify, (unsigned char *)email_body, strlen(email_body) );
if (stat != DKIM_STAT_OK){
#ifdef __DEBUG
std::cout << "DKIM Result [" << stat << "]" << std::endl;
#endif
}
dkim_close( dkim );
if (DKIM_STAT_OK == stat){
unsigned char *d = dkim_getdomain(verify);
std::string d_str = std::string( (char *)d );
email.insertVariable("dkim-d", d_str);
if (_d){
// Test if the supplied d=DOMAIN matches the verified d=
if (strcmp(_d, (char *)d) == 0){
return ( __ir( true != _not ) );
}
else {
return ( __ir( false != _not ) );
}
}
return ( __ir(true != _not) );
}
else {
const char *error_message = dkim_getresultstr(stat);
email.insertVariable("dkim:err", std::string(error_message));
}
return __ir( false != _not );
}
int
main(int argc, char **argv)
{
#ifdef TEST_KEEP_FILES
u_int flags;
#endif /* TEST_KEEP_FILES */
DKIM_STAT status;
DKIM *dkim;
DKIM_LIB *lib;
dkim_query_t qtype = DKIM_QUERY_FILE;
unsigned char hdr[MAXHEADER + 1];
printf("*** relaxed/relaxed rsa-sha1 verifying with empty \"t=\"\n");
#ifdef USE_GNUTLS
(void) gnutls_global_init();
#endif /* USE_GNUTLS */
/* instantiate the library */
lib = dkim_init(NULL, NULL);
assert(lib != NULL);
#ifdef TEST_KEEP_FILES
/* set flags */
flags = (DKIM_LIBFLAGS_TMPFILES|DKIM_LIBFLAGS_KEEPFILES);
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_FLAGS, &flags,
sizeof flags);
#endif /* TEST_KEEP_FILES */
(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));
dkim = dkim_verify(lib, JOBID, NULL, &status);
assert(dkim != NULL);
snprintf(hdr, sizeof hdr, "%s: %s", DKIM_SIGNHEADER, SIG2);
status = dkim_header(dkim, hdr, strlen(hdr));
assert(status == DKIM_STAT_SYNTAX);
status = dkim_free(dkim);
assert(status == DKIM_STAT_OK);
dkim_close(lib);
return 0;
}
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)
{
#ifdef TEST_KEEP_FILES
u_int flags;
#endif /* TEST_KEEP_FILES */
int len;
time_t now;
DKIM_STAT status;
DKIM *dkim;
DKIM_LIB *lib;
dkim_query_t qtype = DKIM_QUERY_FILE;
unsigned char hdr[MAXHEADER + 1];
printf("*** relaxed/simple rsa-sha1 verifying with far future timestamp\n");
#ifdef USE_GNUTLS
(void) gnutls_global_init();
#endif /* USE_GNUTLS */
/* instantiate the library */
lib = dkim_init(NULL, NULL);
assert(lib != NULL);
#ifdef TEST_KEEP_FILES
/* set flags */
flags = (DKIM_LIBFLAGS_TMPFILES|DKIM_LIBFLAGS_KEEPFILES);
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_FLAGS, &flags,
sizeof flags);
#endif /* TEST_KEEP_FILES */
(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));
dkim = dkim_verify(lib, JOBID, NULL, &status);
assert(dkim != NULL);
(void) time(&now);
len = snprintf(hdr, sizeof hdr, "%s: ", DKIM_SIGNHEADER);
snprintf(hdr + len, sizeof hdr - len, SIG2, (long) (now + 86400));
status = dkim_header(dkim, hdr, strlen(hdr));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER01, strlen(HEADER01));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER02, strlen(HEADER02));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER03, strlen(HEADER03));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER04, strlen(HEADER04));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER05, strlen(HEADER05));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER06, strlen(HEADER06));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER07, strlen(HEADER07));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER08, strlen(HEADER08));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER09, strlen(HEADER09));
assert(status == DKIM_STAT_OK);
status = dkim_eoh(dkim);
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY00, strlen(BODY00));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01, strlen(BODY01));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01A, strlen(BODY01A));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01B, strlen(BODY01B));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01C, strlen(BODY01C));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01D, strlen(BODY01D));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01E, strlen(BODY01E));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY02, strlen(BODY02));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY04, strlen(BODY04));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY05, strlen(BODY05));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_eom(dkim, NULL);
assert(status == DKIM_STAT_CANTVRFY);
status = dkim_free(dkim);
assert(status == DKIM_STAT_OK);
dkim_close(lib);
return 0;
}
int
main(int argc, char **argv)
{
#ifdef TEST_KEEP_FILES
u_int flags;
#endif /* TEST_KEEP_FILES */
DKIM_STAT status;
uint64_t fixed_time;
dkim_sigkey_t key;
DKIM *dkim;
DKIM *resign;
DKIM_LIB *lib;
dkim_query_t qtype = DKIM_QUERY_FILE;
unsigned char hdr[MAXHEADER + 1];
unsigned char hdr2[MAXHEADER + 1];
key = KEY;
#ifdef USE_GNUTLS
(void) gnutls_global_init();
#endif /* USE_GNUTLS */
/* instantiate the library */
lib = dkim_init(NULL, NULL);
assert(lib != NULL);
if (!dkim_libfeature(lib, DKIM_FEATURE_RESIGN))
{
printf("*** relaxed/simple rsa-sha1 re-signing with header binding SKIPPED\n");
dkim_close(lib);
return 0;
}
printf("*** relaxed/simple rsa-sha1 re-signing with header binding\n");
#ifdef TEST_KEEP_FILES
/* set flags */
flags = (DKIM_LIBFLAGS_TMPFILES|DKIM_LIBFLAGS_KEEPFILES);
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_FLAGS, &flags,
sizeof flags);
#endif /* TEST_KEEP_FILES */
/* test mode */
(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));
/* fix signing time */
fixed_time = 1172620939;
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_FIXEDTIME,
&fixed_time, sizeof fixed_time);
/* restrict signed headers */
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_SIGNHDRS,
dkim_should_signhdrs, sizeof(u_char **));
dkim = dkim_verify(lib, JOBID, NULL, &status);
assert(dkim != NULL);
snprintf(hdr, sizeof hdr, "%s: %s", DKIM_SIGNHEADER, SIG2);
status = dkim_header(dkim, hdr, strlen(hdr));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER01, strlen(HEADER01));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER02, strlen(HEADER02));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER03, strlen(HEADER03));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER04, strlen(HEADER04));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER05, strlen(HEADER05));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER06, strlen(HEADER06));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER07, strlen(HEADER07));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER08, strlen(HEADER08));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER09, strlen(HEADER09));
assert(status == DKIM_STAT_OK);
resign = dkim_sign(lib, JOBID, NULL, key, SELECTOR, DOMAIN,
DKIM_CANON_RELAXED, DKIM_CANON_SIMPLE,
DKIM_SIGN_RSASHA1, -1L, &status);
assert(resign != NULL);
status = dkim_resign(dkim, resign, TRUE);
assert(status == DKIM_STAT_INVALID);
status = dkim_resign(resign, dkim, TRUE);
assert(status == DKIM_STAT_OK);
status = dkim_eoh(dkim);
assert(status == DKIM_STAT_OK);
status = dkim_eoh(resign);
assert(status == DKIM_STAT_INVALID);
status = dkim_body(dkim, BODY00, strlen(BODY00));
assert(status == DKIM_STAT_OK);
status = dkim_body(resign, BODY00, strlen(BODY00));
assert(status == DKIM_STAT_INVALID);
status = dkim_body(dkim, BODY01, strlen(BODY01));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01A, strlen(BODY01A));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01B, strlen(BODY01B));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01C, strlen(BODY01C));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01D, strlen(BODY01D));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01E, strlen(BODY01E));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY02, strlen(BODY02));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY04, strlen(BODY04));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY05, strlen(BODY05));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_eom(resign, NULL);
assert(status == DKIM_STAT_INVALID);
status = dkim_eom(dkim, NULL);
assert(status == DKIM_STAT_OK);
status = dkim_eom(resign, NULL);
assert(status == DKIM_STAT_OK);
memset(hdr, '\0', sizeof hdr);
status = dkim_getsighdr(resign, hdr, sizeof hdr,
strlen(DKIM_SIGNHEADER) + 2);
assert(status == DKIM_STAT_OK);
status = dkim_free(dkim);
assert(status == DKIM_STAT_INVALID);
status = dkim_free(resign);
assert(status == DKIM_STAT_OK);
status = dkim_free(dkim);
assert(status == DKIM_STAT_OK);
/* now see if that one was valid */
dkim = dkim_verify(lib, JOBID, NULL, &status);
assert(dkim != NULL);
snprintf(hdr2, sizeof hdr2, "%s: %s", DKIM_SIGNHEADER, hdr);
status = dkim_header(dkim, hdr2, strlen(hdr2));
assert(status == DKIM_STAT_OK);
snprintf(hdr2, sizeof hdr2, "%s: %s", DKIM_SIGNHEADER, SIG2);
status = dkim_header(dkim, hdr2, strlen(hdr2));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER01, strlen(HEADER01));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER02, strlen(HEADER02));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER03, strlen(HEADER03));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER04, strlen(HEADER04));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER05, strlen(HEADER05));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER06, strlen(HEADER06));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER07, strlen(HEADER07));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER08, strlen(HEADER08));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER09, strlen(HEADER09));
assert(status == DKIM_STAT_OK);
status = dkim_eoh(dkim);
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY00, strlen(BODY00));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01, strlen(BODY01));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01A, strlen(BODY01A));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01B, strlen(BODY01B));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01C, strlen(BODY01C));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01D, strlen(BODY01D));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY01E, strlen(BODY01E));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY02, strlen(BODY02));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY04, strlen(BODY04));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY05, strlen(BODY05));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_body(dkim, BODY03, strlen(BODY03));
assert(status == DKIM_STAT_OK);
status = dkim_eom(dkim, NULL);
assert(status == DKIM_STAT_OK);
status = dkim_free(dkim);
assert(status == DKIM_STAT_OK);
dkim_close(lib);
return 0;
}
int
main(int argc, char **argv)
{
u_int flags;
DKIM_STAT status;
DKIM *dkim;
DKIM_LIB *lib;
dkim_query_t qtype = DKIM_QUERY_FILE;
unsigned char hdr[MAXHEADER + 1];
#ifdef USE_GNUTLS
(void) gnutls_global_init();
#endif /* USE_GNUTLS */
/* instantiate the library */
lib = dkim_init(NULL, NULL);
assert(lib != NULL);
if (!dkim_libfeature(lib, DKIM_FEATURE_SHA256))
{
printf("*** simple/simple rsa-sha256 verify failure with EOH check SKIPPED\n");
dkim_close(lib);
return 0;
}
printf("*** simple/simple rsa-sha256 verify failure with EOH check\n");
/* set flags */
flags = DKIM_LIBFLAGS_EOHCHECK;
#ifdef TEST_KEEP_FILES
flags |= (DKIM_LIBFLAGS_TMPFILES|DKIM_LIBFLAGS_KEEPFILES);
#endif /* TEST_KEEP_FILES */
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_FLAGS, &flags,
sizeof flags);
(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));
dkim = dkim_verify(lib, JOBID, NULL, &status);
assert(dkim != NULL);
snprintf(hdr, sizeof hdr, "%s: %s", DKIM_SIGNHEADER, SIG2);
status = dkim_header(dkim, hdr, strlen(hdr));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER01, strlen(HEADER01));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER02, strlen(HEADER02));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER03, strlen(HEADER03));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER04, strlen(HEADER04));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER05, strlen(HEADER05));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER06, strlen(HEADER06));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER07, strlen(HEADER07));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER08, strlen(HEADER08));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER09, strlen(HEADER09));
assert(status == DKIM_STAT_OK);
status = dkim_eoh(dkim);
assert(status == DKIM_STAT_CANTVRFY);
status = dkim_free(dkim);
assert(status == DKIM_STAT_OK);
dkim_close(lib);
return 0;
}
int
main(int argc, char **argv)
{
#ifdef TEST_KEEP_FILES
u_int flags;
#endif /* TEST_KEEP_FILES */
int nsigs;
size_t hdrlen;
DKIM_STAT status;
DKIM *dkim;
DKIM_SIGINFO **sigs;
DKIM_LIB *lib;
dkim_query_t qtype = DKIM_QUERY_FILE;
unsigned char hdr[MAXHEADER + 1];
#ifdef USE_GNUTLS
(void) gnutls_global_init();
#endif /* USE_GNUTLS */
/* instantiate the library */
lib = dkim_init(NULL, NULL);
assert(lib != NULL);
if (!dkim_libfeature(lib, DKIM_FEATURE_SHA256))
{
printf("*** simple/simple rsa-sha256 signature substrings SKIPPED\n");
dkim_close(lib);
return 0;
}
printf("*** simple/simple rsa-sha256 verifying signature substrings\n");
#ifdef TEST_KEEP_FILES
/* set flags */
flags = (DKIM_LIBFLAGS_TMPFILES|DKIM_LIBFLAGS_KEEPFILES);
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_FLAGS, &flags,
sizeof flags);
#endif /* TEST_KEEP_FILES */
(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));
dkim = dkim_verify(lib, JOBID, NULL, &status);
assert(dkim != NULL);
snprintf(hdr, sizeof hdr, "%s: %s", DKIM_SIGNHEADER, SIG1);
status = dkim_header(dkim, hdr, strlen(hdr));
assert(status == DKIM_STAT_OK);
snprintf(hdr, sizeof hdr, "%s: %s", DKIM_SIGNHEADER, SIG2);
status = dkim_header(dkim, hdr, strlen(hdr));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER01, strlen(HEADER01));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER02, strlen(HEADER02));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER03, strlen(HEADER03));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER04, strlen(HEADER04));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER05, strlen(HEADER05));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER06, strlen(HEADER06));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER07, strlen(HEADER07));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER08, strlen(HEADER08));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER09, strlen(HEADER09));
assert(status == DKIM_STAT_OK);
status = dkim_eoh(dkim);
assert(status == DKIM_STAT_OK);
status = dkim_getsiglist(dkim, &sigs, &nsigs);
assert(status == DKIM_STAT_OK);
assert(nsigs == 2);
memset(hdr, '\0', sizeof hdr);
hdrlen = sizeof hdr - 1;
status = dkim_get_sigsubstring(dkim, sigs[0], hdr, &hdrlen);
assert(status == DKIM_STAT_OK);
assert(hdrlen == 8);
assert(strcmp(hdr, "V+wiYd1c") == 0);
status = dkim_get_sigsubstring(dkim, sigs[1], hdr, &hdrlen);
assert(status == DKIM_STAT_OK);
assert(hdrlen == 8);
assert(strcmp(hdr, "12345678") == 0);
status = dkim_free(dkim);
assert(status == DKIM_STAT_OK);
dkim = dkim_verify(lib, JOBID, NULL, &status);
assert(dkim != NULL);
snprintf(hdr, sizeof hdr, "%s: %s", DKIM_SIGNHEADER, SIG1);
status = dkim_header(dkim, hdr, strlen(hdr));
assert(status == DKIM_STAT_OK);
snprintf(hdr, sizeof hdr, "%s: %s", DKIM_SIGNHEADER, SIG2);
status = dkim_header(dkim, hdr, strlen(hdr));
assert(status == DKIM_STAT_OK);
snprintf(hdr, sizeof hdr, "%s: %s", DKIM_SIGNHEADER, SIG3);
status = dkim_header(dkim, hdr, strlen(hdr));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER01, strlen(HEADER01));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER02, strlen(HEADER02));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER03, strlen(HEADER03));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER04, strlen(HEADER04));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER05, strlen(HEADER05));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER06, strlen(HEADER06));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER07, strlen(HEADER07));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER08, strlen(HEADER08));
assert(status == DKIM_STAT_OK);
status = dkim_header(dkim, HEADER09, strlen(HEADER09));
assert(status == DKIM_STAT_OK);
status = dkim_eoh(dkim);
assert(status == DKIM_STAT_OK);
status = dkim_getsiglist(dkim, &sigs, &nsigs);
assert(status == DKIM_STAT_OK);
assert(nsigs == 3);
memset(hdr, '\0', sizeof hdr);
hdrlen = sizeof hdr - 1;
status = dkim_get_sigsubstring(dkim, sigs[0], hdr, &hdrlen);
assert(status == DKIM_STAT_OK);
assert(hdrlen == 10);
assert(strcmp(hdr, "V+wiYd1cE7") == 0);
status = dkim_get_sigsubstring(dkim, sigs[1], hdr, &hdrlen);
assert(status == DKIM_STAT_OK);
assert(hdrlen == 10);
assert(strcmp(hdr, "12345678Y3") == 0);
status = dkim_get_sigsubstring(dkim, sigs[2], hdr, &hdrlen);
assert(status == DKIM_STAT_OK);
assert(hdrlen == 10);
assert(strcmp(hdr, "12345678Y4") == 0);
status = dkim_free(dkim);
assert(status == DKIM_STAT_OK);
dkim_close(lib);
return 0;
}
