Changeset Navigation

← Previous Changeset
Next Changeset →

Changeset 631

Timestamp:

01/06/09 13:12:05

Author:

rachel

Message:

Use OPS_ARMOURED/UNARMOURED where possible

Files:

openpgpsdk/trunk/tests/test_common.c (modified) (1 diff)
openpgpsdk/trunk/tests/test_dsa_signature.c (modified) (8 diffs)
openpgpsdk/trunk/tests/test_rsa_encrypt.c (modified) (2 diffs)
openpgpsdk/trunk/tests/test_rsa_keys.c (modified) (9 diffs)
openpgpsdk/trunk/tests/test_rsa_signature.c (modified) (6 diffs)
openpgpsdk/trunk/tests/test_rsa_verify.c (modified) (7 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

openpgpsdk/trunk/tests/test_common.c

r630	r631
195	195	assert(alphadsa_skey);
196	196	assert(bravodsa_pkey);
197		assert(bravodsa_skey); ~~//not yet set because of passphrase~~
	197	assert(bravodsa_skey);
198	198	}
199	199

openpgpsdk/trunk/tests/test_dsa_signature.c

r629	r631
23	23
24	24	#include <openpgpsdk/types.h>
	25	#include <openpgpsdk/defs.h>
25	26	#include "openpgpsdk/keyring.h"
26	27	#include <openpgpsdk/armour.h>
…	…
425	426	static void test_dsa_signature_large_noarmour_nopassphrase(void)
426	427	{
427		int armour=0;
428		assert(pub_keyring.nkeys);
429		test_dsa_signature_sign(armour,filename_dsa_large_noarmour_nopassphrase, alphadsa_skey);
	428	assert(pub_keyring.nkeys);
	429	test_dsa_signature_sign(OPS_UNARMOURED,filename_dsa_large_noarmour_nopassphrase, alphadsa_skey);
430	430	}
431	431
432	432	static void test_dsa_signature_large_armour_nopassphrase(void)
433	433	{
434		int armour=1;
435		assert(pub_keyring.nkeys);
436		test_dsa_signature_sign(armour,filename_dsa_large_armour_nopassphrase, alphadsa_skey);
	434	assert(pub_keyring.nkeys);
	435	test_dsa_signature_sign(OPS_ARMOURED,filename_dsa_large_armour_nopassphrase, alphadsa_skey);
437	436	}
438	437
…	…
440	439	{
441	440	unsigned char testdata[MAXBUF];
442		~~int armour=0;~~
443	441	assert(pub_keyring.nkeys);
444	442	assert(alphadsa_skey);
445		test_dsa_signature_sign(~~armour~~,filename_dsa_noarmour_nopassphrase, alphadsa_skey);
	443	test_dsa_signature_sign(OPS_UNARMOURED,filename_dsa_noarmour_nopassphrase, alphadsa_skey);
446	444	create_testdata("test_dsa_signature_noarmour_nopassphrase",testdata, MAXBUF);
447		test_dsa_signature_sign_memory(~~armour~~,testdata,MAXBUF, alphadsa_skey);
	445	test_dsa_signature_sign_memory(OPS_UNARMOURED,testdata,MAXBUF, alphadsa_skey);
448	446	}
449	447
…	…
451	449	{
452	450	unsigned char testdata[MAXBUF];
453		int armour=0;
454		assert(pub_keyring.nkeys);
455		test_dsa_signature_sign(armour,filename_dsa_noarmour_passphrase, bravodsa_skey);
	451	assert(pub_keyring.nkeys);
	452	test_dsa_signature_sign(OPS_UNARMOURED,filename_dsa_noarmour_passphrase, bravodsa_skey);
456	453
457	454	create_testdata("test_dsa_signature_noarmour_passphrase",testdata, MAXBUF);
458		test_dsa_signature_sign_memory(~~armour~~,testdata,MAXBUF, bravodsa_skey);
	455	test_dsa_signature_sign_memory(OPS_UNARMOURED,testdata,MAXBUF, bravodsa_skey);
459	456	}
460	457
…	…
462	459	{
463	460	unsigned char testdata[MAXBUF];
464		int armour=1;
465		assert(pub_keyring.nkeys);
466		test_dsa_signature_sign(armour,filename_dsa_armour_nopassphrase, alphadsa_skey);
	461	assert(pub_keyring.nkeys);
	462	test_dsa_signature_sign(OPS_ARMOURED,filename_dsa_armour_nopassphrase, alphadsa_skey);
467	463
468	464	create_testdata("test_dsa_signature_armour_nopassphrase",testdata, MAXBUF);
469		test_dsa_signature_sign_memory(~~armour~~,testdata,MAXBUF, alphadsa_skey);
	465	test_dsa_signature_sign_memory(OPS_UNARMOURED,testdata,MAXBUF, alphadsa_skey);
470	466	}
471	467
…	…
474	470	unsigned char testdata[MAXBUF];
475	471
476		int armour=1;
477		assert(pub_keyring.nkeys);
478		test_dsa_signature_sign(armour,filename_dsa_armour_passphrase, bravodsa_skey);
	472	assert(pub_keyring.nkeys);
	473	test_dsa_signature_sign(OPS_ARMOURED,filename_dsa_armour_passphrase, bravodsa_skey);
