Changeset Navigation

← Previous Changeset
Next Changeset →

Changeset 602

Timestamp:

08/27/08 15:33:54

Author:

rachel

Message:

Split ops_signature_t struct into 2 parts: the actual signature information
derived from the packet; and the data needed whilst parsing it.
The actual signature information can then be passed back in the
ops_validate_result_t for a user to do further processing if they wish.

Files:

openpgpsdk/trunk/include/openpgpsdk/packet.h (modified) (1 diff)
openpgpsdk/trunk/include/openpgpsdk/validate.h (modified) (1 diff)
openpgpsdk/trunk/src/lib/packet-parse.c (modified) (15 diffs)
openpgpsdk/trunk/src/lib/packet-print.c (modified) (8 diffs)
openpgpsdk/trunk/src/lib/signature.c (modified) (10 diffs)
openpgpsdk/trunk/src/lib/validate.c (modified) (15 diffs)
openpgpsdk/trunk/tests/test_common.c (modified) (1 diff)
openpgpsdk/trunk/tests/test_rsa_keys.c (modified) (1 diff)

Legend:

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

openpgpsdk/trunk/include/openpgpsdk/packet.h

r601	r602
579	579	ops_public_key_algorithm_t key_algorithm; /!< public key algorithm number /
580	580	ops_hash_algorithm_t hash_algorithm; /!< hashing algorithm number /
581		~~unsigned char hash2[2]; /!< high 2 bytes of hashed value - for quick test /~~
582	581	ops_signature_union_t signature; /!< signature parameters /
583		~~size_t v4_hashed_data_start; /* only valid if accumulate is set */~~
584	582	size_t v4_hashed_data_length;
585		unsigned char* v4_hashed_data;
586		ops_hash_t hash; /!< if set, the hash filled in for the data so far */
	583	unsigned char* v4_hashed_data;
587	584	ops_boolean_t creation_time_set:1;
588	585	ops_boolean_t signer_id_set:1;
	586	} ops_signature_info_t;
	587
	588	typedef struct
	589	{
	590	ops_signature_info_t info;
	591	/* The following fields are only used while parsing the signature */
	592	unsigned char hash2[2]; /!< high 2 bytes of hashed value - for quick test /
	593	size_t v4_hashed_data_start; /* only valid if accumulate is set */
	594	ops_hash_t hash; /!< if set, the hash filled in for the data so far */
589	595	} ops_signature_t;
590	596

openpgpsdk/trunk/include/openpgpsdk/validate.h

r570	r602
24	24	{
25	25	unsigned int valid_count;
26		ops_~~keydata_t * valid_key~~s;
	26	ops_signature_info_t * valid_sigs;
27	27	unsigned int invalid_count;
28		ops_~~keydata_t * invalid_key~~s;
	28	ops_signature_info_t * invalid_sigs;
29	29	unsigned int unknown_signer_count;
30		~~unsigned char * unknown_key~~s;
	30	ops_signature_info_t * unknown_sigs;
31	31	} ops_validate_result_t;
32	32

openpgpsdk/trunk/src/lib/packet-parse.c

r601	r602
1185	1185	void ops_signature_free(ops_signature_t *sig)
1186	1186	{
1187		switch(sig->key_algorithm)
	1187	switch(sig->info.key_algorithm)
1188	1188	{
1189	1189	case OPS_PKA_RSA:
1190	1190	case OPS_PKA_RSA_SIGN_ONLY:
1191		free_BN(&sig->signature.rsa.sig);
	1191	free_BN(&sig->info.signature.rsa.sig);
1192	1192	break;
1193	1193
1194	1194	case OPS_PKA_DSA:
1195		free_BN(&sig->signature.dsa.r);
1196		free_BN(&sig->signature.dsa.s);
	1195	free_BN(&sig->info.signature.dsa.r);
	1196	free_BN(&sig->info.signature.dsa.s);
1197	1197	break;
1198	1198
1199	1199	case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
1200		free_BN(&sig->signature.elgamal.r);
1201		free_BN(&sig->signature.elgamal.s);
	1200	free_BN(&sig->info.signature.elgamal.r);
	1201	free_BN(&sig->info.signature.elgamal.s);
1202	1202	break;
1203	1203
…	…
1213	1213	case OPS_PKA_PRIVATE09:
1214	1214	case OPS_PKA_PRIVATE10:
1215		free_unknown_sig_pka(&sig->signature.unknown);
	1215	free_unknown_sig_pka(&sig->info.signature.unknown);
1216	1216	break;
1217	1217
…	…
1240	1240	ops_parser_content_t content;
1241	1241
1242		C.signature.version=OPS_V3;
	1242	C.signature.info.version=OPS_V3;
1243	1243
1244	1244	/* hash info length */
…	…
1250	1250	if(!limited_read(c,1,region,pinfo))
1251	1251	return 0;
1252		C.signature.type=c[0];
	1252	C.signature.info.type=c[0];
1253	1253	/* XXX: check signature type */
1254	1254
1255		if(!limited_read_time(&C.signature.creation_time,region,pinfo))
1256		return 0;
1257		C.signature.creation_time_set=ops_true;
1258
1259		if(!limited_read(C.signature.signer_id,OPS_KEY_ID_SIZE,region,pinfo))
1260		return 0;
1261		C.signature.signer_id_set=ops_true;
	1255	if(!limited_read_time(&C.signature.info.creation_time,region,pinfo))
	1256	return 0;
	1257	C.signature.info.creation_time_set=ops_true;
	1258
	1259	if(!limited_read(C.signature.info.signer_id,OPS_KEY_ID_SIZE,region,pinfo))
	1260	return 0;
	1261	C.signature.info.signer_id_set=ops_true;
1262	1262
1263	1263	if(!limited_read(c,1,region,pinfo))
1264	1264	return 0;
1265		C.signature.key_algorithm=c[0];
	1265	C.signature.info.key_algorithm=c[0];
1266	1266	/* XXX: check algorithm */
1267	1267
1268	1268	if(!limited_read(c,1,region,pinfo))
1269	1269	return 0;
1270		C.signature.hash_algorithm=c[0];
	1270	C.signature.info.hash_algorithm=c[0];
1271	1271	/* XXX: check algorithm */
1272	1272
…	…
1274	1274	return 0;
1275	1275
1276		switch(C.signature.key_algorithm)
	1276	switch(C.signature.info.key_algorithm)
1277	1277	{
1278	1278	case OPS_PKA_RSA:
1279	1279	case OPS_PKA_RSA_SIGN_ONLY:
1280		if(!limited_read_mpi(&C.signature.signature.rsa.sig,region,pinfo))
	1280	if(!limited_read_mpi(&C.signature.info.signature.rsa.sig,region,pinfo))
1281	1281	return 0;
1282	1282	break;
1283	1283
1284	1284	case OPS_PKA_DSA:
1285		if(!limited_read_mpi(&C.signature.signature.dsa.r,region,pinfo)
1286		\|\| !limited_read_mpi(&C.signature.signature.dsa.s,region,pinfo))
	1285	if(!limited_read_mpi(&C.signature.info.signature.dsa.r,region,pinfo)
	1286	\|\| !limited_read_mpi(&C.signature.info.signature.dsa.s,region,pinfo))
1287	1287	return 0;
1288	1288	break;
1289	1289
1290	1290	case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
1291		if(!limited_read_mpi(&C.signature.signature.elgamal.r,region,pinfo)
1292		\|\| !limited_read_mpi(&C.signature.signature.elgamal.s,region,pinfo))
	1291	if(!limited_read_mpi(&C.signature.info.signature.elgamal.r,region,pinfo)
	1292	\|\| !limited_read_mpi(&C.signature.info.signature.elgamal.s,region,pinfo))
1293	1293	return 0;
1294	1294	break;
…	…
1297	1297	OPS_ERROR_1(&pinfo->errors,OPS_E_ALG_UNSUPPORTED_SIGNATURE_ALG,
1298	1298	"Unsupported signature key algorithm (%s)",
1299		ops_show_pka(C.signature.key_algorithm));
	1299	ops_show_pka(C.signature.info.key_algorithm));
1300	1300	return 0;
1301	1301	}
…	…
1307	1307	}
1308	1308
1309		if(C.signature.signer_id_set)
1310		C.signature.hash=ops_parse_hash_find(pinfo,C.signature.signer_id);
	1309	if(C.signature.info.signer_id_set)
	1310	C.signature.hash=ops_parse_hash_find(pinfo,C.signature.info.signer_id);
1311	1311
1312	1312	CBP(pinfo,OPS_PTAG_CT_SIGNATURE,&content);
…	…
1379	1379	if(content.tag == OPS_PTAG_SS_CREATION_TIME)
1380	1380	{
1381		sig->creation_time=C.ss_time.time;
1382		sig->creation_time_set=ops_true;
	1381	sig->info.creation_time=C.ss_time.time;
	1382	sig->info.creation_time_set=ops_true;
1383	1383	}
1384	1384	break;
…	…
1400	1400	&subregion,pinfo))
1401	1401	return 0;
1402		memcpy(sig->signer_id,C.ss_issuer_key_id.key_id,OPS_KEY_ID_SIZE);
1403		sig->signer_id_set=ops_true;
	1402	memcpy(sig->info.signer_id,C.ss_issuer_key_id.key_id,OPS_KEY_ID_SIZE);
	1403	sig->info.signer_id_set=ops_true;
1404	1404	break;
1405	1405
…	…
1671	1671	/* Set version,type,algorithms */
1672	1672
1673		C.signature.version=OPS_V4;
	1673	C.signature.info.version=OPS_V4;
1674	1674
1675	1675	if(!limited_read(c,1,region,pinfo))
1676	1676	return 0;
1677		C.signature.type=c[0];
	1677	C.signature.info.type=c[0];
1678	1678	/* XXX: check signature type */
1679	1679
1680	1680	if(!limited_read(c,1,region,pinfo))
1681	1681	return 0;
1682		C.signature.key_algorithm=c[0];
	1682	C.signature.info.key_algorithm=c[0];
1683	1683	/* XXX: check algorithm */
1684	1684
1685	1685	if(!limited_read(c,1,region,pinfo))
1686	1686	return 0;
1687		C.signature.hash_algorithm=c[0];
	1687	C.signature.info.hash_algorithm=c[0];
1688	1688	/* XXX: check algorithm */
1689	1689
…	…
1693	1693	return 0;
1694	1694
1695		C.signature.v4_hashed_data_length=pinfo->rinfo.alength
	1695	C.signature.info.v4_hashed_data_length=pinfo->rinfo.alength
1696	1696	-C.signature.v4_hashed_data_start;
1697	1697
1698	1698	// copy hashed subpackets
1699		if (C.signature.v4_hashed_data)
1700		free(C.signature.v4_hashed_data);
1701		C.signature.~~v4_hashed_data=ops_mallocz(C.signature~~.v4_hashed_data_length);
	1699	if (C.signature.info.v4_hashed_data)
	1700	free(C.signature.info.v4_hashed_data);
	1701	C.signature.info.v4_hashed_data=ops_mallocz(C.signature.info.v4_hashed_data_length);
1702	1702
1703	1703	if (!pinfo->rinfo.accumulate)
…	…
1708	1708	}
1709	1709
1710		memcpy(C.signature.v4_hashed_data,
	1710	memcpy(C.signature.info.v4_hashed_data,
1711	1711	pinfo->rinfo.accumulated+C.signature.v4_hashed_data_start,
1712		C.signature.v4_hashed_data_length);
	1712	C.signature.info.v4_hashed_data_length);
1713	1713
1714	1714	if(!parse_signature_subpackets(&C.signature,region,pinfo))
…	…
1718	1718	return 0;
1719	1719
1720		switch(C.signature.key_algorithm)
	1720	switch(C.signature.info.key_algorithm)
1721	1721	{
1722	1722	case OPS_PKA_RSA:
1723		if(!limited_read_mpi(&C.signature.signature.rsa.sig,region,pinfo))
	1723	if(!limited_read_mpi(&C.signature.info.signature.rsa.sig,region,pinfo))
1724	1724	return 0;
1725	1725	break;
1726	1726
1727	1727	case OPS_PKA_DSA:
1728		if(!limited_read_mpi(&C.signature.signature.dsa.r,region,pinfo))
	1728	if(!limited_read_mpi(&C.signature.info.signature.dsa.r,region,pinfo))
1729	1729	ERRP(pinfo,"Error reading DSA r field in signature");
1730		if (!limited_read_mpi(&C.signature.signature.dsa.s,region,pinfo))
	1730	if (!limited_read_mpi(&C.signature.info.signature.dsa.s,region,pinfo))
1731	1731	ERRP(pinfo,"Error reading DSA s field in signature");
1732	1732	break;
1733	1733
1734	1734	case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
1735		if(!limited_read_mpi(&C.signature.signature.elgamal.r,region,pinfo)
1736		\|\| !limited_read_mpi(&C.signature.signature.elgamal.s,region,pinfo))
	1735	if(!limited_read_mpi(&C.signature.info.signature.elgamal.r,region,pinfo)
	1736	\|\| !limited_read_mpi(&C.signature.info.signature.elgamal.s,region,pinfo))
1737	1737	return 0;
1738	1738	break;
…	…
1749	1749	case OPS_PKA_PRIVATE09:
1750	1750	case OPS_PKA_PRIVATE10:
1751		if (!read_data(&C.signature.signature.unknown.data,region,pinfo))
	1751	if (!read_data(&C.signature.info.signature.unknown.data,region,pinfo))
1752	1752	return 0;
1753	1753	break;
…	…
1756	1756	OPS_ERROR_1(&pinfo->errors,OPS_E_ALG_UNSUPPORTED_SIGNATURE_ALG,
1757	1757	"Bad v4 signature key algorithm (%s)",
1758		ops_show_pka(C.signature.key_algorithm));
	1758	ops_show_pka(C.signature.info.key_algorithm));
1759	1759	return 0;
1760	1760	}

openpgpsdk/trunk/src/lib/packet-print.c

r596	r602
702	702	print_indent(indent);
703	703	print_unsigned_int("Signature Version",
704		content->signature.version);
705		if (content->signature.creation_time_set)
	704	content->signature.info.version);
	705	if (content->signature.info.creation_time_set)
706	706	print_time("Signature Creation Time",
707		content->signature.creation_time);
	707	content->signature.info.creation_time);
708	708
709	709	print_string_and_value("Signature Type",
710		ops_show_sig_type(content->signature.type),
711		content->signature.type);
712
713		if(content->signature.signer_id_set)
	710	ops_show_sig_type(content->signature.info.type),
	711	content->signature.info.type);
	712
	713	if(content->signature.info.signer_id_set)
714	714	print_hexdump_data("Signer ID",
715		content->signature.signer_id,
716		sizeof content->signature.signer_id);
	715	content->signature.info.signer_id,
	716	sizeof content->signature.info.signer_id);
717	717
718	718	print_string_and_value("Public Key Algorithm",
719		ops_show_pka(content->signature.key_algorithm),
720		content->signature.key_algorithm);
	719	ops_show_pka(content->signature.info.key_algorithm),
	720	content->signature.info.key_algorithm);
721	721	print_string_and_value("Hash Algorithm",
722		ops_show_hash_algorithm(content->signature.hash_algorithm),
723		content->signature.hash_algorithm);
	722	ops_show_hash_algorithm(content->signature.info.hash_algorithm),
	723	content->signature.info.hash_algorithm);
724	724
725	725	print_indent();
726	726	print_hexdump_data("hash2",&content->signature.hash2[0],2);
727	727
728		switch(content->signature.key_algorithm)
	728	switch(content->signature.info.key_algorithm)
729	729	{
730	730	case OPS_PKA_RSA:
731	731	case OPS_PKA_RSA_SIGN_ONLY:
732		print_bn("sig",content->signature.signature.rsa.sig);
	732	print_bn("sig",content->signature.info.signature.rsa.sig);
733	733	break;
734	734
735	735	case OPS_PKA_DSA:
736		print_bn("r",content->signature.signature.dsa.r);
737		print_bn("s",content->signature.signature.dsa.s);
	736	print_bn("r",content->signature.info.signature.dsa.r);
	737	print_bn("s",content->signature.info.signature.dsa.s);
738	738	break;
739	739
740	740	case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
741		print_bn("r",content->signature.signature.elgamal.r);
742		print_bn("s",content->signature.signature.elgamal.s);
	741	print_bn("r",content->signature.info.signature.elgamal.r);
	742	print_bn("s",content->signature.info.signature.elgamal.s);
743	743	break;
744	744
…	…
1043	1043	print_indent(indent);
1044	1044	print_unsigned_int("Signature Version",
1045		content->signature.version);
1046		if(content->signature.creation_time_set)
1047		print_time("Signature Creation Time", content->signature.creation_time);
	1045	content->signature.info.version);
	1046	if(content->signature.info.creation_time_set)
	1047	print_time("Signature Creation Time", content->signature.info.creation_time);
1048	1048
1049	1049	print_string_and_value("Signature Type",
1050		ops_show_sig_type(content->signature.type),
1051		content->signature.type);
1052
1053		if(content->signature.signer_id_set)
	1050	ops_show_sig_type(content->signature.info.type),
	1051	content->signature.info.type);
	1052
	1053	if(content->signature.info.signer_id_set)
1054	1054	print_hexdump_data("Signer ID",
1055		content->signature.signer_id,
1056		sizeof content->signature.signer_id);
	1055	content->signature.info.signer_id,
	1056	sizeof content->signature.info.signer_id);
1057	1057
1058	1058	print_string_and_value("Public Key Algorithm",
1059		ops_show_pka(content->signature.key_algorithm),
1060		content->signature.key_algorithm);
	1059	ops_show_pka(content->signature.info.key_algorithm),
	1060	content->signature.info.key_algorithm);
1061	1061	print_string_and_value("Hash Algorithm",
1062		ops_show_hash_algorithm(content->signature.hash_algorithm),
1063		content->signature.hash_algorithm);
	1062	ops_show_hash_algorithm(content->signature.info.hash_algorithm),
	1063	content->signature.info.hash_algorithm);
1064	1064
1065	1065	break;
…	…
1069	1069	print_hexdump_data("hash2",&content->signature.hash2[0],2);
1070	1070
1071		switch(content->signature.key_algorithm)
	1071	switch(content->signature.info.key_algorithm)
1072	1072	{
1073	1073	case OPS_PKA_RSA:
1074		print_bn("sig",content->signature.signature.rsa.sig);
	1074	print_bn("sig",content->signature.info.signature.rsa.sig);
1075	1075	break;
1076	1076
1077	1077	case OPS_PKA_DSA:
1078		print_bn("r",content->signature.signature.dsa.r);
1079		print_bn("s",content->signature.signature.dsa.s);
	1078	print_bn("r",content->signature.info.signature.dsa.r);
	1079	print_bn("s",content->signature.info.signature.dsa.s);
1080	1080	break;
1081	1081
1082	1082	case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
1083		print_bn("r",content->signature.signature.elgamal.r);
1084		print_bn("s",content->signature.signature.elgamal.s);
	1083	print_bn("r",content->signature.info.signature.elgamal.r);
	1084	print_bn("s",content->signature.info.signature.elgamal.s);
1085	1085	break;
1086	1086
…	…
1097	1097	case OPS_PKA_PRIVATE10:
1098	1098	print_data("Private/Experimental",
1099		&content->signature.signature.unknown.data);
	1099	&content->signature.info.signature.unknown.data);
1100	1100	break;
1101	1101
…	…
1286	1286	print_indent(indent);
1287	1287	print_unsigned_int("Signature Version",
1288		content->signature.version);
1289		if (content->signature.creation_time_set)
	1288	content->signature.info.version);
	1289	if (content->signature.info.creation_time_set)
1290	1290	print_time("Signature Creation Time",
1291		content->signature.creation_time);
	1291	content->signature.info.creation_time);
1292	1292
1293	1293	print_string_and_value("Signature Type",
1294		ops_show_sig_type(content->signature.type),
1295		content->signature.type);
1296
1297		if(content->signature.signer_id_set)
	1294	ops_show_sig_type(content->signature.info.type),
	1295	content->signature.info.type);
	1296
	1297	if(content->signature.info.signer_id_set)
1298	1298	print_hexdump_data("Signer ID",
1299		content->signature.signer_id,
1300		sizeof content->signature.signer_id);
	1299	content->signature.info.signer_id,
	1300	sizeof content->signature.info.signer_id);
1301	1301
1302	1302	print_string_and_value("Public Key Algorithm",
1303		ops_show_pka(content->signature.key_algorithm),
1304		content->signature.key_algorithm);
	1303	ops_show_pka(content->signature.info.key_algorithm),
	1304	content->signature.info.key_algorithm);
1305	1305	print_string_and_value("Hash Algorithm",
1306		ops_show_hash_algorithm(content->signature.hash_algorithm),
1307		content->signature.hash_algorithm);
	1306	ops_show_hash_algorithm(content->signature.info.hash_algorithm),
	1307	content->signature.info.hash_algorithm);
1308	1308
1309	1309	print_indent();
1310	1310	print_hexdump_data("hash2",&content->signature.hash2[0],2);
1311	1311
1312		switch(content->signature.key_algorithm)
	1312	switch(content->signature.info.key_algorithm)
1313	1313	{
1314	1314	case OPS_PKA_RSA:
1315	1315	case OPS_PKA_RSA_SIGN_ONLY:
1316		print_bn("sig",content->signature.signature.rsa.sig);
	1316	print_bn("sig",content->signature.info.signature.rsa.sig);
1317	1317	break;
1318	1318
1319	1319	case OPS_PKA_DSA:
1320		print_bn("r",content->signature.signature.dsa.r);
1321		print_bn("s",content->signature.signature.dsa.s);
	1320	print_bn("r",content->signature.info.signature.dsa.r);
	1321	print_bn("s",content->signature.info.signature.dsa.s);
1322	1322	break;
1323	1323
1324	1324	case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
1325		print_bn("r",content->signature.signature.elgamal.r);
1326		print_bn("s",content->signature.signature.elgamal.s);
	1325	print_bn("r",content->signature.info.signature.elgamal.r);
	1326	print_bn("s",content->signature.info.signature.elgamal.s);
1327	1327	break;
1328	1328
…	…
1627	1627	print_indent(indent);
1628	1628	print_unsigned_int("Signature Version",
1629		content->signature.version);
1630		if(content->signature.creation_time_set)
1631		print_time("Signature Creation Time", content->signature.creation_time);
	1629	content->signature.info.version);
	1630	if(content->signature.info.creation_time_set)
	1631	print_time("Signature Creation Time", content->signature.info.creation_time);
1632	1632
1633	1633	print_string_and_value("Signature Type",
1634		ops_show_sig_type(content->signature.type),
1635		content->signature.type);
1636
1637		if(content->signature.signer_id_set)
	1634	ops_show_sig_type(content->signature.info.type),
	1635	content->signature.info.type);
	1636
	1637	if(content->signature.info.signer_id_set)
1638	1638	print_hexdump_data("Signer ID",
1639		content->signature.signer_id,
1640		sizeof content->signature.signer_id);
	1639	content->signature.info.signer_id,
	1640	sizeof content->signature.info.signer_id);
1641	1641
1642	1642	print_string_and_value("Public Key Algorithm",
1643		ops_show_pka(content->signature.key_algorithm),
1644		content->signature.key_algorithm);
	1643	ops_show_pka(content->signature.info.key_algorithm),
	1644	content->signature.info.key_algorithm);
1645	1645	print_string_and_value("Hash Algorithm",
1646		ops_show_hash_algorithm(content->signature.hash_algorithm),
1647		content->signature.hash_algorithm);
	1646	ops_show_hash_algorithm(content->signature.info.hash_algorithm),
	1647	content->signature.info.hash_algorithm);
1648	1648
1649	1649	break;
…	…
1653	1653	print_hexdump_data("hash2",&content->signature.hash2[0],2);
1654	1654
1655		switch(content->signature.key_algorithm)
	1655	switch(content->signature.info.key_algorithm)
1656	1656	{
1657	1657	case OPS_PKA_RSA:
1658		print_bn("sig",content->signature.signature.rsa.sig);
	1658	print_bn("sig",content->signature.info.signature.rsa.sig);
1659	1659	break;
1660	1660
1661	1661	case OPS_PKA_DSA:
1662		print_bn("r",content->signature.signature.dsa.r);
1663		print_bn("s",content->signature.signature.dsa.s);
	1662	print_bn("r",content->signature.info.signature.dsa.r);
	1663	print_bn("s",content->signature.info.signature.dsa.s);
1664	1664	break;
1665	1665
1666	1666	case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
1667		print_bn("r",content->signature.signature.elgamal.r);
1668		print_bn("s",content->signature.signature.elgamal.s);
	1667	print_bn("r",content->signature.info.signature.elgamal.r);
	1668	print_bn("s",content->signature.info.signature.elgamal.s);
1669	1669	break;
1670	1670
…	…
1681	1681	case OPS_PKA_PRIVATE10:
1682	1682	print_data("Private/Experimental",
1683		&content->signature.signature.unknown.data);
	1683	&content->signature.info.signature.unknown.data);
1684	1684	break;
1685	1685

openpgpsdk/trunk/src/lib/signature.c

r574	r602
294	294	static void initialise_hash(ops_hash_t hash,const ops_signature_t sig)
295	295	{
296		ops_hash_any(hash,sig->hash_algorithm);
	296	ops_hash_any(hash,sig->info.hash_algorithm);
297	297	hash->init(hash);
298	298	}
…	…
308	308	const unsigned char *raw_packet)
309	309	{
310		if(sig->version == OPS_V4)
	310	if(sig->info.version == OPS_V4)
311	311	{
312	312	if(raw_packet)
313	313	hash->add(hash,raw_packet+sig->v4_hashed_data_start,
314		sig->v4_hashed_data_length);
315		ops_hash_add_int(hash,sig->version,1);
	314	sig->info.v4_hashed_data_length);
	315	ops_hash_add_int(hash,sig->info.version,1);
316	316	ops_hash_add_int(hash,0xff,1);
317		ops_hash_add_int(hash,sig->v4_hashed_data_length,4);
	317	ops_hash_add_int(hash,sig->info.v4_hashed_data_length,4);
318	318	}
319	319	else
320	320	{
321		ops_hash_add_int(hash,sig->type,1);
322		ops_hash_add_int(hash,sig->creation_time,4);
	321	ops_hash_add_int(hash,sig->info.type,1);
	322	ops_hash_add_int(hash,sig->info.creation_time,4);
323	323	}
324	324	}
…	…
336	336	*/
337	337
338		switch(sig->key_algorithm)
	338	switch(sig->info.key_algorithm)
339	339	{
340	340	case OPS_PKA_DSA:
341		ret=ops_dsa_verify(hash,length,&sig->signature.dsa,&signer->key.dsa);
	341	ret=ops_dsa_verify(hash,length,&sig->info.signature.dsa,&signer->key.dsa);
342	342	break;
343	343
344	344	case OPS_PKA_RSA:
345		ret=rsa_verify(sig->~~hash_algorithm,hash,length,&sig->~~signature.rsa,
	345	ret=rsa_verify(sig->info.hash_algorithm,hash,length,&sig->info.signature.rsa,
346	346	&signer->key.rsa);
347	347	break;
…	…
398	398	init_key_signature(&hash,sig,key);
399	399
400		if(sig->version == OPS_V4)
	400	if(sig->info.version == OPS_V4)
401	401	{
402	402	ops_hash_add_int(&hash,0xb4,1);
…	…
430	430	init_key_signature(&hash,sig,key);
431	431
432		if(sig->version == OPS_V4)
	432	if(sig->info.version == OPS_V4)
433	433	{
434	434	ops_hash_add_int(&hash,0xd1,1);
…	…
504	504	const ops_public_key_t *signer)
505	505	{
506		if(sig->hash_algorithm != hash->algorithm)
	506	if(sig->info.hash_algorithm != hash->algorithm)
507	507	return ops_false;
508	508
…	…
519	519
520	520	// write nearly up to the first subpacket
521		ops_write_scalar(sig->sig.version,1,sig->info);
522		ops_write_scalar(sig->sig.type,1,sig->info);
523		ops_write_scalar(sig->sig.key_algorithm,1,sig->info);
524		ops_write_scalar(sig->sig.hash_algorithm,1,sig->info);
	521	ops_write_scalar(sig->sig.info.version,1,sig->info);
	522	ops_write_scalar(sig->sig.info.type,1,sig->info);
	523	ops_write_scalar(sig->sig.info.key_algorithm,1,sig->info);
	524	ops_write_scalar(sig->sig.info.hash_algorithm,1,sig->info);
525	525
526	526	// dummy hashed subpacket count
…	…
550	550	// use the buffered writer to construct packets (done), and also should
551	551	// share code for hash calculation)
552		sig->sig.version=OPS_V4;
553		sig->sig.hash_algorithm=OPS_HASH_SHA1;
554		sig->sig.key_algorithm=key->algorithm;
555		sig->sig.type=type;
	552	sig->sig.info.version=OPS_V4;
	553	sig->sig.info.hash_algorithm=OPS_HASH_SHA1;
	554	sig->sig.info.key_algorithm=key->algorithm;
	555	sig->sig.info.type=type;
556	556
557	557	sig->hashed_data_length=-1;
…	…
587	587	// use the buffered writer to construct packets (done), and also should
588	588	// share code for hash calculation)
589		sig->sig.version=OPS_V4;
590		sig->sig.key_algorithm=key->public_key.algorithm;
591		sig->sig.hash_algorithm=hash;
592		sig->sig.type=type;
	589	sig->sig.info.version=OPS_V4;
	590	sig->sig.info.key_algorithm=key->public_key.algorithm;
	591	sig->sig.info.hash_algorithm=hash;
	592	sig->sig.info.type=type;
593	593
594	594	sig->hashed_data_length=-1;
…	…
687	687
688	688	// add final trailer
689		ops_hash_add_int(&sig->hash,sig->sig.version,1);
	689	ops_hash_add_int(&sig->hash,sig->sig.info.version,1);
690	690	ops_hash_add_int(&sig->hash,0xff,1);
691	691	// +6 for version, type, pk alg, hash alg, hashed subpacket length

openpgpsdk/trunk/src/lib/validate.c

r594	r602
52	52
53	53	//common_init_signature(&hash,sig);
54		ops_hash_any(&hash,sig->hash_algorithm);
	54	ops_hash_any(&hash,sig->info.hash_algorithm);
55	55	hash.init(&hash);
56	56	hash.add(&hash,data,len);
57		hash.add(&hash,sig->~~v4_hashed_data,sig->~~v4_hashed_data_length);
	57	hash.add(&hash,sig->info.v4_hashed_data,sig->info.v4_hashed_data_length);
58	58
59	59	trailer[0]=0x04; // version
60	60	trailer[1]=0xFF;
61		hashedlen=sig->v4_hashed_data_length;
	61	hashedlen=sig->info.v4_hashed_data_length;
62	62	trailer[2]=hashedlen >> 24;
63	63	trailer[3]=hashedlen >> 16;
…	…
102	102	*/
103	103
104		static void add_key_to_valid_list(ops_validate_result_t * result, const ops_keydata_t *signer)
	104	static void free_signature_info(ops_signature_info_t *sig)
	105	{
	106	free (sig->v4_hashed_data);
	107	free (sig);
	108	}
	109
	110	static void copy_signature_info(ops_signature_info_t* dst, const ops_signature_info_t* src)
	111	{
	112	memcpy(dst,src,sizeof *src);
	113	dst->v4_hashed_data=ops_mallocz(src->v4_hashed_data_length);
	114	memcpy(dst->v4_hashed_data,src->v4_hashed_data,src->v4_hashed_data_length);
	115	}
	116
	117	static void add_sig_to_valid_list(ops_validate_result_t * result, const ops_signature_info_t* sig)
105	118	{
106	119	size_t newsize;
…	…
111	124
112	125	// increase size of array
113		newsize=(sizeof sig~~ner~~) result->valid_count;
114		if (!result->valid_~~key~~s)
115		result->valid_~~key~~s=malloc(newsize);
	126	newsize=(sizeof sig) result->valid_count;
	127	if (!result->valid_sigs)
	128	result->valid_sigs=malloc(newsize);
116	129	else
117		result->valid_~~keys=realloc(result->valid_key~~s, newsize);
	130	result->valid_sigs=realloc(result->valid_sigs, newsize);
118	131
119	132	// copy key ptr to array
120		start=(sizeof sig~~ner~~) (result->valid_count-1);
121		~~memcpy(result->valid_keys+start,signer,sizeof *signer~~);
122		}
123
124		static void add_~~key_to_invalid_list(ops_validate_result_t * result, const ops_keydata_t *signer~~)
	133	start=(sizeof sig) (result->valid_count-1);
	134	copy_signature_info(result->valid_sigs+start,sig);
	135	}
	136
	137	static void add_sig_to_invalid_list(ops_validate_result_t * result, const ops_signature_info_t *sig)
125	138	{
126	139	size_t newsize;
…	…
131	144
132	145	// increase size of array
133		newsize=(sizeof sig~~ner~~) result->invalid_count;
134		if (!result->invalid_~~key~~s)
135		result->invalid_~~key~~s=malloc(newsize);
	146	newsize=(sizeof sig) result->invalid_count;
	147	if (!result->invalid_sigs)
	148	result->invalid_sigs=malloc(newsize);
136	149	else
137		result->invalid_~~keys=realloc(result->invalid_key~~s, newsize);
	150	result->invalid_sigs=realloc(result->invalid_sigs, newsize);
138	151
139	152	// copy key ptr to array
140		start=(sizeof sig~~ner~~) (result->invalid_count-1);
141		~~memcpy(result->invalid_keys+start,signer,(sizeof *signer)~~);
142		}
143
144		static void add_~~key_to_unknown_list(ops_validate_result_t * result, const unsigned char signer_id[OPS_KEY_ID_SIZE]~~)
	153	start=(sizeof sig) (result->invalid_count-1);
	154	copy_signature_info(result->invalid_sigs+start, sig);
	155	}
	156
	157	static void add_sig_to_unknown_list(ops_validate_result_t * result, const ops_signature_info_t *sig)
145	158	{
146	159	size_t newsize;
…	…
151	164
152	165	// increase size of array
153		newsize=(sizeof sig~~ner_id~~) result->unknown_signer_count;
154		if (!result->unknown_~~key~~s)
155		result->unknown_~~key~~s=malloc(newsize);
	166	newsize=(sizeof sig) result->unknown_signer_count;
	167	if (!result->unknown_sigs)
	168	result->unknown_sigs=malloc(newsize);
156	169	else
157		result->unknown_~~keys=realloc(result->unknown_key~~s, newsize);
	170	result->unknown_sigs=realloc(result->unknown_sigs, newsize);
158	171
159	172	// copy key id to array
160	173	start=OPS_KEY_ID_SIZE * (result->unknown_signer_count-1);
161		~~memcpy(result->unknown_keys+start, signer_id, OPS_KEY_ID_SIZE~~);
	174	copy_signature_info(result->unknown_sigs+start, sig);
162	175	}
163	176
…	…
216	229
217	230	signer=ops_keyring_find_key_by_id(arg->keyring,
218		content->signature.signer_id);
	231	content->signature.info.signer_id);
219	232	if(!signer)
220	233	{
221		add_~~key_to_unknown_list(arg->result, content->signature.signer_id~~);
	234	add_sig_to_unknown_list(arg->result, &content->signature.info);
222	235	break;
223	236	}
224	237
225		switch(content->signature.type)
	238	switch(content->signature.info.type)
226	239	{
227	240	case OPS_CERT_GENERIC:
…	…
266	279	case OPS_SIG_3RD_PARTY:
267	280	OPS_ERROR_1(errors, OPS_E_UNIMPLEMENTED,
268		"Verification of signature type 0x%02x not yet implemented\n", content->signature.type);
	281	"Verification of signature type 0x%02x not yet implemented\n", content->signature.info.type);
269	282	break;
270	283
271	284	default:
272	285	OPS_ERROR_1(errors, OPS_E_UNIMPLEMENTED,
273		"Unexpected signature type 0x%02x\n", content->signature.type);
	286	"Unexpected signature type 0x%02x\n", content->signature.info.type);
274	287	}
275	288
…	…
278	291	// printf(" validated\n");
279	292	//++arg->result->valid_count;
280		add_~~key_to_valid_list(arg->result, signer~~);
	293	add_sig_to_valid_list(arg->result, &content->signature.info);
281	294	}
282	295	else
…	…
285	298	// printf(" BAD SIGNATURE\n");
286	299	// ++arg->result->invalid_count;
287		add_~~key_to_invalid_list(arg->result, signer~~);
	300	add_sig_to_invalid_list(arg->result, &content->signature.info);
288	301	}
289	302	break;
…	…
362	375	printf("\n*** hashed data:\n");
363	376	unsigned int zzz=0;
364		for (zzz=0; zzz<content->signature.v4_hashed_data_length; zzz++)
365		printf("0x%02x ", content->signature.v4_hashed_data[zzz]);
	377	for (zzz=0; zzz<content->signature.info.v4_hashed_data_length; zzz++)
	378	printf("0x%02x ", content->signature.info.v4_hashed_data[zzz]);
366	379	printf("\n");
367		printf(" type=%02x signer_id=",content->signature.type);
368		hexdump(content->signature.signer_id,
369		sizeof content->signature.signer_id);
	380	printf(" type=%02x signer_id=",content->signature.info.type);
	381	hexdump(content->signature.info.signer_id,
	382	sizeof content->signature.info.signer_id);
370	383	}
371	384
372	385	signer=ops_keyring_find_key_by_id(arg->keyring,
373		content->signature.signer_id);
	386	content->signature.info.signer_id);
374	387	if(!signer)
375	388	{
376	389	OPS_ERROR(errors,OPS_E_V_UNKNOWN_SIGNER,"Unknown Signer");
377		add_~~key_to_unknown_list(arg->result, content->signature.signer_id~~);
	390	add_sig_to_unknown_list(arg->result, &content->signature.info);
378	391	break;
379	392	}
…	…
382	395	ops_memory_init(mem,128);
383	396
384		switch(content->signature.type)
	397	switch(content->signature.info.type)
385	398	{
386	399	case OPS_SIG_BINARY:
…	…
414	427	default:
415	428	OPS_ERROR_1(errors, OPS_E_UNIMPLEMENTED,
416		"Verification of signature type 0x%02x not yet implemented\n", content->signature.type);
	429	"Verification of signature type 0x%02x not yet implemented\n", content->signature.info.type);
417	430	break;
418	431
…	…
422	435	if(valid)
423	436	{
424		add_~~key_to_valid_list(arg->result, signer~~);
	437	add_sig_to_valid_list(arg->result, &content->signature.info);
425	438	// ++arg->result->valid_count;
426	439	}
…	…
430	443	// printf(" BAD SIGNATURE\n");
431	444	// ++arg->result->invalid_count;
432		add_~~key_to_invalid_list(arg->result, signer~~);
	445	add_sig_to_invalid_list(arg->result, &content->signature.info);
433	446	}
434	447	break;
…	…
522	535	return;
523	536
524		if (result->valid_~~key~~s)
525		free~~(result->valid_key~~s);
526		if (result->invalid_~~key~~s)
527		free~~(result->invalid_key~~s);
528		if (result->unknown_~~key~~s)
529		free~~(result->unknown_key~~s);
	537	if (result->valid_sigs)
	538	free_signature_info(result->valid_sigs);
	539	if (result->invalid_sigs)
	540	free_signature_info(result->invalid_sigs);
	541	if (result->unknown_sigs)
	542	free_signature_info(result->unknown_sigs);
530	543
531	544	free(result);

openpgpsdk/trunk/tests/test_common.c

r574	r602
475	475
476	476	// example: print out the signature creation time
477		if (content_->content.signature.creation_time_set)
	477	if (content_->content.signature.info.creation_time_set)
478	478	{
479	479	printf("\nsignature creation time : %s",
480		ctime(&content_->content.signature.creation_time));
	480	ctime(&content_->content.signature.info.creation_time));
481	481	}
482	482	break;

openpgpsdk/trunk/tests/test_rsa_keys.c

r594	r602
144	144	ops_validate_all_signatures(result, &pub_keyring, NULL);
145	145	CU_ASSERT(result->valid_count==1);
146		CU_ASSERT(strncmp((char )ops_get_key_id(&result->valid_keys[0]),(char )keyid,strlen((char *)keyid))==0);
147		CU_ASSERT(~~strncmp((char *)ops_get_user_id(&result->valid_keys[0],0),userid,strlen(userid)~~)==0);
	146
	147	CU_ASSERT(memcmp(result->valid_sigs[0].signer_id,keyid,OPS_KEY_ID_SIZE)==0);
148	148	CU_ASSERT(result->invalid_count==0);
149	149	CU_ASSERT(result->unknown_signer_count==0);

Download in other formats: