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)
{
#ifdef TEST_KEEP_FILES
u_int flags;
#endif /* TEST_KEEP_FILES */
DKIM_STAT status;
DKIM *dkim;
DKIM_LIB *lib;
dkim_sigkey_t key;
printf("*** invalid key preload test\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 */
key = BADKEY;
dkim = dkim_sign(lib, JOBID, NULL, key, SELECTOR, DOMAIN,
DKIM_CANON_RELAXED, DKIM_CANON_RELAXED,
DKIM_SIGN_RSASHA1, -1L, &status);
assert(dkim != NULL);
status = dkim_privkey_load(dkim);
assert(status == DKIM_STAT_NORESOURCE);
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;
}
yastr
env_dkim_sign( struct envelope *env )
{
char df[ MAXPATHLEN + 1 ];
DKIM_LIB *libhandle;
unsigned int flags;
DKIM *dkim;
DKIM_STAT result;
yastr signature = NULL;
yastr key = NULL;
yastr tmp = NULL;
yastr *split = NULL;
size_t tok_count = 0;
char buf[ 1024 * 1024 ];
unsigned char *dkim_header;
SNET *snet;
ssize_t chunk;
sprintf( df, "%s/D%s", env->e_dir, env->e_id );
if (( snet = snet_open( simta_dkim_key, O_RDONLY, 0,
1024 * 1024 )) == NULL ) {
syslog( LOG_ERR, "Liberror: env_dkim_sign snet_open %s: %m",
simta_dkim_key );
return( NULL );
}
key = yaslempty();
while (( chunk = snet_read( snet, buf, 1024 * 1024, NULL )) > 0 ) {
key = yaslcatlen( key, buf, chunk );
}
snet_close( snet );
if (( libhandle = dkim_init( NULL, NULL )) == NULL ) {
syslog( LOG_ERR, "Liberror: env_dkim_sign dkim_init" );
return( NULL );
}
/* Data is stored in UNIX format, so tell libopendkim to fix
* CRLF issues.
*/
flags = DKIM_LIBFLAGS_FIXCRLF;
dkim_options( libhandle, DKIM_OP_SETOPT, DKIM_OPTS_FLAGS, &flags,
sizeof( flags ));
/* Only sign the headers recommended by RFC 6376 */
dkim_options( libhandle, DKIM_OP_SETOPT, DKIM_OPTS_SIGNHDRS,
dkim_should_signhdrs, sizeof( unsigned char ** ));
if (( dkim = dkim_sign( libhandle, (unsigned char *)(env->e_id), NULL,
(unsigned char *)key, (unsigned char *)simta_dkim_selector,
(unsigned char *)simta_dkim_domain,
DKIM_CANON_RELAXED, DKIM_CANON_RELAXED, DKIM_SIGN_RSASHA256,
-1, &result )) == NULL ) {
syslog( LOG_NOTICE, "Liberror: env_dkim_sign dkim_sign: %s",
dkim_getresultstr( result ));
goto error;
}
if (( snet = snet_open( df, O_RDONLY, 0, 1024 * 1024 )) == NULL ) {
syslog( LOG_ERR, "Liberror: env_dkim_sign snet_open %s: %m",
buf );
goto error;
}
while (( chunk = snet_read( snet, buf, 1024 * 1024, NULL )) > 0 ) {
if (( result = dkim_chunk( dkim, (unsigned char *)buf,
chunk )) != 0 ) {
syslog( LOG_NOTICE, "Liberror: env_dkim_sign dkim_chunk: %s: %s",
dkim_getresultstr( result ),
dkim_geterror( dkim ));
snet_close( snet );
goto error;
}
}
snet_close( snet );
if (( result = dkim_chunk( dkim, NULL, 0 )) != 0 ) {
syslog( LOG_NOTICE, "Liberror: env_dkim_sign dkim_chunk: %s: %s",
dkim_getresultstr( result ),
dkim_geterror( dkim ));
goto error;
}
if (( result = dkim_eom( dkim, NULL )) != 0 ) {
syslog( LOG_NOTICE, "Liberror: env_dkim_sign dkim_eom: %s: %s",
dkim_getresultstr( result ),
dkim_geterror( dkim ));
goto error;
}
if (( result = dkim_getsighdr_d( dkim, 16, &dkim_header,
(size_t *)&chunk )) != 0 ) {
syslog( LOG_NOTICE,
"Liberror: env_dkim_sign dkim_getsighdr_d: %s: %s",
dkim_getresultstr( result ),
dkim_geterror( dkim ));
goto error;
}
/* Get rid of carriage returns in libopendkim output */
split = yaslsplitlen( (const char *)dkim_header,
strlen( (const char *)dkim_header ), "\r", 1, &tok_count );
tmp = yasljoinyasl( split, tok_count, "", 0 );
signature = yaslcatyasl( yaslauto( "DKIM-Signature: " ), tmp );
error:
yaslfree( tmp );
yaslfreesplitres( split, tok_count );
yaslfree( key );
dkim_free( dkim );
dkim_close( libhandle );
return( signature );
}
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;
uint64_t fixed_time;
DKIM *dkim;
DKIM_LIB *lib;
dkim_sigkey_t key;
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/relaxed rsa-sha256 signing with lengths SKIPPED\n");
dkim_close(lib);
return 0;
}
printf("*** simple/relaxed rsa-sha256 signing with lengths\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_GETOPT, DKIM_OPTS_FLAGS, &flags,
sizeof flags);
flags |= DKIM_LIBFLAGS_SIGNLEN;
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_FLAGS, &flags,
sizeof flags);
key = KEY;
dkim = dkim_sign(lib, JOBID, NULL, key, SELECTOR, DOMAIN,
DKIM_CANON_SIMPLE, DKIM_CANON_RELAXED,
DKIM_SIGN_RSASHA256, -1L, &status);
assert(dkim != NULL);
/* fix signing time */
fixed_time = 1172620939;
(void) dkim_options(lib, DKIM_OP_SETOPT, DKIM_OPTS_FIXEDTIME,
&fixed_time, sizeof fixed_time);
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);
memset(hdr, '\0', sizeof hdr);
status = dkim_getsighdr(dkim, hdr, sizeof hdr,
strlen(DKIM_SIGNHEADER) + 2);
assert(status == DKIM_STAT_OK);
assert(strcmp(SIG2, hdr) == 0);
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;
}