479	474
480	475	create_testdata("test_dsa_signature_armour_passphrase",testdata, MAXBUF);
481		test_dsa_signature_sign_memory(~~armour~~,testdata,MAXBUF, bravodsa_skey);
	476	test_dsa_signature_sign_memory(OPS_ARMOURED,testdata,MAXBUF, bravodsa_skey);
482	477	}
483	478
…	…
504	499	assert(pub_keyring.nkeys);
505	500	test_dsa_signature_clearsign_buf(filename_dsa_clearsign_buf_passphrase, bravodsa_skey);
	501	}
	502
	503	static void test_dsa_signature_dss(void)
	504	{
	505	unsigned char testdata[MAXBUF];
	506	assert(sec_keyring.nkeys);
	507	unsigned i;
	508	for (i=0; i<sz_dsstests; i++)
	509	{
	510	char teststr[MAXBUF];
	511	const ops_keydata_t* keydata;
	512	const ops_secret_key_t* skey;
	513
	514	snprintf(teststr,MAXBUF,"%s%d","test_dsa_signature_dss",i);
	515	create_testdata(teststr,testdata,MAXBUF);
	516	keydata=ops_keyring_find_key_by_userid(&sec_keyring,dsstests[i].userid);
	517	skey=ops_get_secret_key_from_data(keydata);
	518	test_dsa_signature_sign_memory(OPS_UNARMOURED,testdata,MAXBUF,skey);
	519	}
506	520	}
507	521
…	…
551	565	return 0;
552	566
	567	if (NULL == CU_add_test(suite, "DSS keys", test_dsa_signature_dss))
	568	return 0;
	569
553	570	/*
554	571	if (NULL == CU_add_test(suite, "Tests to be implemented", test_todo))

openpgpsdk/trunk/tests/test_rsa_encrypt.c

r620	r631
22	22	#include "CUnit/Basic.h"
23	23
	24	#include <openpgpsdk/defs.h>
24	25	#include <openpgpsdk/types.h>
25	26	#include "openpgpsdk/keyring.h"
…	…
214	215	static void test_rsa_encrypt_noarmour_nopassphrase_singlekey(void)
215	216	{
216		int armour=0;
217		test_rsa_encrypt(armour,filename_rsa_noarmour_nopassphrase_singlekey, alpha_pub_keydata);
	217	test_rsa_encrypt(OPS_UNARMOURED,filename_rsa_noarmour_nopassphrase_singlekey, alpha_pub_keydata);
218	218	}
219	219
220	220	static void test_rsa_encrypt_noarmour_passphrase_singlekey(void)
221	221	{
222		int armour=0;
223		test_rsa_encrypt(armour,filename_rsa_noarmour_passphrase_singlekey,bravo_pub_keydata);
	222	test_rsa_encrypt(OPS_UNARMOURED,filename_rsa_noarmour_passphrase_singlekey,bravo_pub_keydata);
224	223	}
225	224
226	225	static void test_rsa_encrypt_armour_nopassphrase_singlekey(void)
227	226	{
228		int armour=1;
229		test_rsa_encrypt(armour,filename_rsa_armour_nopassphrase_singlekey,alpha_pub_keydata);
	227	test_rsa_encrypt(OPS_ARMOURED,filename_rsa_armour_nopassphrase_singlekey,alpha_pub_keydata);
230	228	}
231	229
232	230	static void test_rsa_encrypt_armour_passphrase_singlekey(void)
233	231	{
234		int armour=1;
235		test_rsa_encrypt(armour,filename_rsa_armour_passphrase_singlekey,bravo_pub_keydata);
	232	test_rsa_encrypt(OPS_ARMOURED,filename_rsa_armour_passphrase_singlekey,bravo_pub_keydata);
236	233	}
237	234
238	235	static void test_rsa_encrypt_large_noarmour_nopassphrase(void)
239	236	{
240		int armour=0;
241		test_rsa_encrypt(armour,filename_rsa_large_noarmour_nopassphrase, alpha_pub_keydata);
	237	test_rsa_encrypt(OPS_UNARMOURED,filename_rsa_large_noarmour_nopassphrase, alpha_pub_keydata);
242	238	}
243	239
244	240	static void test_rsa_encrypt_large_armour_nopassphrase(void)
245	241	{
246		int armour=1;
247		test_rsa_encrypt(armour,filename_rsa_large_armour_nopassphrase, alpha_pub_keydata);
	242	test_rsa_encrypt(OPS_ARMOURED,filename_rsa_large_armour_nopassphrase, alpha_pub_keydata);
248	243	}
249	244

openpgpsdk/trunk/tests/test_rsa_keys.c

r624	r631
22	22	#include "CUnit/Basic.h"
23	23
	24	#include "openpgpsdk/defs.h"
24	25	#include "openpgpsdk/keyring.h"
25	26	#include "openpgpsdk/crypto.h"
…	…
193	194	static void test_rsa_keys_verify_keypair(void)
194	195	{
195		ops_boolean_t armoured=ops_false;
196		verify_keypair(armoured);
	196	verify_keypair(OPS_UNARMOURED);
197	197	}
198	198
…	…
200	200	{
201	201	ops_keyring_t keyring;
202		~~ops_boolean_t armoured=ops_false;~~
203	202	char filename[MAXBUF+1];
204	203	snprintf(filename,MAXBUF,"%s/%s", dir, "pubring.gpg");
…	…
206	205	memset(&keyring, '\0', sizeof keyring);
207	206
208		ops_keyring_read_from_file(&keyring, ~~armoured~~, filename);
	207	ops_keyring_read_from_file(&keyring, OPS_UNARMOURED, filename);
209	208	ops_keyring_free(&keyring);
210	209	}
…	…
212	211	static void test_rsa_keys_verify_armoured_keypair(void)
213	212	{
214		ops_boolean_t armoured=ops_true;
215		verify_keypair(armoured);
	213	verify_keypair(OPS_ARMOURED);
216	214	}
217	215
…	…
230	228	char filename[MAXBUF+1];
231	229	int fd=0;
232		~~ops_boolean_t armour=ops_true;~~
233	230	char* name1="First User<user1@nowhere.com>";
234	231	uid1.user_id=(unsigned char *)name1;
…	…
257	254	snprintf(filename,MAXBUF,"%s/%s",dir,"transferable_public_key_1");
258	255	fd=ops_setup_file_write(&cinfo, filename,overwrite);
259		ops_write_transferable_public_key(keydata,~~armour~~,cinfo);
260		ops_teardown_file_write(cinfo,fd);
261		ops_keyring_read_from_file(&keyring1, ~~armour~~, filename);
	256	ops_write_transferable_public_key(keydata,OPS_ARMOURED,cinfo);
	257	ops_teardown_file_write(cinfo,fd);
	258	ops_keyring_read_from_file(&keyring1, OPS_ARMOURED, filename);
262	259
263	260	// Keyring 2
…	…
266	263	snprintf(filename,MAXBUF,"%s/%s",dir,"transferable_public_key_2");
267	264	fd=ops_setup_file_write(&cinfo, filename,overwrite);
268		ops_write_transferable_public_key(keydata,~~armour~~,cinfo);
269		ops_teardown_file_write(cinfo,fd);
270		ops_keyring_read_from_file(&keyring2, ~~armour~~, filename);
	265	ops_write_transferable_public_key(keydata,OPS_ARMOURED,cinfo);
	266	ops_teardown_file_write(cinfo,fd);
	267	ops_keyring_read_from_file(&keyring2, OPS_ARMOURED, filename);
271	268
272	269	// Keyring 3
…	…
281	278	snprintf(filename,MAXBUF,"%s/%s",dir,"transferable_public_key_3_bad");
282	279	fd=ops_setup_file_write(&cinfo, filename, overwrite);
283		ops_write_transferable_public_key(keydata,~~armour~~,cinfo);
284		ops_teardown_file_write(cinfo,fd);
285		ops_keyring_read_from_file(&keyring3, ~~armour~~, filename);
	280	ops_write_transferable_public_key(keydata,OPS_ARMOURED,cinfo);
	281	ops_teardown_file_write(cinfo,fd);
	282	ops_keyring_read_from_file(&keyring3, OPS_ARMOURED, filename);
286	283
287	284	/*

openpgpsdk/trunk/tests/test_rsa_signature.c

r625	r631
22	22	#include "CUnit/Basic.h"
23	23
	24	#include <openpgpsdk/defs.h>
24	25	#include <openpgpsdk/types.h>
25	26	#include "openpgpsdk/keyring.h"
…	…
425	426	static void test_rsa_signature_large_noarmour_nopassphrase(void)
426	427	{
427		int armour=0;
428		assert(pub_keyring.nkeys);
429		test_rsa_signature_sign(armour,filename_rsa_large_noarmour_nopassphrase, alpha_skey);
	428	assert(pub_keyring.nkeys);
	429	test_rsa_signature_sign(OPS_UNARMOURED,filename_rsa_large_noarmour_nopassphrase, alpha_skey);
430	430	}
431	431
432	432	static void test_rsa_signature_large_armour_nopassphrase(void)
433	433	{
434		int armour=1;
435		assert(pub_keyring.nkeys);
436		test_rsa_signature_sign(armour,filename_rsa_large_armour_nopassphrase, alpha_skey);
	434	assert(pub_keyring.nkeys);
	435	test_rsa_signature_sign(OPS_ARMOURED,filename_rsa_large_armour_nopassphrase, alpha_skey);
437	436	}
438	437
…	…
440	439	{
441	440	unsigned char testdata[MAXBUF];
442		int armour=0;
443		assert(pub_keyring.nkeys);
444		test_rsa_signature_sign(armour,filename_rsa_noarmour_nopassphrase, alpha_skey);
	441	assert(pub_keyring.nkeys);
	442	test_rsa_signature_sign(OPS_UNARMOURED,filename_rsa_noarmour_nopassphrase, alpha_skey);
445	443	create_testdata("test_rsa_signature_noarmour_nopassphrase",testdata, MAXBUF);
446		test_rsa_signature_sign_memory(~~armour~~,testdata,MAXBUF, alpha_skey);
	444	test_rsa_signature_sign_memory(OPS_UNARMOURED,testdata,MAXBUF, alpha_skey);
447	445	}
448	446
…	…
450	448	{
451	449	unsigned char testdata[MAXBUF];
452		int armour=0;
453		assert(pub_keyring.nkeys);
454		test_rsa_signature_sign(armour,filename_rsa_noarmour_passphrase, bravo_skey);
	450	assert(pub_keyring.nkeys);
	451	test_rsa_signature_sign(OPS_ARMOURED,filename_rsa_noarmour_passphrase, bravo_skey);
455	452
456	453	create_testdata("test_rsa_signature_noarmour_passphrase",testdata, MAXBUF);
457		test_rsa_signature_sign_memory(~~armour~~,testdata,MAXBUF, bravo_skey);
	454	test_rsa_signature_sign_memory(OPS_ARMOURED,testdata,MAXBUF, bravo_skey);
458	455	}
459	456
…	…
461	458	{
462	459	unsigned char testdata[MAXBUF];
463		int armour=1;
464		assert(pub_keyring.nkeys);
465		test_rsa_signature_sign(armour,filename_rsa_armour_nopassphrase, alpha_skey);
	460	assert(pub_keyring.nkeys);
	461	test_rsa_signature_sign(OPS_ARMOURED,filename_rsa_armour_nopassphrase, alpha_skey);
466	462
467	463	create_testdata("test_rsa_signature_armour_nopassphrase",testdata, MAXBUF);
468		test_rsa_signature_sign_memory(~~armour~~,testdata,MAXBUF, alpha_skey);
	464	test_rsa_signature_sign_memory(OPS_ARMOURED,testdata,MAXBUF, alpha_skey);
469	465	}
470	466
…	…
473	469	unsigned char testdata[MAXBUF];
474	470
475		int armour=1;
476		assert(pub_keyring.nkeys);
477		test_rsa_signature_sign(armour,filename_rsa_armour_passphrase, bravo_skey);
	471	assert(pub_keyring.nkeys);
	472	test_rsa_signature_sign(OPS_ARMOURED,filename_rsa_armour_passphrase, bravo_skey);
478	473
479	474	create_testdata("test_rsa_signature_armour_passphrase",testdata, MAXBUF);
480		test_rsa_signature_sign_memory(~~armour~~,testdata,MAXBUF, bravo_skey);
	475	test_rsa_signature_sign_memory(OPS_ARMOURED,testdata,MAXBUF, bravo_skey);
481	476	}
482	477

openpgpsdk/trunk/tests/test_rsa_verify.c

r627	r631
22	22	#include "CUnit/Basic.h"
23	23
	24	#include <openpgpsdk/defs.h>
24	25	#include <openpgpsdk/types.h>
25	26	#include "openpgpsdk/keyring.h"
…	…
511	512	static void test_rsa_verify_v3sig(void)
512	513	{
513		int armour=0;
514		assert(pub_keyring.nkeys);
515
516		test_rsa_verify_ok(armour,filename_rsa_v3sig);
	514	assert(pub_keyring.nkeys);
	515
	516	test_rsa_verify_ok(OPS_UNARMOURED,filename_rsa_v3sig);
517	517	}
518	518
519	519	static void test_rsa_verify_hash_md5(void)
520	520	{
521		int armour=0;
522		assert(pub_keyring.nkeys);
523
524		test_rsa_verify_ok(armour,filename_rsa_hash_md5);
	521	assert(pub_keyring.nkeys);
	522
	523	test_rsa_verify_ok(OPS_UNARMOURED,filename_rsa_hash_md5);
525	524	}
526	525
527	526	static void test_rsa_verify_hash_sha256(void)
528	527	{
529		int armour=0;
530		assert(pub_keyring.nkeys);
531
532		test_rsa_verify_ok(armour,filename_rsa_hash_sha256);
	528	assert(pub_keyring.nkeys);
	529
	530	test_rsa_verify_ok(OPS_UNARMOURED,filename_rsa_hash_sha256);
533	531	}
534	532
535	533	static void test_rsa_verify_noarmour_nopassphrase(void)
536	534	{
537		int armour=0;
538		assert(pub_keyring.nkeys);
539
540		test_rsa_verify_ok(armour,filename_rsa_noarmour_nopassphrase);
	535	assert(pub_keyring.nkeys);
	536
	537	test_rsa_verify_ok(OPS_UNARMOURED,filename_rsa_noarmour_nopassphrase);
541	538	}
542	539
543	540	static void test_rsa_verify_noarmour_passphrase(void)
544	541	{
545		int armour=0;
546		assert(pub_keyring.nkeys);
547		test_rsa_verify_ok(armour,filename_rsa_noarmour_passphrase);
	542	assert(pub_keyring.nkeys);
	543	test_rsa_verify_ok(OPS_UNARMOURED,filename_rsa_noarmour_passphrase);
548	544	}
549	545
550	546	static void test_rsa_verify_armour_nopassphrase(void)
551	547	{
552		int armour=1;
553		assert(pub_keyring.nkeys);
554
555		test_rsa_verify_ok(armour,filename_rsa_armour_nopassphrase);
	548	assert(pub_keyring.nkeys);
	549
	550	test_rsa_verify_ok(OPS_ARMOURED,filename_rsa_armour_nopassphrase);
556	551	}
557	552
558	553	static void test_rsa_verify_armour_passphrase(void)
559	554	{
560		int armour=1;
561		assert(pub_keyring.nkeys);
562
563		test_rsa_verify_ok(armour,filename_rsa_armour_passphrase);
	555	assert(pub_keyring.nkeys);
	556
	557	test_rsa_verify_ok(OPS_ARMOURED,filename_rsa_armour_passphrase);
564	558	}
565	559
566	560	static void test_rsa_verify_clearsign_nopassphrase(void)
567	561	{
568		int armour=1;
569		assert(pub_keyring.nkeys);
570
571		test_rsa_verify_ok(armour,filename_rsa_clearsign_nopassphrase);
	562	assert(pub_keyring.nkeys);
	563
	564	test_rsa_verify_ok(OPS_ARMOURED,filename_rsa_clearsign_nopassphrase);
572	565	}
573	566
574	567	static void test_rsa_verify_clearsign_passphrase(void)
575	568	{
576		int armour=1;
577		assert(pub_keyring.nkeys);
578
579		test_rsa_verify_ok(armour,filename_rsa_clearsign_passphrase);
	569	assert(pub_keyring.nkeys);
	570
	571	test_rsa_verify_ok(OPS_ARMOURED,filename_rsa_clearsign_passphrase);
580	572	}
581	573
…	…
629	621	static void test_rsa_verify_noarmour_fail_bad_sig(void)
630	622	{
631		int armour=0;
632		assert(pub_keyring.nkeys);
633
634		test_rsa_verify_fail(armour,filename_rsa_noarmour_fail_bad_sig,callback_bad_sig,OPS_E_V_BAD_SIGNATURE);
	623	assert(pub_keyring.nkeys);
	624
	625	test_rsa_verify_fail(OPS_UNARMOURED,filename_rsa_noarmour_fail_bad_sig,callback_bad_sig,OPS_E_V_BAD_SIGNATURE);
635	626	}
636	627
637	628	static void test_rsa_verify_v3sig_fail_bad_sig(void)
638	629	{
639		int armour=0;
640		assert(pub_keyring.nkeys);
641
642		test_rsa_verify_fail(armour,filename_rsa_v3sig_fail_bad_sig, callback_bad_sig, OPS_E_V_BAD_SIGNATURE);
	630	assert(pub_keyring.nkeys);
	631
	632	test_rsa_verify_fail(OPS_UNARMOURED,filename_rsa_v3sig_fail_bad_sig, callback_bad_sig, OPS_E_V_BAD_SIGNATURE);
643	633	}
644	634
645	635	static void test_rsa_verify_clearsign_fail_bad_sig(void)
646	636	{
647		int armour=1;
648		assert(pub_keyring.nkeys);
649
650		test_rsa_verify_fail(armour,filename_rsa_clearsign_fail_bad_sig,callback_bad_sig,OPS_E_V_BAD_SIGNATURE);
	637	assert(pub_keyring.nkeys);
	638
	639	test_rsa_verify_fail(OPS_ARMOURED,filename_rsa_clearsign_fail_bad_sig,callback_bad_sig,OPS_E_V_BAD_SIGNATURE);
651	640	}
652	641
…	…
654	643	{
655	644	int i=0;
656		~~int armour=1;~~
657	645	assert(pub_keyring.nkeys);
658	646
…	…
661	649	char filename[MAXBUF];
662	650	make_filename_malformed(filename,MAXBUF,i);
663		test_rsa_verify_fail(~~armour~~,filename,NULL,OPS_E_R_BAD_FORMAT);
	651	test_rsa_verify_fail(OPS_ARMOURED,filename,NULL,OPS_E_R_BAD_FORMAT);
664	652	}
665	653	}
…	…
668	656	{
669	657	int i=0;
670		~~int armour=1;~~
671	658	assert(pub_keyring.nkeys);
672	659
…	…
675	662	char filename[MAXBUF];
676	663	make_filename_wellformed(filename,MAXBUF,i);
677		test_rsa_verify_wellformed(~~armour~~,filename,NULL);
	664	test_rsa_verify_wellformed(OPS_ARMOURED,filename,NULL);
678	665	}
679	666	}

Download in other formats: