From 450b7dd65f095b98704a379ef7b654890098b33c Mon Sep 17 00:00:00 2001 From: Adam Janovsky Date: Sat, 18 Dec 2021 14:02:25 +0100 Subject: Format code with black --- tests/fips_test_utils.py | 15 +- tests/test_cc_heuristics.py | 221 +++++++++++++++++++++--------- tests/test_cc_oop.py | 293 +++++++++++++++++++++++----------------- tests/test_cc_txt_processing.py | 4 +- tests/test_fips_oop.py | 207 ++++++++++++++++++---------- 5 files changed, 468 insertions(+), 272 deletions(-) (limited to 'tests') diff --git a/tests/fips_test_utils.py b/tests/fips_test_utils.py index 94fb406a..07734d9d 100644 --- a/tests/fips_test_utils.py +++ b/tests/fips_test_utils.py @@ -1,17 +1,18 @@ from typing import List from pathlib import Path + def generate_html(ids: List[str], path: Path): def generate_entry(certificate_id: str) -> str: - return f''' + return f""" {certificate_id} - ''' + """ - html_head = ''' + html_head = """ @@ -25,11 +26,11 @@ def generate_html(ids: List[str], path: Path): - ''' + """ rows = "" for cert_id in ids: rows += f"\n{generate_entry(cert_id)}\n" - html_body = f''' + html_body = f""" @@ -46,6 +47,6 @@ def generate_html(ids: List[str], path: Path):
- ''' - with open(path, 'w') as f: + """ + with open(path, "w") as f: f.write(f"{html_head}\n{html_body}\n") diff --git a/tests/test_cc_heuristics.py b/tests/test_cc_heuristics.py index 13cdb465..527d6e6f 100644 --- a/tests/test_cc_heuristics.py +++ b/tests/test_cc_heuristics.py @@ -17,7 +17,7 @@ import tests.data.test_cc_heuristics class TestCommonCriteriaHeuristics(TestCase): - dataset_json_path: ClassVar[Path] = Path(tests.data.test_cc_heuristics.__path__[0]) / 'vulnerable_dataset.json' + dataset_json_path: ClassVar[Path] = Path(tests.data.test_cc_heuristics.__path__[0]) / "vulnerable_dataset.json" data_dir_path: ClassVar[Path] = dataset_json_path.parent @classmethod @@ -25,40 +25,44 @@ class TestCommonCriteriaHeuristics(TestCase): cls.tmp_dir: ClassVar[tempfile.TemporaryDirectory] = tempfile.TemporaryDirectory() shutil.copytree(cls.data_dir_path, cls.tmp_dir.name, dirs_exist_ok=True) - cls.cc_dset: CCDataset = CCDataset.from_json(Path(cls.tmp_dir.name) / 'vulnerable_dataset.json') + cls.cc_dset: CCDataset = CCDataset.from_json(Path(cls.tmp_dir.name) / "vulnerable_dataset.json") cls.cc_dset.process_protection_profiles() cls.cc_dset.download_all_pdfs() cls.cc_dset.convert_all_pdfs() cls.cc_dset._extract_data() cls.cc_dset._compute_heuristics(use_nist_cpe_matching_dict=False) - - cpe_single_sign_on = CPE("cpe:2.3:a:ibm:security_access_manager_for_enterprise_single_sign-on:8.2.2:*:*:*:*:*:*:*", - "IBM Security Access Manager For Enterprise Single Sign-On 8.2.2") + cpe_single_sign_on = CPE( + "cpe:2.3:a:ibm:security_access_manager_for_enterprise_single_sign-on:8.2.2:*:*:*:*:*:*:*", + "IBM Security Access Manager For Enterprise Single Sign-On 8.2.2", + ) cls.cpes = [ cpe_single_sign_on, - CPE("cpe:2.3:a:ibm:security_key_lifecycle_manager:2.6.0.1:*:*:*:*:*:*:*", - "IBM Security Key Lifecycle Manager 2.6.0.1"), - CPE("cpe:2.3:a:semperplugins:all_in_one_seo_pack:1.3.6.4:*:*:*:*:wordpress:*:*", - "Semper Plugins All in One SEO Pack 1.3.6.4 for WordPress"), - CPE("cpe:2.3:a:tracker-software:pdf-xchange_lite_printer:6.0.320.0:*:*:*:*:*:*:*", - "Tracker Software PDF-XChange Lite Printer 6.0.320.0") + CPE( + "cpe:2.3:a:ibm:security_key_lifecycle_manager:2.6.0.1:*:*:*:*:*:*:*", + "IBM Security Key Lifecycle Manager 2.6.0.1", + ), + CPE( + "cpe:2.3:a:semperplugins:all_in_one_seo_pack:1.3.6.4:*:*:*:*:wordpress:*:*", + "Semper Plugins All in One SEO Pack 1.3.6.4 for WordPress", + ), + CPE( + "cpe:2.3:a:tracker-software:pdf-xchange_lite_printer:6.0.320.0:*:*:*:*:*:*:*", + "Tracker Software PDF-XChange Lite Printer 6.0.320.0", + ), ] - cls.cpe_dset = CPEDataset(True, Path('../'), {x.uri: x for x in cls.cpes}) + cls.cpe_dset = CPEDataset(True, Path("../"), {x.uri: x for x in cls.cpes}) cls.cves = [ - CVE('CVE-2017-1732', - [cpe_single_sign_on], - CVE.Impact(5.3, 'MEDIUM', 3.9, 1.4), - '2021-05-26T04:15Z', - ), - CVE('CVE-2019-4513', + CVE( + "CVE-2017-1732", [cpe_single_sign_on], - CVE.Impact(8.2, 'HIGH', 3.9, 4.2), - '2000-05-26T04:15Z' - ) - ] + CVE.Impact(5.3, "MEDIUM", 3.9, 1.4), + "2021-05-26T04:15Z", + ), + CVE("CVE-2019-4513", [cpe_single_sign_on], CVE.Impact(8.2, "HIGH", 3.9, 4.2), "2000-05-26T04:15Z"), + ] cls.cve_dset = CVEDataset({x.cve_id: x for x in cls.cves}) cls.cve_dset.build_lookup_dict(use_nist_mapping=False) @@ -67,89 +71,172 @@ class TestCommonCriteriaHeuristics(TestCase): cls.tmp_dir.cleanup() def test_load_cpe_dataset(self): - json_cpe_dset = CPEDataset.from_json(self.data_dir_path / 'auxillary_datasets' / 'cpe_dataset.json') - json_cpe_dset.json_path = Path('../') - self.assertEqual(self.cpe_dset, json_cpe_dset, 'CPE template dataset does not match CPE dataset loaded from json.') + json_cpe_dset = CPEDataset.from_json(self.data_dir_path / "auxillary_datasets" / "cpe_dataset.json") + json_cpe_dset.json_path = Path("../") + self.assertEqual( + self.cpe_dset, json_cpe_dset, "CPE template dataset does not match CPE dataset loaded from json." + ) def test_cpe_lookup_dicts(self): - self.assertEqual(self.cpe_dset.vendors, {'ibm', 'tracker-software', 'semperplugins'}, - 'The set of versions in CPE dataset does not match template') - self.assertEqual(self.cpe_dset.vendor_to_versions, {'ibm': {'8.2.2', '2.6.0.1'}, 'semperplugins': {'1.3.6.4'}, 'tracker-software': {'6.0.320.0'}}, - 'The CPE lookup dictionary vendor->version of CPE dataset does not match template.') - self.assertEqual(self.cpe_dset.vendor_version_to_cpe, {('ibm', '8.2.2'): {CPE('cpe:2.3:a:ibm:security_access_manager_for_enterprise_single_sign-on:8.2.2:*:*:*:*:*:*:*', 'IBM Security Access Manager For Enterprise Single Sign-On 8.2.2')}, ('ibm', '2.6.0.1'): {CPE('cpe:2.3:a:ibm:security_key_lifecycle_manager:2.6.0.1:*:*:*:*:*:*:*', 'IBM Security Key Lifecycle Manager 2.6.0.1')}, ('semperplugins', '1.3.6.4'): {CPE('cpe:2.3:a:semperplugins:all_in_one_seo_pack:1.3.6.4:*:*:*:*:wordpress:*:*', 'Semper Plugins All in One SEO Pack 1.3.6.4 for WordPress')}, ('tracker-software', '6.0.320.0'): {CPE('cpe:2.3:a:tracker-software:pdf-xchange_lite_printer:6.0.320.0:*:*:*:*:*:*:*', 'Tracker Software PDF-XChange Lite Printer 6.0.320.0')}}, - 'The CPE lookup dictionary (vendor,version)->cpe does not match the template.') + self.assertEqual( + self.cpe_dset.vendors, + {"ibm", "tracker-software", "semperplugins"}, + "The set of versions in CPE dataset does not match template", + ) + self.assertEqual( + self.cpe_dset.vendor_to_versions, + {"ibm": {"8.2.2", "2.6.0.1"}, "semperplugins": {"1.3.6.4"}, "tracker-software": {"6.0.320.0"}}, + "The CPE lookup dictionary vendor->version of CPE dataset does not match template.", + ) + self.assertEqual( + self.cpe_dset.vendor_version_to_cpe, + { + ("ibm", "8.2.2"): { + CPE( + "cpe:2.3:a:ibm:security_access_manager_for_enterprise_single_sign-on:8.2.2:*:*:*:*:*:*:*", + "IBM Security Access Manager For Enterprise Single Sign-On 8.2.2", + ) + }, + ("ibm", "2.6.0.1"): { + CPE( + "cpe:2.3:a:ibm:security_key_lifecycle_manager:2.6.0.1:*:*:*:*:*:*:*", + "IBM Security Key Lifecycle Manager 2.6.0.1", + ) + }, + ("semperplugins", "1.3.6.4"): { + CPE( + "cpe:2.3:a:semperplugins:all_in_one_seo_pack:1.3.6.4:*:*:*:*:wordpress:*:*", + "Semper Plugins All in One SEO Pack 1.3.6.4 for WordPress", + ) + }, + ("tracker-software", "6.0.320.0"): { + CPE( + "cpe:2.3:a:tracker-software:pdf-xchange_lite_printer:6.0.320.0:*:*:*:*:*:*:*", + "Tracker Software PDF-XChange Lite Printer 6.0.320.0", + ) + }, + }, + "The CPE lookup dictionary (vendor,version)->cpe does not match the template.", + ) def test_cve_lookup_dicts(self): alt_lookup = {x: set(y) for x, y in self.cve_dset.cpe_to_cve_ids_lookup.items()} - self.assertEqual(alt_lookup, {'cpe:2.3:a:ibm:security_access_manager_for_enterprise_single_sign-on:8.2.2:*:*:*:*:*:*:*': {x.cve_id for x in self.cves}}, - 'The CVE lookup dicionary cve-> affected cpes does not match the template') + self.assertEqual( + alt_lookup, + { + "cpe:2.3:a:ibm:security_access_manager_for_enterprise_single_sign-on:8.2.2:*:*:*:*:*:*:*": { + x.cve_id for x in self.cves + } + }, + "The CVE lookup dicionary cve-> affected cpes does not match the template", + ) def test_load_cve_dataset(self): - json_cve_dset = CVEDataset.from_json(self.data_dir_path / 'auxillary_datasets' / 'cve_dataset.json') - self.assertEqual(self.cve_dset, json_cve_dset, 'CVE template dataset does not match CVE dataset loaded from json.') + json_cve_dset = CVEDataset.from_json(self.data_dir_path / "auxillary_datasets" / "cve_dataset.json") + self.assertEqual( + self.cve_dset, json_cve_dset, "CVE template dataset does not match CVE dataset loaded from json." + ) def test_match_cpe(self): - self.assertTrue(self.cpes[0].uri in self.cc_dset['ebd276cca70fd723'].heuristics.cpe_matches, 'The CPE matching algorithm did not find the right CPE.') - self.assertTrue(len(self.cc_dset['ebd276cca70fd723'].heuristics.cpe_matches) == 1, 'Exactly one CPE match should be found.') + self.assertTrue( + self.cpes[0].uri in self.cc_dset["ebd276cca70fd723"].heuristics.cpe_matches, + "The CPE matching algorithm did not find the right CPE.", + ) + self.assertTrue( + len(self.cc_dset["ebd276cca70fd723"].heuristics.cpe_matches) == 1, "Exactly one CPE match should be found." + ) def test_find_related_cves(self): - self.cc_dset['ebd276cca70fd723'].heuristics.cpe_matches = [self.cpes[0].uri] - self.cc_dset.compute_related_cves(use_nist_cpe_matching_dict = False) - self.assertEqual({x.cve_id for x in self.cves}, self.cc_dset['ebd276cca70fd723'].heuristics.related_cves, 'The computed CVEs do not match the excpected CVEs') + self.cc_dset["ebd276cca70fd723"].heuristics.cpe_matches = [self.cpes[0].uri] + self.cc_dset.compute_related_cves(use_nist_cpe_matching_dict=False) + self.assertEqual( + {x.cve_id for x in self.cves}, + self.cc_dset["ebd276cca70fd723"].heuristics.related_cves, + "The computed CVEs do not match the excpected CVEs", + ) def test_version_extraction(self): - self.assertEqual(self.cc_dset['ebd276cca70fd723'].heuristics.extracted_versions, ['8.2'], 'The version extracted from the sample does not match the template') - new_cert = CommonCriteriaCert('', '', 'IDOneClassIC Card : ID-One Cosmo 64 RSA v5.4 and applet IDOneClassIC v1.0 embedded on P5CT072VOP', '', '', - '', None, None, '', '', '', '', set(), set(), None, None, None) + self.assertEqual( + self.cc_dset["ebd276cca70fd723"].heuristics.extracted_versions, + ["8.2"], + "The version extracted from the sample does not match the template", + ) + new_cert = CommonCriteriaCert( + "", + "", + "IDOneClassIC Card : ID-One Cosmo 64 RSA v5.4 and applet IDOneClassIC v1.0 embedded on P5CT072VOP", + "", + "", + "", + None, + None, + "", + "", + "", + "", + set(), + set(), + None, + None, + None, + ) new_cert.compute_heuristics_version() - self.assertEqual(set(new_cert.heuristics.extracted_versions), {'5.4', '1.0'}, 'The extracted versions do not match the template.') + self.assertEqual( + set(new_cert.heuristics.extracted_versions), + {"5.4", "1.0"}, + "The extracted versions do not match the template.", + ) def test_cert_lab_heuristics(self): - self.assertEqual(self.cc_dset['ebd276cca70fd723'].heuristics.cert_lab, ['BSI']) + self.assertEqual(self.cc_dset["ebd276cca70fd723"].heuristics.cert_lab, ["BSI"]) def test_cert_id_heuristics(self): - self.assertEqual(self.cc_dset['ebd276cca70fd723'].heuristics.cert_id, 'BSI-DSZ-CC-0683-2014') + self.assertEqual(self.cc_dset["ebd276cca70fd723"].heuristics.cert_id, "BSI-DSZ-CC-0683-2014") def test_keywords_heuristics(self): - extracted_keywords: Dict = self.cc_dset['ebd276cca70fd723'].pdf_data.st_keywords + extracted_keywords: Dict = self.cc_dset["ebd276cca70fd723"].pdf_data.st_keywords - self.assertTrue('rules_security_level' in extracted_keywords) - self.assertEqual(extracted_keywords['rules_security_level']['EAL3'], 1) + self.assertTrue("rules_security_level" in extracted_keywords) + self.assertEqual(extracted_keywords["rules_security_level"]["EAL3"], 1) - self.assertTrue('rules_security_assurance_components' in extracted_keywords) - self.assertEqual(extracted_keywords['rules_security_assurance_components']['ADV_ARC.1'], 1) - self.assertEqual(extracted_keywords['rules_security_assurance_components']['ADV_FSP.3'], 1) - self.assertEqual(extracted_keywords['rules_security_assurance_components']['ADV_TDS.2'], 1) + self.assertTrue("rules_security_assurance_components" in extracted_keywords) + self.assertEqual(extracted_keywords["rules_security_assurance_components"]["ADV_ARC.1"], 1) + self.assertEqual(extracted_keywords["rules_security_assurance_components"]["ADV_FSP.3"], 1) + self.assertEqual(extracted_keywords["rules_security_assurance_components"]["ADV_TDS.2"], 1) - self.assertTrue('rules_crypto_algs' in extracted_keywords) - self.assertEqual(extracted_keywords['rules_crypto_algs']['AES'], 2) + self.assertTrue("rules_crypto_algs" in extracted_keywords) + self.assertEqual(extracted_keywords["rules_crypto_algs"]["AES"], 2) - self.assertTrue('rules_block_cipher_modes' in extracted_keywords) - self.assertEqual(extracted_keywords['rules_block_cipher_modes']['CBC'], 2) + self.assertTrue("rules_block_cipher_modes" in extracted_keywords) + self.assertEqual(extracted_keywords["rules_block_cipher_modes"]["CBC"], 2) def test_protection_profiles_matching(self): - artificial_pp: ProtectionProfile = ProtectionProfile('Korean National Protection Profile for Single Sign On V1.0', - 'http://www.commoncriteriaportal.org/files/ppfiles/KECS-PP-0822-2017%20Korean%20National%20PP%20for%20Single%20Sign%20On%20V1.0(eng).pdf') - self.cc_dset['ebd276cca70fd723'].protection_profiles = {artificial_pp} - expected_pp: ProtectionProfile = ProtectionProfile('Korean National Protection Profile for Single Sign On V1.0', - 'http://www.commoncriteriaportal.org/files/ppfiles/KECS-PP-0822-2017%20Korean%20National%20PP%20for%20Single%20Sign%20On%20V1.0(eng).pdf', - frozenset(['KECS-PP-0822-2017 SSO V1.0'])) + artificial_pp: ProtectionProfile = ProtectionProfile( + "Korean National Protection Profile for Single Sign On V1.0", + "http://www.commoncriteriaportal.org/files/ppfiles/KECS-PP-0822-2017%20Korean%20National%20PP%20for%20Single%20Sign%20On%20V1.0(eng).pdf", + ) + self.cc_dset["ebd276cca70fd723"].protection_profiles = {artificial_pp} + expected_pp: ProtectionProfile = ProtectionProfile( + "Korean National Protection Profile for Single Sign On V1.0", + "http://www.commoncriteriaportal.org/files/ppfiles/KECS-PP-0822-2017%20Korean%20National%20PP%20for%20Single%20Sign%20On%20V1.0(eng).pdf", + frozenset(["KECS-PP-0822-2017 SSO V1.0"]), + ) self.cc_dset.process_protection_profiles(to_download=False) - self.assertSetEqual(self.cc_dset['ebd276cca70fd723'].protection_profiles, {expected_pp}) + self.assertSetEqual(self.cc_dset["ebd276cca70fd723"].protection_profiles, {expected_pp}) def test_single_record_dependency_heuristics(self): # Single record in daset is not affecting nor affected by other records - heuristics = self.cc_dset['ebd276cca70fd723'].heuristics + heuristics = self.cc_dset["ebd276cca70fd723"].heuristics self.assertEqual(heuristics.directly_affected_by, None) self.assertEqual(heuristics.indirectly_affected_by, None) self.assertEqual(heuristics.directly_affecting, None) self.assertEqual(heuristics.indirectly_affecting, None) def test_dependency_dataset(self): - dependency_dataset = CCDataset.from_json(self.data_dir_path / 'dependency_dataset.json') + dependency_dataset = CCDataset.from_json(self.data_dir_path / "dependency_dataset.json") dependency_dataset._compute_dependencies() test_cert: CommonCriteriaCert = dependency_dataset["692e91451741ef49"] - + self.assertEqual(test_cert.heuristics.directly_affected_by, ["BSI-DSZ-CC-0370-2006"]) self.assertEqual(test_cert.heuristics.indirectly_affected_by, {"BSI-DSZ-CC-0370-2006", "BSI-DSZ-CC-0517-2009"}) self.assertEqual(test_cert.heuristics.directly_affecting, {"BSI-DSZ-CC-0268-2005"}) diff --git a/tests/test_cc_oop.py b/tests/test_cc_oop.py index 3ca1935e..9a598bc5 100644 --- a/tests/test_cc_oop.py +++ b/tests/test_cc_oop.py @@ -17,162 +17,211 @@ import sec_certs.constants as constants class TestCommonCriteriaOOP(TestCase): def setUp(self): - self.test_data_dir = Path(__file__).parent / 'data' / 'test_cc_oop' - self.crt_one = CommonCriteriaCert('active', - 'Access Control Devices and Systems', - 'NetIQ Identity Manager 4.7', - 'NetIQ Corporation', - 'SE', - {'ALC_FLR.2', - 'EAL3+'}, - date(2020, 6, 15), - date(2025, 6, 15), - 'https://www.commoncriteriaportal.org/files/epfiles/Certification%20Report%20-%20NetIQ®%20Identity%20Manager%204.7.pdf', - 'https://www.commoncriteriaportal.org/files/epfiles/ST%20-%20NetIQ%20Identity%20Manager%204.7.pdf', - 'https://www.commoncriteriaportal.org/files/epfiles/Certifikat%20CCRA%20-%20NetIQ%20Identity%20Manager%204.7_signed.pdf', - 'https://www.netiq.com/', - set(), - set(), - None, - None, - None) - - self.crt_two = CommonCriteriaCert('active', - 'Access Control Devices and Systems', - 'Magic SSO V4.0', - 'Dreamsecurity Co., Ltd.', - 'KR', - set(), - date(2019, 11, 15), - date(2024, 11, 15), - 'https://www.commoncriteriaportal.org/files/epfiles/KECS-CR-19-70%20Magic%20SSO%20V4.0(eng)%20V1.0.pdf', - 'https://www.commoncriteriaportal.org/files/epfiles/Magic_SSO_V4.0-ST-v1.4_EN.pdf', - None, - 'https://www.dreamsecurity.com/', - {ProtectionProfile('Korean National Protection Profile for Single Sign On V1.0', - 'https://www.commoncriteriaportal.org/files/ppfiles/KECS-PP-0822-2017%20Korean%20National%20PP%20for%20Single%20Sign%20On%20V1.0(eng).pdf')}, - set(), - None, - None, - None) - - pp = ProtectionProfile('sample_pp', 'https://sample.pp') - update = CommonCriteriaCert.MaintenanceReport(date(1900, 1, 1), 'Sample maintenance', 'https://maintenance.up', 'https://maintenance.up') - self.fictional_cert = CommonCriteriaCert('archived', - 'Sample category', - 'Sample certificate name', - 'Sample manufacturer', - 'Sample scheme', - {'Sample security level'}, - date(1900, 1, 2), - date(1900, 1, 3), - 'https://path.to/report/link', - 'https://path.to/st/link', - 'https://path.to/cert/link', - 'https://path.to/manufacturer/web', - {pp}, - {update}, - None, - None, - None) - self.template_dataset = CCDataset({self.crt_one.dgst: self.crt_one, self.crt_two.dgst: self.crt_two}, Path('/fictional/path/to/dataset'), 'toy dataset', 'toy dataset description') + self.test_data_dir = Path(__file__).parent / "data" / "test_cc_oop" + self.crt_one = CommonCriteriaCert( + "active", + "Access Control Devices and Systems", + "NetIQ Identity Manager 4.7", + "NetIQ Corporation", + "SE", + {"ALC_FLR.2", "EAL3+"}, + date(2020, 6, 15), + date(2025, 6, 15), + "https://www.commoncriteriaportal.org/files/epfiles/Certification%20Report%20-%20NetIQ®%20Identity%20Manager%204.7.pdf", + "https://www.commoncriteriaportal.org/files/epfiles/ST%20-%20NetIQ%20Identity%20Manager%204.7.pdf", + "https://www.commoncriteriaportal.org/files/epfiles/Certifikat%20CCRA%20-%20NetIQ%20Identity%20Manager%204.7_signed.pdf", + "https://www.netiq.com/", + set(), + set(), + None, + None, + None, + ) + + self.crt_two = CommonCriteriaCert( + "active", + "Access Control Devices and Systems", + "Magic SSO V4.0", + "Dreamsecurity Co., Ltd.", + "KR", + set(), + date(2019, 11, 15), + date(2024, 11, 15), + "https://www.commoncriteriaportal.org/files/epfiles/KECS-CR-19-70%20Magic%20SSO%20V4.0(eng)%20V1.0.pdf", + "https://www.commoncriteriaportal.org/files/epfiles/Magic_SSO_V4.0-ST-v1.4_EN.pdf", + None, + "https://www.dreamsecurity.com/", + { + ProtectionProfile( + "Korean National Protection Profile for Single Sign On V1.0", + "https://www.commoncriteriaportal.org/files/ppfiles/KECS-PP-0822-2017%20Korean%20National%20PP%20for%20Single%20Sign%20On%20V1.0(eng).pdf", + ) + }, + set(), + None, + None, + None, + ) + + pp = ProtectionProfile("sample_pp", "https://sample.pp") + update = CommonCriteriaCert.MaintenanceReport( + date(1900, 1, 1), "Sample maintenance", "https://maintenance.up", "https://maintenance.up" + ) + self.fictional_cert = CommonCriteriaCert( + "archived", + "Sample category", + "Sample certificate name", + "Sample manufacturer", + "Sample scheme", + {"Sample security level"}, + date(1900, 1, 2), + date(1900, 1, 3), + "https://path.to/report/link", + "https://path.to/st/link", + "https://path.to/cert/link", + "https://path.to/manufacturer/web", + {pp}, + {update}, + None, + None, + None, + ) + self.template_dataset = CCDataset( + {self.crt_one.dgst: self.crt_one, self.crt_two.dgst: self.crt_two}, + Path("/fictional/path/to/dataset"), + "toy dataset", + "toy dataset description", + ) self.template_dataset.timestamp = datetime(2020, 11, 16, hour=17, minute=4, second=14, microsecond=770153) self.template_dataset.state.meta_sources_parsed = True - self.template_report_pdf_hashes = {'309ac2fd7f2dcf17': '774c41fbba980191ca40ae610b2f61484c5997417b3325b6fd68b345173bde52', - '8cf86948f02f047d': '533a5995ef8b736cc48cfda30e8aafec77d285511471e0e5a9e8007c8750203a'} - self.template_target_pdf_hashes = {'309ac2fd7f2dcf17': 'b9a45995d9e40b2515506bbf5945e806ef021861820426c6d0a6a074090b47a9', - '8cf86948f02f047d': '3c8614338899d956e9e56f1aa88d90e37df86f3310b875d9d14ec0f71e4759be'} + self.template_report_pdf_hashes = { + "309ac2fd7f2dcf17": "774c41fbba980191ca40ae610b2f61484c5997417b3325b6fd68b345173bde52", + "8cf86948f02f047d": "533a5995ef8b736cc48cfda30e8aafec77d285511471e0e5a9e8007c8750203a", + } + self.template_target_pdf_hashes = { + "309ac2fd7f2dcf17": "b9a45995d9e40b2515506bbf5945e806ef021861820426c6d0a6a074090b47a9", + "8cf86948f02f047d": "3c8614338899d956e9e56f1aa88d90e37df86f3310b875d9d14ec0f71e4759be", + } - self.template_report_txt_path = self.test_data_dir / 'report_869415cc4b91282e.txt' - self.template_target_txt_path = self.test_data_dir / 'target_869415cc4b91282e.txt' + self.template_report_txt_path = self.test_data_dir / "report_869415cc4b91282e.txt" + self.template_target_txt_path = self.test_data_dir / "target_869415cc4b91282e.txt" def test_certificate_input_sanity(self): - self.assertEqual(self.crt_one.report_link, - 'https://www.commoncriteriaportal.org/files/epfiles/Certification%20Report%20-%20NetIQ®%20Identity%20Manager%204.7.pdf', - 'Report link contains some improperly escaped characters.') + self.assertEqual( + self.crt_one.report_link, + "https://www.commoncriteriaportal.org/files/epfiles/Certification%20Report%20-%20NetIQ®%20Identity%20Manager%204.7.pdf", + "Report link contains some improperly escaped characters.", + ) def test_download_and_convert_pdfs(self): - dset = CCDataset.from_json(self.test_data_dir / 'toy_dataset.json') + dset = CCDataset.from_json(self.test_data_dir / "toy_dataset.json") with TemporaryDirectory() as td: dset.root_dir = Path(td) dset.download_all_pdfs() dset.convert_all_pdfs() - actual_report_pdf_hashes = {key: helpers.get_sha256_filepath(val.state.report_pdf_path) for key, val in dset.certs.items()} - actual_target_pdf_hashes = {key: helpers.get_sha256_filepath(val.state.st_pdf_path) for key, val in dset.certs.items()} - - self.assertEqual(actual_report_pdf_hashes, self.template_report_pdf_hashes, 'Hashes of downloaded pdfs (sample report) do not the template') - self.assertEqual(actual_target_pdf_hashes, self.template_target_pdf_hashes, 'Hashes of downloaded pdfs (security target) do not match the template') - - self.assertTrue(dset['309ac2fd7f2dcf17'].state.report_txt_path.exists()) - self.assertTrue(dset['309ac2fd7f2dcf17'].state.st_txt_path.exists()) - - self.assertAlmostEqual(dset['309ac2fd7f2dcf17'].state.st_txt_path.stat().st_size, - self.template_target_txt_path.stat().st_size, - delta=1000) - - self.assertAlmostEqual(dset['309ac2fd7f2dcf17'].state.report_txt_path.stat().st_size, - self.template_report_txt_path.stat().st_size, - delta=1000) + actual_report_pdf_hashes = { + key: helpers.get_sha256_filepath(val.state.report_pdf_path) for key, val in dset.certs.items() + } + actual_target_pdf_hashes = { + key: helpers.get_sha256_filepath(val.state.st_pdf_path) for key, val in dset.certs.items() + } + + self.assertEqual( + actual_report_pdf_hashes, + self.template_report_pdf_hashes, + "Hashes of downloaded pdfs (sample report) do not the template", + ) + self.assertEqual( + actual_target_pdf_hashes, + self.template_target_pdf_hashes, + "Hashes of downloaded pdfs (security target) do not match the template", + ) + + self.assertTrue(dset["309ac2fd7f2dcf17"].state.report_txt_path.exists()) + self.assertTrue(dset["309ac2fd7f2dcf17"].state.st_txt_path.exists()) + + self.assertAlmostEqual( + dset["309ac2fd7f2dcf17"].state.st_txt_path.stat().st_size, + self.template_target_txt_path.stat().st_size, + delta=1000, + ) + + self.assertAlmostEqual( + dset["309ac2fd7f2dcf17"].state.report_txt_path.stat().st_size, + self.template_report_txt_path.stat().st_size, + delta=1000, + ) def test_cert_to_json(self): - with NamedTemporaryFile('w') as tmp: + with NamedTemporaryFile("w") as tmp: self.fictional_cert.to_json(tmp.name) - self.assertTrue(filecmp.cmp(self.test_data_dir / 'fictional_cert.json', - tmp.name), - 'The sample serialized to json differs from a template.') + self.assertTrue( + filecmp.cmp(self.test_data_dir / "fictional_cert.json", tmp.name), + "The sample serialized to json differs from a template.", + ) def test_dataset_to_json(self): - with NamedTemporaryFile('w') as tmp: + with NamedTemporaryFile("w") as tmp: self.template_dataset.to_json(tmp.name) - self.assertTrue(filecmp.cmp(self.test_data_dir / 'toy_dataset.json', - tmp.name), - 'The dataset serialized to json differs from a template.') + self.assertTrue( + filecmp.cmp(self.test_data_dir / "toy_dataset.json", tmp.name), + "The dataset serialized to json differs from a template.", + ) def test_cert_from_json(self): - self.assertEqual(self.fictional_cert, - CommonCriteriaCert.from_json(self.test_data_dir / 'fictional_cert.json'), - 'The sample serialized from json differs from a template.') + self.assertEqual( + self.fictional_cert, + CommonCriteriaCert.from_json(self.test_data_dir / "fictional_cert.json"), + "The sample serialized from json differs from a template.", + ) def test_dataset_from_json(self): - self.assertEqual(self.template_dataset, - CCDataset.from_json(self.test_data_dir / 'toy_dataset.json'), - 'The dataset serialized from json differs from a template.') + self.assertEqual( + self.template_dataset, + CCDataset.from_json(self.test_data_dir / "toy_dataset.json"), + "The dataset serialized from json differs from a template.", + ) def test_build_empty_dataset(self): with TemporaryDirectory() as tmp_dir: - dset = CCDataset({}, Path(tmp_dir), 'sample_dataset', 'sample dataset description') + dset = CCDataset({}, Path(tmp_dir), "sample_dataset", "sample dataset description") dset.get_certs_from_web(to_download=False, get_archived=False, get_active=False) - self.assertEqual(len(dset), 0, 'The dataset should contain 0 files.') + self.assertEqual(len(dset), 0, "The dataset should contain 0 files.") def test_build_dataset(self): with TemporaryDirectory() as tmp_dir: dataset_path = Path(tmp_dir) - os.mkdir(dataset_path / 'web') - shutil.copyfile(self.test_data_dir / 'cc_products_active.csv', dataset_path / 'web' / 'cc_products_active.csv') - shutil.copyfile(self.test_data_dir / 'cc_products_active.html', dataset_path / 'web' / 'cc_products_active.html') - - dset = CCDataset({}, dataset_path, 'sample_dataset', 'sample dataset description') - dset.get_certs_from_web(keep_metadata=False, - to_download=False, - get_archived=False, - get_active=True, - update_json=False) - - self.assertEqual(len(os.listdir(dataset_path)), 0, - 'Meta files (csv, html) were not deleted properly albeit this was explicitly required.') - - self.assertEqual(len(dset), 2, 'The dataset should contain 2 files.') - - self.assertTrue(self.crt_one in dset, 'The dataset does not contain the template sample.') - self.assertEqual(dset, self.template_dataset, 'The loaded dataset does not match the template dataset.') + os.mkdir(dataset_path / "web") + shutil.copyfile( + self.test_data_dir / "cc_products_active.csv", dataset_path / "web" / "cc_products_active.csv" + ) + shutil.copyfile( + self.test_data_dir / "cc_products_active.html", dataset_path / "web" / "cc_products_active.html" + ) + + dset = CCDataset({}, dataset_path, "sample_dataset", "sample dataset description") + dset.get_certs_from_web( + keep_metadata=False, to_download=False, get_archived=False, get_active=True, update_json=False + ) + + self.assertEqual( + len(os.listdir(dataset_path)), + 0, + "Meta files (csv, html) were not deleted properly albeit this was explicitly required.", + ) + + self.assertEqual(len(dset), 2, "The dataset should contain 2 files.") + + self.assertTrue(self.crt_one in dset, "The dataset does not contain the template sample.") + self.assertEqual(dset, self.template_dataset, "The loaded dataset does not match the template dataset.") def test_download_csv_html_files(self): with TemporaryDirectory() as tmp_dir: dataset_path = Path(tmp_dir) - dset = CCDataset({}, dataset_path, 'sample_dataset', 'sample dataset description') + dset = CCDataset({}, dataset_path, "sample_dataset", "sample dataset description") dset.download_csv_html_resources(get_active=True, get_archived=False) for x in dset.active_html_tuples: @@ -187,4 +236,6 @@ class TestCommonCriteriaOOP(TestCase): self.template_dataset.root_dir = tmp_dir self.template_dataset.process_protection_profiles() self.assertTrue(self.template_dataset.pp_dataset_path.exists()) - self.assertGreaterEqual(self.template_dataset.pp_dataset_path.stat().st_size, constants.MIN_CC_PP_DATASET_SIZE) \ No newline at end of file + self.assertGreaterEqual( + self.template_dataset.pp_dataset_path.stat().st_size, constants.MIN_CC_PP_DATASET_SIZE + ) diff --git a/tests/test_cc_txt_processing.py b/tests/test_cc_txt_processing.py index 01b2212b..96716fbe 100644 --- a/tests/test_cc_txt_processing.py +++ b/tests/test_cc_txt_processing.py @@ -10,7 +10,7 @@ from sec_certs.sample.common_criteria import CommonCriteriaCert class TestCommonCriteriaHeuristics(TestCase): - dataset_json_path: ClassVar[Path] = Path(tests.data.test_cc_heuristics.__path__[0]) / 'vulnerable_dataset.json' + dataset_json_path: ClassVar[Path] = Path(tests.data.test_cc_heuristics.__path__[0]) / "vulnerable_dataset.json" data_dir_path: ClassVar[Path] = dataset_json_path.parent @classmethod @@ -18,7 +18,7 @@ class TestCommonCriteriaHeuristics(TestCase): cls.tmp_dir: ClassVar[tempfile.TemporaryDirectory] = tempfile.TemporaryDirectory() shutil.copytree(cls.data_dir_path, cls.tmp_dir.name, dirs_exist_ok=True) - cls.cc_dset: CCDataset = CCDataset.from_json(Path(cls.tmp_dir.name) / 'vulnerable_dataset.json') + cls.cc_dset: CCDataset = CCDataset.from_json(Path(cls.tmp_dir.name) / "vulnerable_dataset.json") cls.cc_dset.download_all_pdfs() cls.cc_dset.convert_all_pdfs() diff --git a/tests/test_fips_oop.py b/tests/test_fips_oop.py index 4d858edb..c39558b6 100644 --- a/tests/test_fips_oop.py +++ b/tests/test_fips_oop.py @@ -13,9 +13,9 @@ import tests.data.test_fips_oop def _set_up_dataset(td, certs): - dataset = FIPSDataset({}, Path(td), 'test_dataset', 'fips_test_dataset') - generate_html(certs, td + '/test_search.html') - dataset.get_certs_from_web(test=td + '/test_search.html', no_download_algorithms=True) + dataset = FIPSDataset({}, Path(td), "test_dataset", "fips_test_dataset") + generate_html(certs, td + "/test_search.html") + dataset.get_certs_from_web(test=td + "/test_search.html", no_download_algorithms=True) return dataset @@ -31,25 +31,76 @@ def _set_up_dataset_for_full(td, certs, cpe_dset_path: Union[str, Path] = None, dataset.convert_all_pdfs() dataset.pdf_scan() dataset.extract_certs_from_tables(high_precision=True) - dataset.algorithms = FIPSAlgorithmDataset.from_json(Path(__file__).parent / 'data/test_fips_oop/algorithms.json') + dataset.algorithms = FIPSAlgorithmDataset.from_json(Path(__file__).parent / "data/test_fips_oop/algorithms.json") dataset.finalize_results(use_nist_cpe_matching_dict=False, perform_cpe_heuristics=False) return dataset class TestFipsOOP(TestCase): data_dir: Final[Path] = Path(tests.data.test_fips_oop.__path__[0]) - cpe_dset_path: Final[Path] = data_dir.parent / 'test_cc_heuristics/auxillary_datasets/cpe_dataset.json' - cve_dset_path: Final[Path] = data_dir.parent / 'test_cc_heuristics/auxillary_datasets/cve_dataset.json' + cpe_dset_path: Final[Path] = data_dir.parent / "test_cc_heuristics/auxillary_datasets/cpe_dataset.json" + cve_dset_path: Final[Path] = data_dir.parent / "test_cc_heuristics/auxillary_datasets/cve_dataset.json" certs_to_parse: Final[Dict[str, List[str]]] = { - 'microsoft': ['3095', '3651', '3093', '3090', '3197', '3196', '3089', '3195', '3480', '3615', '3194', '3091', '3690', '3644', '3527', '3094', '3544', '3096', '3092'], - 'redhat': ['2630', '2721', '2997', '2441', '2711', '2633', '2798', '3613', '3733', '2908', '2446', '2742', '2447'], - 'docusign': ['3850', '2779', '2860', '2665', '1883', '3518', '3141', '2590'], - 'referencing_openssl': ['3493', '3495', '3711', '3176', '3488', '3126', '3269', '3524', '3220', '2398', '3543', '2676', '3313', '3363', '3608', '3158'] + "microsoft": [ + "3095", + "3651", + "3093", + "3090", + "3197", + "3196", + "3089", + "3195", + "3480", + "3615", + "3194", + "3091", + "3690", + "3644", + "3527", + "3094", + "3544", + "3096", + "3092", + ], + "redhat": [ + "2630", + "2721", + "2997", + "2441", + "2711", + "2633", + "2798", + "3613", + "3733", + "2908", + "2446", + "2742", + "2447", + ], + "docusign": ["3850", "2779", "2860", "2665", "1883", "3518", "3141", "2590"], + "referencing_openssl": [ + "3493", + "3495", + "3711", + "3176", + "3488", + "3126", + "3269", + "3524", + "3220", + "2398", + "3543", + "2676", + "3313", + "3363", + "3608", + "3158", + ], } @classmethod def setUpClass(cls) -> None: - config.load(cls.data_dir.parent / 'settings_test.yaml') + config.load(cls.data_dir.parent / "settings_test.yaml") def test_size(self): for certs in self.certs_to_parse.values(): @@ -58,82 +109,88 @@ class TestFipsOOP(TestCase): self.assertEqual(len(dataset.certs), len(certs), "Wrong number of parsed certs") def test_connections_microsoft(self): - certs = self.certs_to_parse['microsoft'] + certs = self.certs_to_parse["microsoft"] with TemporaryDirectory() as tmp_dir: dataset = _set_up_dataset_for_full(tmp_dir, certs, self.cpe_dset_path, self.cve_dset_path) - self.assertEqual(set(dataset.certs['3095'].heuristics.connections), {'3093', '3096', '3094'}) - self.assertEqual(set(dataset.certs['3651'].heuristics.connections), {'3615'}) - self.assertEqual(set(dataset.certs['3093'].heuristics.connections), {'3090', '3091'}) - self.assertEqual(set(dataset.certs['3090'].heuristics.connections), {'3089'}) - self.assertEqual(set(dataset.certs['3197'].heuristics.connections), {x for x in ['3195', '3096', '3196', '3644', '3651']}) - self.assertEqual(set(dataset.certs['3196'].heuristics.connections), {x for x in ['3194', '3091', '3480', '3615']}) - self.assertEqual(set(dataset.certs['3089'].heuristics.connections), set()) - self.assertEqual(set(dataset.certs['3195'].heuristics.connections), {'3194', '3091', '3480'}) - self.assertEqual(set(dataset.certs['3480'].heuristics.connections), {'3089'}) - self.assertEqual(set(dataset.certs['3615'].heuristics.connections), {'3089'}) - self.assertEqual(set(dataset.certs['3194'].heuristics.connections), {'3089'}) - self.assertEqual(set(dataset.certs['3091'].heuristics.connections), {'3089'}) - self.assertEqual(set(dataset.certs['3690'].heuristics.connections), {'3644', '3196', '3651'}) - self.assertEqual(set(dataset.certs['3644'].heuristics.connections), {'3615'}) - self.assertEqual(set(dataset.certs['3527'].heuristics.connections), {'3090', '3091'}) - self.assertEqual(set(dataset.certs['3094'].heuristics.connections), {'3090', '3091'}) - self.assertEqual(set(dataset.certs['3544'].heuristics.connections), {'3093', '3096', '3527'}) - self.assertEqual(set(dataset.certs['3096'].heuristics.connections), {'3090', '3194', '3091', '3480'}) - self.assertEqual(set(dataset.certs['3092'].heuristics.connections), {'3093', '3195', '3096', '3644', '3651'}) + self.assertEqual(set(dataset.certs["3095"].heuristics.connections), {"3093", "3096", "3094"}) + self.assertEqual(set(dataset.certs["3651"].heuristics.connections), {"3615"}) + self.assertEqual(set(dataset.certs["3093"].heuristics.connections), {"3090", "3091"}) + self.assertEqual(set(dataset.certs["3090"].heuristics.connections), {"3089"}) + self.assertEqual( + set(dataset.certs["3197"].heuristics.connections), {x for x in ["3195", "3096", "3196", "3644", "3651"]} + ) + self.assertEqual( + set(dataset.certs["3196"].heuristics.connections), {x for x in ["3194", "3091", "3480", "3615"]} + ) + self.assertEqual(set(dataset.certs["3089"].heuristics.connections), set()) + self.assertEqual(set(dataset.certs["3195"].heuristics.connections), {"3194", "3091", "3480"}) + self.assertEqual(set(dataset.certs["3480"].heuristics.connections), {"3089"}) + self.assertEqual(set(dataset.certs["3615"].heuristics.connections), {"3089"}) + self.assertEqual(set(dataset.certs["3194"].heuristics.connections), {"3089"}) + self.assertEqual(set(dataset.certs["3091"].heuristics.connections), {"3089"}) + self.assertEqual(set(dataset.certs["3690"].heuristics.connections), {"3644", "3196", "3651"}) + self.assertEqual(set(dataset.certs["3644"].heuristics.connections), {"3615"}) + self.assertEqual(set(dataset.certs["3527"].heuristics.connections), {"3090", "3091"}) + self.assertEqual(set(dataset.certs["3094"].heuristics.connections), {"3090", "3091"}) + self.assertEqual(set(dataset.certs["3544"].heuristics.connections), {"3093", "3096", "3527"}) + self.assertEqual(set(dataset.certs["3096"].heuristics.connections), {"3090", "3194", "3091", "3480"}) + self.assertEqual( + set(dataset.certs["3092"].heuristics.connections), {"3093", "3195", "3096", "3644", "3651"} + ) def test_connections_redhat(self): - certs = self.certs_to_parse['redhat'] + certs = self.certs_to_parse["redhat"] with TemporaryDirectory() as tmp_dir: dataset = _set_up_dataset_for_full(tmp_dir, certs, self.cpe_dset_path, self.cve_dset_path) - self.assertEqual(set(dataset.certs['2630'].heuristics.connections), {'2441'}) - self.assertEqual(set(dataset.certs['2633'].heuristics.connections), {'2441'}) - self.assertEqual(set(dataset.certs['2441'].heuristics.connections), set()) - self.assertEqual(set(dataset.certs['2997'].heuristics.connections), {'2711'}) - self.assertEqual(set(dataset.certs['2446'].heuristics.connections), {'2441'}) - self.assertEqual(set(dataset.certs['2447'].heuristics.connections), {'2441'}) - self.assertEqual(set(dataset.certs['3733'].heuristics.connections), {'2441'}) - self.assertEqual(set(dataset.certs['2441'].heuristics.connections), set()) - self.assertEqual(set(dataset.certs['2711'].heuristics.connections), set()) - self.assertEqual(set(dataset.certs['2908'].heuristics.connections), {'2711'}) - self.assertEqual(set(dataset.certs['3613'].heuristics.connections), {'2997'}) - self.assertEqual(set(dataset.certs['2721'].heuristics.connections), {'2441', '2711'}) - self.assertEqual(set(dataset.certs['2798'].heuristics.connections), {'2721', '2711'}) - self.assertEqual(set(dataset.certs['2711'].heuristics.connections), set()) - self.assertEqual(set(dataset.certs['2997'].heuristics.connections), {'2711'}) - self.assertEqual(set(dataset.certs['2742'].heuristics.connections), {'2721', '2711'}) - self.assertEqual(set(dataset.certs['2721'].heuristics.connections), {'2441', '2711'}) + self.assertEqual(set(dataset.certs["2630"].heuristics.connections), {"2441"}) + self.assertEqual(set(dataset.certs["2633"].heuristics.connections), {"2441"}) + self.assertEqual(set(dataset.certs["2441"].heuristics.connections), set()) + self.assertEqual(set(dataset.certs["2997"].heuristics.connections), {"2711"}) + self.assertEqual(set(dataset.certs["2446"].heuristics.connections), {"2441"}) + self.assertEqual(set(dataset.certs["2447"].heuristics.connections), {"2441"}) + self.assertEqual(set(dataset.certs["3733"].heuristics.connections), {"2441"}) + self.assertEqual(set(dataset.certs["2441"].heuristics.connections), set()) + self.assertEqual(set(dataset.certs["2711"].heuristics.connections), set()) + self.assertEqual(set(dataset.certs["2908"].heuristics.connections), {"2711"}) + self.assertEqual(set(dataset.certs["3613"].heuristics.connections), {"2997"}) + self.assertEqual(set(dataset.certs["2721"].heuristics.connections), {"2441", "2711"}) + self.assertEqual(set(dataset.certs["2798"].heuristics.connections), {"2721", "2711"}) + self.assertEqual(set(dataset.certs["2711"].heuristics.connections), set()) + self.assertEqual(set(dataset.certs["2997"].heuristics.connections), {"2711"}) + self.assertEqual(set(dataset.certs["2742"].heuristics.connections), {"2721", "2711"}) + self.assertEqual(set(dataset.certs["2721"].heuristics.connections), {"2441", "2711"}) def test_docusign_chunk(self): - certs = self.certs_to_parse['docusign'] + certs = self.certs_to_parse["docusign"] with TemporaryDirectory() as tmp_dir: dataset = _set_up_dataset_for_full(tmp_dir, certs, self.cpe_dset_path, self.cve_dset_path) - self.assertEqual(set(dataset.certs['3850'].heuristics.connections), {'3518', '1883'}) - self.assertEqual(set(dataset.certs['2779'].heuristics.connections), {'1883'}) - self.assertEqual(set(dataset.certs['2860'].heuristics.connections), {'1883'}) - self.assertEqual(set(dataset.certs['2665'].heuristics.connections), {'1883'}) - self.assertEqual(set(dataset.certs['1883'].heuristics.connections), set()) - self.assertEqual(set(dataset.certs['3518'].heuristics.connections), {'1883'}) - self.assertEqual(set(dataset.certs['3141'].heuristics.connections), {'1883'}) - self.assertEqual(set(dataset.certs['2590'].heuristics.connections), {'1883'}) + self.assertEqual(set(dataset.certs["3850"].heuristics.connections), {"3518", "1883"}) + self.assertEqual(set(dataset.certs["2779"].heuristics.connections), {"1883"}) + self.assertEqual(set(dataset.certs["2860"].heuristics.connections), {"1883"}) + self.assertEqual(set(dataset.certs["2665"].heuristics.connections), {"1883"}) + self.assertEqual(set(dataset.certs["1883"].heuristics.connections), set()) + self.assertEqual(set(dataset.certs["3518"].heuristics.connections), {"1883"}) + self.assertEqual(set(dataset.certs["3141"].heuristics.connections), {"1883"}) + self.assertEqual(set(dataset.certs["2590"].heuristics.connections), {"1883"}) def test_openssl_chunk(self): - certs = self.certs_to_parse['referencing_openssl'] + certs = self.certs_to_parse["referencing_openssl"] with TemporaryDirectory() as tmp_dir: dataset = _set_up_dataset_for_full(tmp_dir, certs, self.cpe_dset_path, self.cve_dset_path) - self.assertEqual(set(dataset.certs['3493'].heuristics.connections), {'2398'}) - self.assertEqual(set(dataset.certs['3495'].heuristics.connections), {'2398'}) - self.assertEqual(set(dataset.certs['3711'].heuristics.connections), {'3220'}) - self.assertEqual(set(dataset.certs['3176'].heuristics.connections), {'2398'}) - self.assertEqual(set(dataset.certs['3488'].heuristics.connections), {'2398'}) - self.assertEqual(set(dataset.certs['3126'].heuristics.connections), {'3126', '2398'}) - self.assertEqual(set(dataset.certs['3269'].heuristics.connections), {'3269', '3220'}) - self.assertEqual(set(dataset.certs['3524'].heuristics.connections), {'3220'}) - self.assertEqual(set(dataset.certs['3220'].heuristics.connections), {'3220', '2398'}) - self.assertEqual(set(dataset.certs['2398'].heuristics.connections), set()) - self.assertEqual(set(dataset.certs['3543'].heuristics.connections), {'2398'}) - self.assertEqual(set(dataset.certs['2676'].heuristics.connections), {'2398'}) - self.assertEqual(set(dataset.certs['3313'].heuristics.connections), {'3313', '3220'}) - self.assertEqual(set(dataset.certs['3363'].heuristics.connections), set()) - self.assertEqual(set(dataset.certs['3608'].heuristics.connections), {'2398'}) - self.assertEqual(set(dataset.certs['3158'].heuristics.connections), {'2398'}) + self.assertEqual(set(dataset.certs["3493"].heuristics.connections), {"2398"}) + self.assertEqual(set(dataset.certs["3495"].heuristics.connections), {"2398"}) + self.assertEqual(set(dataset.certs["3711"].heuristics.connections), {"3220"}) + self.assertEqual(set(dataset.certs["3176"].heuristics.connections), {"2398"}) + self.assertEqual(set(dataset.certs["3488"].heuristics.connections), {"2398"}) + self.assertEqual(set(dataset.certs["3126"].heuristics.connections), {"3126", "2398"}) + self.assertEqual(set(dataset.certs["3269"].heuristics.connections), {"3269", "3220"}) + self.assertEqual(set(dataset.certs["3524"].heuristics.connections), {"3220"}) + self.assertEqual(set(dataset.certs["3220"].heuristics.connections), {"3220", "2398"}) + self.assertEqual(set(dataset.certs["2398"].heuristics.connections), set()) + self.assertEqual(set(dataset.certs["3543"].heuristics.connections), {"2398"}) + self.assertEqual(set(dataset.certs["2676"].heuristics.connections), {"2398"}) + self.assertEqual(set(dataset.certs["3313"].heuristics.connections), {"3313", "3220"}) + self.assertEqual(set(dataset.certs["3363"].heuristics.connections), set()) + self.assertEqual(set(dataset.certs["3608"].heuristics.connections), {"2398"}) + self.assertEqual(set(dataset.certs["3158"].heuristics.connections), {"2398"}) -- cgit v1.3.1 From 6e980798f0e51ac2b581aa79c8d314a3c935b4c5 Mon Sep 17 00:00:00 2001 From: Adam Janovsky Date: Sat, 18 Dec 2021 14:18:46 +0100 Subject: sort imports --- cc_cli.py | 7 ++--- examples/cc_cpe_labeling.py | 6 ++--- examples/cc_oop_demo.py | 6 ++--- examples/fips_cpe_labeling.py | 7 ++--- examples/fips_oop_demo.py | 9 ++++--- fips_cli.py | 11 ++++---- pyproject.toml | 3 ++- sec_certs/config/configuration.py | 7 ++--- sec_certs/dataset/common_criteria.py | 24 ++++++++++------- sec_certs/dataset/cpe.py | 16 +++++------ sec_certs/dataset/cve.py | 23 ++++++++-------- sec_certs/dataset/dataset.py | 20 +++++++------- sec_certs/dataset/fips.py | 13 ++++----- sec_certs/dataset/fips_algorithm.py | 13 ++++----- sec_certs/dataset/protection_profile.py | 6 ++--- sec_certs/helpers.py | 44 +++++++++++++------------------ sec_certs/model/cpe_matching.py | 18 +++++++------ sec_certs/model/dependency_finder.py | 3 ++- sec_certs/model/evaluation.py | 12 ++++----- sec_certs/parallel_processing.py | 7 ++--- sec_certs/sample/cc_maintenance_update.py | 2 +- sec_certs/sample/certificate.py | 14 +++++----- sec_certs/sample/common_criteria.py | 10 +++---- sec_certs/sample/cpe.py | 3 ++- sec_certs/sample/cve.py | 4 +-- sec_certs/sample/fips.py | 21 ++++++++------- sec_certs/sample/protection_profile.py | 7 +++-- sec_certs/serialization/json.py | 4 +-- setup.py | 2 +- tests/fips_test_utils.py | 2 +- tests/test_cc_heuristics.py | 16 +++++------ tests/test_cc_oop.py | 18 ++++++------- tests/test_cc_txt_processing.py | 8 +++--- tests/test_fips_oop.py | 11 ++++---- 34 files changed, 193 insertions(+), 184 deletions(-) (limited to 'tests') diff --git a/cc_cli.py b/cc_cli.py index 33077e06..bd9e586b 100755 --- a/cc_cli.py +++ b/cc_cli.py @@ -1,10 +1,11 @@ #!/usr/bin/env python3 -from typing import Optional, List -import click -from pathlib import Path import logging import sys from datetime import datetime +from pathlib import Path +from typing import List, Optional + +import click from sec_certs.config.configuration import config from sec_certs.dataset.common_criteria import CCDataset diff --git a/examples/cc_cpe_labeling.py b/examples/cc_cpe_labeling.py index c3ead2ef..89527bbe 100644 --- a/examples/cc_cpe_labeling.py +++ b/examples/cc_cpe_labeling.py @@ -1,10 +1,10 @@ -from datetime import datetime import logging +from datetime import datetime from pathlib import Path -from sec_certs.dataset.common_criteria import CCDataset from sec_certs.config.configuration import config -from sec_certs.model.evaluation import get_validation_dgsts, evaluate +from sec_certs.dataset.common_criteria import CCDataset +from sec_certs.model.evaluation import evaluate, get_validation_dgsts logger = logging.getLogger(__name__) diff --git a/examples/cc_oop_demo.py b/examples/cc_oop_demo.py index a30d63ce..60949cd1 100644 --- a/examples/cc_oop_demo.py +++ b/examples/cc_oop_demo.py @@ -1,9 +1,9 @@ -from pathlib import Path -from datetime import datetime import logging +from datetime import datetime +from pathlib import Path -from sec_certs.dataset.common_criteria import CCDataset from sec_certs.config.configuration import config +from sec_certs.dataset.common_criteria import CCDataset logger = logging.getLogger(__name__) diff --git a/examples/fips_cpe_labeling.py b/examples/fips_cpe_labeling.py index 4aebe902..8b2d99d2 100644 --- a/examples/fips_cpe_labeling.py +++ b/examples/fips_cpe_labeling.py @@ -1,8 +1,9 @@ -from datetime import datetime import logging -from sec_certs.dataset.fips import FIPSDataset +from datetime import datetime from pathlib import Path -from sec_certs.model.evaluation import get_validation_dgsts, evaluate + +from sec_certs.dataset.fips import FIPSDataset +from sec_certs.model.evaluation import evaluate, get_validation_dgsts logger = logging.getLogger(__name__) diff --git a/examples/fips_oop_demo.py b/examples/fips_oop_demo.py index 1f13dc2a..a84b1ac9 100644 --- a/examples/fips_oop_demo.py +++ b/examples/fips_oop_demo.py @@ -1,11 +1,12 @@ -from pathlib import Path -from datetime import datetime import logging +from datetime import datetime +from pathlib import Path + import click + +from sec_certs.config.configuration import config from sec_certs.dataset.fips import FIPSDataset from sec_certs.dataset.fips_algorithm import FIPSAlgorithmDataset -from sec_certs.config.configuration import config - logger = logging.getLogger(__name__) diff --git a/fips_cli.py b/fips_cli.py index 4336a9bb..b1bca9c2 100755 --- a/fips_cli.py +++ b/fips_cli.py @@ -1,13 +1,14 @@ #!/usr/bin/env python3 -from typing import Optional, List, Set -import click -from pathlib import Path import logging -import sys import os +import sys from datetime import datetime +from pathlib import Path +from typing import List, Optional, Set + +import click -from sec_certs.config.configuration import config, DEFAULT_CONFIG_PATH +from sec_certs.config.configuration import DEFAULT_CONFIG_PATH, config from sec_certs.dataset.fips import FIPSDataset logger = logging.getLogger(__name__) diff --git a/pyproject.toml b/pyproject.toml index 2fc133c9..e51b5a9b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,7 +15,8 @@ exclude = ''' ''' [tool.isort] -profile = "black" +profile = "black" +skip = ["certsvenv"] [tool.mypy] plugins = ["numpy.typing.mypy_plugin"] diff --git a/sec_certs/config/configuration.py b/sec_certs/config/configuration.py index cafb2b23..d06f2e41 100644 --- a/sec_certs/config/configuration.py +++ b/sec_certs/config/configuration.py @@ -1,8 +1,9 @@ -import yaml -from typing import Union +import json from pathlib import Path +from typing import Union + import jsonschema -import json +import yaml class Configuration(object): diff --git a/sec_certs/dataset/common_criteria.py b/sec_certs/dataset/common_criteria.py index 68a5d8bf..bc488d17 100644 --- a/sec_certs/dataset/common_criteria.py +++ b/sec_certs/dataset/common_criteria.py @@ -1,28 +1,32 @@ import copy import itertools +import json import locale import shutil import tempfile from dataclasses import dataclass from datetime import datetime from pathlib import Path -from typing import Dict, Iterator, Optional, Set, Union, List, Tuple, Mapping, ClassVar -import json +from typing import (ClassVar, Dict, Iterator, List, Mapping, Optional, Set, + Tuple, Union) import numpy as np import pandas as pd -from bs4 import Tag, BeautifulSoup +from bs4 import BeautifulSoup, Tag -from sec_certs import helpers as helpers, parallel_processing as cert_processing +from sec_certs import helpers as helpers +from sec_certs import parallel_processing as cert_processing +from sec_certs.config.configuration import config from sec_certs.dataset.dataset import Dataset, logger -from sec_certs.serialization.json import ComplexSerializableType, serialize, CustomJSONDecoder -from sec_certs.sample.common_criteria import CommonCriteriaCert -from sec_certs.sample.certificate import Certificate from sec_certs.dataset.protection_profile import ProtectionProfileDataset -from sec_certs.sample.protection_profile import ProtectionProfile -from sec_certs.sample.cc_maintenance_update import CommonCriteriaMaintenanceUpdate -from sec_certs.config.configuration import config from sec_certs.model.dependency_finder import DependencyFinder +from sec_certs.sample.cc_maintenance_update import \ + CommonCriteriaMaintenanceUpdate +from sec_certs.sample.certificate import Certificate +from sec_certs.sample.common_criteria import CommonCriteriaCert +from sec_certs.sample.protection_profile import ProtectionProfile +from sec_certs.serialization.json import (ComplexSerializableType, + CustomJSONDecoder, serialize) class CCDataset(Dataset, ComplexSerializableType): diff --git a/sec_certs/dataset/cpe.py b/sec_certs/dataset/cpe.py index 8ad514d8..6727f930 100644 --- a/sec_certs/dataset/cpe.py +++ b/sec_certs/dataset/cpe.py @@ -1,19 +1,19 @@ -from dataclasses import dataclass, field -import logging -from typing import List, Dict, Tuple, Set, Union, ClassVar import itertools +import logging import tempfile -from pathlib import Path +import xml.etree.ElementTree as ET import zipfile +from dataclasses import dataclass, field +from pathlib import Path +from typing import ClassVar, Dict, List, Set, Tuple, Union + +import pandas as pd import sec_certs.helpers as helpers -from sec_certs.sample.cpe import CPE from sec_certs.dataset.cve import CVEDataset +from sec_certs.sample.cpe import CPE from sec_certs.serialization.json import ComplexSerializableType, serialize -import pandas as pd -import xml.etree.ElementTree as ET - logger = logging.getLogger(__name__) diff --git a/sec_certs/dataset/cve.py b/sec_certs/dataset/cve.py index e61e49d6..f143cad6 100644 --- a/sec_certs/dataset/cve.py +++ b/sec_certs/dataset/cve.py @@ -1,24 +1,25 @@ -import itertools -from dataclasses import dataclass, field -from typing import Dict, List, Optional, Tuple, Union, Final, Set import datetime -from pathlib import Path -import tempfile -import zipfile -import logging import glob +import itertools import json +import logging import shutil +import tempfile +import zipfile +from dataclasses import dataclass, field +from pathlib import Path +from typing import Dict, Final, List, Optional, Set, Tuple, Union import pandas as pd -from sec_certs.parallel_processing import process_parallel import sec_certs.constants as constants import sec_certs.helpers as helpers -from sec_certs.sample.cve import CVE -from sec_certs.sample.cpe import CPE -from sec_certs.serialization.json import ComplexSerializableType, CustomJSONDecoder, CustomJSONEncoder from sec_certs.config.configuration import config +from sec_certs.parallel_processing import process_parallel +from sec_certs.sample.cpe import CPE +from sec_certs.sample.cve import CVE +from sec_certs.serialization.json import (ComplexSerializableType, + CustomJSONDecoder, CustomJSONEncoder) logger = logging.getLogger(__name__) diff --git a/sec_certs/dataset/dataset.py b/sec_certs/dataset/dataset.py index 9078d30e..63a781fb 100644 --- a/sec_certs/dataset/dataset.py +++ b/sec_certs/dataset/dataset.py @@ -1,26 +1,24 @@ -from datetime import datetime -import logging -from typing import Dict, Collection, Optional, Set, Union, List, Tuple, Mapping, TypeVar - +import itertools import json +import logging from abc import ABC, abstractmethod +from datetime import datetime from pathlib import Path -import itertools +from typing import (Collection, Dict, List, Mapping, Optional, Set, Tuple, + TypeVar, Union) import requests -import sec_certs.helpers as helpers import sec_certs.constants as constants +import sec_certs.helpers as helpers import sec_certs.parallel_processing as cert_processing -from sec_certs.sample.cpe import CPE - -from sec_certs.sample.certificate import Certificate -from sec_certs.serialization.json import ComplexSerializableType from sec_certs.config.configuration import config -from sec_certs.serialization.json import serialize from sec_certs.dataset.cpe import CPEDataset from sec_certs.dataset.cve import CVEDataset from sec_certs.model.cpe_matching import CPEClassifier +from sec_certs.sample.certificate import Certificate +from sec_certs.sample.cpe import CPE +from sec_certs.serialization.json import ComplexSerializableType, serialize logger = logging.getLogger(__name__) diff --git a/sec_certs/dataset/fips.py b/sec_certs/dataset/fips.py index 60a0543a..cea42eeb 100644 --- a/sec_certs/dataset/fips.py +++ b/sec_certs/dataset/fips.py @@ -1,22 +1,23 @@ import datetime -import tempfile import logging import os +import tempfile from itertools import groupby from pathlib import Path +from typing import Dict, List, Mapping, Optional, Set, Tuple -from typing import Set, Tuple, List, Dict, Optional, Mapping from bs4 import BeautifulSoup, NavigableString from graphviz import Digraph -from sec_certs import constants as constants, parallel_processing as cert_processing, helpers as helpers +from sec_certs import constants as constants +from sec_certs import helpers as helpers +from sec_certs import parallel_processing as cert_processing from sec_certs.config.configuration import config -from sec_certs.sample.certificate import Certificate from sec_certs.dataset.dataset import Dataset, logger from sec_certs.dataset.fips_algorithm import FIPSAlgorithmDataset -from sec_certs.serialization.json import ComplexSerializableType, serialize +from sec_certs.sample.certificate import Certificate from sec_certs.sample.fips import FIPSCertificate - +from sec_certs.serialization.json import ComplexSerializableType, serialize logger = logging.getLogger(__name__) diff --git a/sec_certs/dataset/fips_algorithm.py b/sec_certs/dataset/fips_algorithm.py index e4fbc987..a6ec381e 100644 --- a/sec_certs/dataset/fips_algorithm.py +++ b/sec_certs/dataset/fips_algorithm.py @@ -1,17 +1,18 @@ import json import logging from pathlib import Path -from typing import Dict, Union, List +from typing import Dict, List, Union from bs4 import BeautifulSoup -from sec_certs import helpers as helpers, constants as constants, parallel_processing as cert_processing +from sec_certs import constants as constants +from sec_certs import helpers as helpers +from sec_certs import parallel_processing as cert_processing +from sec_certs.config.configuration import config from sec_certs.dataset.dataset import Dataset -from sec_certs.serialization.json import ComplexSerializableType, CustomJSONEncoder, CustomJSONDecoder - from sec_certs.sample.fips import FIPSCertificate -from sec_certs.config.configuration import config - +from sec_certs.serialization.json import (ComplexSerializableType, + CustomJSONDecoder, CustomJSONEncoder) logger = logging.getLogger(__name__) diff --git a/sec_certs/dataset/protection_profile.py b/sec_certs/dataset/protection_profile.py index 6a3afecc..bab82fb0 100644 --- a/sec_certs/dataset/protection_profile.py +++ b/sec_certs/dataset/protection_profile.py @@ -1,9 +1,9 @@ -from dataclasses import dataclass -from typing import Dict, Tuple, Union, Optional, ClassVar -from pathlib import Path import json import logging import tempfile +from dataclasses import dataclass +from pathlib import Path +from typing import ClassVar, Dict, Optional, Tuple, Union import sec_certs.helpers as helpers from sec_certs.sample.protection_profile import ProtectionProfile diff --git a/sec_certs/helpers.py b/sec_certs/helpers.py index b6cdff84..60775915 100644 --- a/sec_certs/helpers.py +++ b/sec_certs/helpers.py @@ -1,40 +1,34 @@ +import copy +import hashlib +import html +import logging import os import re -from typing import Sequence, Tuple, Optional, Set, List, Dict, Hashable, Any -import logging -import pikepdf -import requests +import subprocess +import time +from datetime import date +from enum import Enum from multiprocessing.pool import ThreadPool from pathlib import Path -from tqdm import tqdm as tqdm_original -import hashlib -import html -from typing import Union, List -from datetime import date +from typing import (Any, Dict, Hashable, List, Optional, Sequence, Set, Tuple, + Union) + +import matplotlib.pyplot as plt import numpy as np import pandas as pd -import subprocess -import time -import copy +import pikepdf +import requests from packaging.version import VERSION_PATTERN - - -from enum import Enum -import matplotlib.pyplot as plt from PyPDF2 import PdfFileReader +from tqdm import tqdm as tqdm_original -import sec_certs.constants import sec_certs.constants as constants -from sec_certs.config.configuration import config from sec_certs.cert_rules import REGEXEC_SEP from sec_certs.cert_rules import rules as cc_search_rules -from sec_certs.constants import ( - TAG_MATCH_COUNTER, - APPEND_DETAILED_MATCH_MATCHES, - TAG_MATCH_MATCHES, - FILE_ERRORS_STRATEGY, - LINE_SEPARATOR, -) +from sec_certs.config.configuration import config +from sec_certs.constants import (APPEND_DETAILED_MATCH_MATCHES, + FILE_ERRORS_STRATEGY, LINE_SEPARATOR, + TAG_MATCH_COUNTER, TAG_MATCH_MATCHES) logger = logging.getLogger(__name__) diff --git a/sec_certs/model/cpe_matching.py b/sec_certs/model/cpe_matching.py index dae6c558..042f6705 100644 --- a/sec_certs/model/cpe_matching.py +++ b/sec_certs/model/cpe_matching.py @@ -1,15 +1,17 @@ -from sklearn.base import BaseEstimator -from typing import Dict, Tuple, Set, List, Optional, Union -from sec_certs.sample.cpe import CPE -import sec_certs.helpers as helpers import itertools -import re -from rapidfuzz import process, fuzz -import operator -from pathlib import Path import json import logging +import operator +import re +from pathlib import Path +from typing import Dict, List, Optional, Set, Tuple, Union + from packaging.version import parse +from rapidfuzz import fuzz, process +from sklearn.base import BaseEstimator + +import sec_certs.helpers as helpers +from sec_certs.sample.cpe import CPE logger = logging.getLogger(__name__) diff --git a/sec_certs/model/dependency_finder.py b/sec_certs/model/dependency_finder.py index 6afcf7ef..07ccb199 100644 --- a/sec_certs/model/dependency_finder.py +++ b/sec_certs/model/dependency_finder.py @@ -1,4 +1,5 @@ -from typing import List, Set, Dict, Tuple, Union, Optional +from typing import Dict, List, Optional, Set, Tuple, Union + from sec_certs.sample.common_criteria import CommonCriteriaCert Certificates = Dict[str, CommonCriteriaCert] diff --git a/sec_certs/model/evaluation.py b/sec_certs/model/evaluation.py index 4eaeea6a..0ef23dd9 100644 --- a/sec_certs/model/evaluation.py +++ b/sec_certs/model/evaluation.py @@ -1,15 +1,15 @@ import json -from pathlib import Path import logging -from typing import List, Set, Union, Optional +from pathlib import Path +from typing import List, Optional, Set, Union +import numpy as np + +import sec_certs.helpers as helpers +from sec_certs.dataset.cpe import CPEDataset from sec_certs.sample.common_criteria import CommonCriteriaCert from sec_certs.sample.fips import FIPSCertificate -from sec_certs.dataset.cpe import CPEDataset from sec_certs.serialization.json import CustomJSONEncoder -import sec_certs.helpers as helpers - -import numpy as np logger = logging.getLogger(__name__) diff --git a/sec_certs/parallel_processing.py b/sec_certs/parallel_processing.py index 28d94914..3bfa2826 100644 --- a/sec_certs/parallel_processing.py +++ b/sec_certs/parallel_processing.py @@ -1,8 +1,9 @@ -from sec_certs.helpers import tqdm +import time from multiprocessing.pool import ThreadPool -from billiard.pool import Pool from typing import Callable, Iterable, Optional, Union -import time + +from billiard.pool import Pool +from sec_certs.helpers import tqdm def process_parallel( diff --git a/sec_certs/sample/cc_maintenance_update.py b/sec_certs/sample/cc_maintenance_update.py index 2ed939c7..fa4012e3 100644 --- a/sec_certs/sample/cc_maintenance_update.py +++ b/sec_certs/sample/cc_maintenance_update.py @@ -1,6 +1,6 @@ import logging -from typing import Optional, Dict, List, ClassVar, Tuple from datetime import date +from typing import ClassVar, Dict, List, Optional, Tuple import sec_certs.helpers as helpers from sec_certs.sample.common_criteria import CommonCriteriaCert diff --git a/sec_certs/sample/certificate.py b/sec_certs/sample/certificate.py index 14c77f2e..991e86a6 100644 --- a/sec_certs/sample/certificate.py +++ b/sec_certs/sample/certificate.py @@ -1,15 +1,15 @@ -import logging -from pathlib import Path import copy -import json import itertools - +import json +import logging from abc import ABC, abstractmethod -from typing import Optional, Union, TypeVar, Type, Any +from pathlib import Path +from typing import Any, Optional, Type, TypeVar, Union -from sec_certs.serialization.json import CustomJSONDecoder, CustomJSONEncoder, ComplexSerializableType -from sec_certs.model.cpe_matching import CPEClassifier from sec_certs.dataset.cve import CVEDataset +from sec_certs.model.cpe_matching import CPEClassifier +from sec_certs.serialization.json import (ComplexSerializableType, + CustomJSONDecoder, CustomJSONEncoder) logger = logging.getLogger(__name__) diff --git a/sec_certs/sample/common_criteria.py b/sec_certs/sample/common_criteria.py index 657477d7..a0c41d13 100644 --- a/sec_certs/sample/common_criteria.py +++ b/sec_certs/sample/common_criteria.py @@ -3,18 +3,18 @@ import operator from dataclasses import dataclass, field from datetime import date, datetime from pathlib import Path -from typing import Optional, List, Dict, Tuple, Union, Any, Set, ClassVar - +from typing import Any, ClassVar, Dict, List, Optional, Set, Tuple, Union import requests from bs4 import Tag -from sec_certs import helpers, constants as constants +from sec_certs import constants as constants +from sec_certs import helpers +from sec_certs.model.cpe_matching import CPEClassifier from sec_certs.sample.certificate import Certificate, logger +from sec_certs.sample.protection_profile import ProtectionProfile from sec_certs.serialization.json import ComplexSerializableType from sec_certs.serialization.pandas import PandasSerializableType -from sec_certs.sample.protection_profile import ProtectionProfile -from sec_certs.model.cpe_matching import CPEClassifier class CommonCriteriaCert(Certificate, PandasSerializableType, ComplexSerializableType): diff --git a/sec_certs/sample/cpe.py b/sec_certs/sample/cpe.py index a67eacbb..1099c144 100644 --- a/sec_certs/sample/cpe.py +++ b/sec_certs/sample/cpe.py @@ -1,5 +1,6 @@ from dataclasses import dataclass -from typing import ClassVar, List, Optional, Tuple, Dict +from typing import ClassVar, Dict, List, Optional, Tuple + from sec_certs.serialization.json import ComplexSerializableType from sec_certs.serialization.pandas import PandasSerializableType diff --git a/sec_certs/sample/cve.py b/sec_certs/sample/cve.py index 58edf1e2..94484374 100644 --- a/sec_certs/sample/cve.py +++ b/sec_certs/sample/cve.py @@ -1,13 +1,13 @@ import datetime import itertools from dataclasses import dataclass -from typing import Any, Dict, List, Optional, ClassVar, Tuple +from typing import Any, ClassVar, Dict, List, Optional, Tuple from dateutil.parser import isoparse +from sec_certs.sample.cpe import CPE from sec_certs.serialization.json import ComplexSerializableType from sec_certs.serialization.pandas import PandasSerializableType -from sec_certs.sample.cpe import CPE @dataclass(init=False) diff --git a/sec_certs/sample/fips.py b/sec_certs/sample/fips.py index 57082218..3a3d2e5a 100644 --- a/sec_certs/sample/fips.py +++ b/sec_certs/sample/fips.py @@ -3,25 +3,26 @@ import re from dataclasses import dataclass, field from datetime import datetime from pathlib import Path -from typing import ClassVar, Dict, Optional, Union, List, Tuple, Set, Pattern +from typing import ClassVar, Dict, List, Optional, Pattern, Set, Tuple, Union import requests -from bs4 import Tag, NavigableString, BeautifulSoup +from bs4 import BeautifulSoup, NavigableString, Tag from dateutil import parser from tabula import read_pdf -import sec_certs.constants -from sec_certs import helpers, constants as constants -from sec_certs.cert_rules import fips_common_rules, REGEXEC_SEP, fips_rules - -from sec_certs.sample.certificate import Certificate, logger +import sec_certs.constants as constants +from sec_certs import constants as constants +from sec_certs import helpers +from sec_certs.cert_rules import REGEXEC_SEP, fips_common_rules, fips_rules from sec_certs.config.configuration import config from sec_certs.constants import LINE_SEPARATOR -from sec_certs.helpers import save_modified_cert_file, normalize_match_string, load_cert_file -from sec_certs.serialization.json import ComplexSerializableType from sec_certs.dataset.cpe import CPEDataset -from sec_certs.sample.cpe import CPE +from sec_certs.helpers import (load_cert_file, normalize_match_string, + save_modified_cert_file) from sec_certs.model.cpe_matching import CPEClassifier +from sec_certs.sample.certificate import Certificate, logger +from sec_certs.sample.cpe import CPE +from sec_certs.serialization.json import ComplexSerializableType class FIPSCertificate(Certificate, ComplexSerializableType): diff --git a/sec_certs/sample/protection_profile.py b/sec_certs/sample/protection_profile.py index 05dab814..6ce2d00e 100644 --- a/sec_certs/sample/protection_profile.py +++ b/sec_certs/sample/protection_profile.py @@ -1,11 +1,10 @@ -from dataclasses import dataclass -from typing import Optional, FrozenSet import copy -from typing import Dict import logging +from dataclasses import dataclass +from typing import Dict, FrozenSet, Optional -from sec_certs.serialization.json import ComplexSerializableType import sec_certs.helpers as helpers +from sec_certs.serialization.json import ComplexSerializableType logger = logging.getLogger(__name__) diff --git a/sec_certs/serialization/json.py b/sec_certs/serialization/json.py index 2ab5aa93..8c229f65 100644 --- a/sec_certs/serialization/json.py +++ b/sec_certs/serialization/json.py @@ -1,8 +1,8 @@ +import copy import json from datetime import date from pathlib import Path -from typing import Dict, List, Union, Optional, Callable -import copy +from typing import Callable, Dict, List, Optional, Union class ComplexSerializableType: diff --git a/setup.py b/setup.py index 595e3811..a34108f8 100644 --- a/setup.py +++ b/setup.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -from setuptools import setup, find_packages +from setuptools import find_packages, setup with open("requirements.txt") as f: requirements = f.read().splitlines() diff --git a/tests/fips_test_utils.py b/tests/fips_test_utils.py index 07734d9d..89b61e7e 100644 --- a/tests/fips_test_utils.py +++ b/tests/fips_test_utils.py @@ -1,5 +1,5 @@ -from typing import List from pathlib import Path +from typing import List def generate_html(ids: List[str], path: Path): diff --git a/tests/test_cc_heuristics.py b/tests/test_cc_heuristics.py index 527d6e6f..e2dd7855 100644 --- a/tests/test_cc_heuristics.py +++ b/tests/test_cc_heuristics.py @@ -1,19 +1,19 @@ import copy import datetime +import shutil import tempfile +from pathlib import Path +from typing import ClassVar, Dict from unittest import TestCase + +import tests.data.test_cc_heuristics from sec_certs.dataset.common_criteria import CCDataset -from sec_certs.sample.common_criteria import CommonCriteriaCert -from sec_certs.sample.protection_profile import ProtectionProfile from sec_certs.dataset.cpe import CPEDataset -from sec_certs.sample.cpe import CPE from sec_certs.dataset.cve import CVEDataset +from sec_certs.sample.common_criteria import CommonCriteriaCert +from sec_certs.sample.cpe import CPE from sec_certs.sample.cve import CVE -from pathlib import Path -from typing import ClassVar, Dict -import shutil - -import tests.data.test_cc_heuristics +from sec_certs.sample.protection_profile import ProtectionProfile class TestCommonCriteriaHeuristics(TestCase): diff --git a/tests/test_cc_oop.py b/tests/test_cc_oop.py index 9a598bc5..0149a23d 100644 --- a/tests/test_cc_oop.py +++ b/tests/test_cc_oop.py @@ -1,18 +1,18 @@ -import tempfile -from unittest import TestCase -from pathlib import Path -from tempfile import TemporaryDirectory, mkstemp, NamedTemporaryFile -from datetime import date, datetime -import json import filecmp -import shutil +import json import os +import shutil +import tempfile +from datetime import date, datetime +from pathlib import Path +from tempfile import NamedTemporaryFile, TemporaryDirectory, mkstemp +from unittest import TestCase +import sec_certs.constants as constants +import sec_certs.helpers as helpers from sec_certs.dataset.common_criteria import CCDataset from sec_certs.sample.common_criteria import CommonCriteriaCert from sec_certs.sample.protection_profile import ProtectionProfile -import sec_certs.helpers as helpers -import sec_certs.constants as constants class TestCommonCriteriaOOP(TestCase): diff --git a/tests/test_cc_txt_processing.py b/tests/test_cc_txt_processing.py index 96716fbe..d33fa6f6 100644 --- a/tests/test_cc_txt_processing.py +++ b/tests/test_cc_txt_processing.py @@ -1,10 +1,10 @@ -import tests.data.test_cc_heuristics -from unittest import TestCase +import shutil +import tempfile from pathlib import Path from typing import ClassVar -import tempfile -import shutil +from unittest import TestCase +import tests.data.test_cc_heuristics from sec_certs.dataset.common_criteria import CCDataset from sec_certs.sample.common_criteria import CommonCriteriaCert diff --git a/tests/test_fips_oop.py b/tests/test_fips_oop.py index c39558b6..74651acf 100644 --- a/tests/test_fips_oop.py +++ b/tests/test_fips_oop.py @@ -1,16 +1,15 @@ -from unittest import TestCase +import shutil from pathlib import Path from tempfile import TemporaryDirectory -from typing import Optional, Union, ClassVar, Final, List, Dict -import shutil +from typing import ClassVar, Dict, Final, List, Optional, Union +from unittest import TestCase +import tests.data.test_fips_oop +from sec_certs.config.configuration import config from sec_certs.dataset.fips import FIPSDataset from sec_certs.dataset.fips_algorithm import FIPSAlgorithmDataset -from sec_certs.config.configuration import config from tests.fips_test_utils import generate_html -import tests.data.test_fips_oop - def _set_up_dataset(td, certs): dataset = FIPSDataset({}, Path(td), "test_dataset", "fips_test_dataset") -- cgit v1.3.1 From 4f255665d2c335185fb68e288801c89c66dc5a5a Mon Sep 17 00:00:00 2001 From: Adam Janovsky Date: Sat, 18 Dec 2021 17:50:51 +0100 Subject: Fix MyPy errors --- sec_certs/dataset/common_criteria.py | 8 ++++---- sec_certs/dataset/dataset.py | 4 ++-- sec_certs/dataset/protection_profile.py | 6 +++--- sec_certs/helpers.py | 13 +++++-------- sec_certs/sample/common_criteria.py | 6 +++++- sec_certs/sample/cpe.py | 4 ++-- sec_certs/sample/fips.py | 4 ++-- sec_certs/sample/protection_profile.py | 2 +- tests/test_cc_heuristics.py | 14 ++++++++++---- tests/test_cc_txt_processing.py | 10 ++++++---- tests/test_fips_oop.py | 2 +- 11 files changed, 41 insertions(+), 32 deletions(-) (limited to 'tests') diff --git a/sec_certs/dataset/common_criteria.py b/sec_certs/dataset/common_criteria.py index a781db41..8fe2b710 100644 --- a/sec_certs/dataset/common_criteria.py +++ b/sec_certs/dataset/common_criteria.py @@ -7,7 +7,7 @@ import tempfile from dataclasses import dataclass from datetime import datetime from pathlib import Path -from typing import ClassVar, Dict, Iterator, List, Mapping, Optional, Set, Tuple, Union +from typing import ClassVar, Dict, Iterator, List, Mapping, Optional, Set, Tuple, Union, Callable import numpy as np import pandas as pd @@ -217,10 +217,10 @@ class CCDataset(Dataset, ComplexSerializableType): @serialize def process_protection_profiles(self, to_download: bool = True, keep_metadata: bool = True): logger.info("Processing protection profiles.") - constructor = {True: ProtectionProfileDataset.from_web, False: ProtectionProfileDataset.from_json} + constructor: Dict[bool, Callable[..., ProtectionProfileDataset]] = {True: ProtectionProfileDataset.from_web, False: ProtectionProfileDataset.from_json} if to_download is True and not self.auxillary_datasets_dir.exists(): self.auxillary_datasets_dir.mkdir() - pp_dataset: ProtectionProfileDataset = constructor[to_download](self.pp_dataset_path) + pp_dataset = constructor[to_download](self.pp_dataset_path) for cert in self: if cert.protection_profiles is None: @@ -342,7 +342,7 @@ class CCDataset(Dataset, ComplexSerializableType): df_main = df_main.drop_duplicates() profiles = { - x.dgst: set([ProtectionProfile(y) for y in helpers.sanitize_protection_profiles(x.protection_profiles)]) + x.dgst: set([ProtectionProfile(pp_name=y) for y in helpers.sanitize_protection_profiles(x.protection_profiles)]) for x in df_base.itertuples() } updates: Dict[str, Set] = {x.dgst: set() for x in df_base.itertuples()} diff --git a/sec_certs/dataset/dataset.py b/sec_certs/dataset/dataset.py index e6a4396d..bf129a82 100644 --- a/sec_certs/dataset/dataset.py +++ b/sec_certs/dataset/dataset.py @@ -4,7 +4,7 @@ import logging from abc import ABC, abstractmethod from datetime import datetime from pathlib import Path -from typing import Collection, Dict, List, Mapping, Optional, Set, Tuple, TypeVar, Union +from typing import Collection, Dict, List, Mapping, Optional, Set, Tuple, TypeVar, Union, Type import requests @@ -119,7 +119,7 @@ class Dataset(ABC): return dset @classmethod - def from_json(cls: T, input_path: Union[str, Path]) -> T: + def from_json(cls: Type[T], input_path: Union[str, Path]) -> T: dset = ComplexSerializableType.from_json(input_path) dset.root_dir = Path(input_path).parent.absolute() dset.set_local_paths() diff --git a/sec_certs/dataset/protection_profile.py b/sec_certs/dataset/protection_profile.py index bab82fb0..4e7ba747 100644 --- a/sec_certs/dataset/protection_profile.py +++ b/sec_certs/dataset/protection_profile.py @@ -15,15 +15,15 @@ logger = logging.getLogger(__name__) class ProtectionProfileDataset: static_dataset_url: ClassVar[str] = "https://ajanovsky.cz/pp_data_complete_processed.json" - pps: Dict[Tuple[str, str], ProtectionProfile] + pps: Dict[Tuple[str, Optional[str]], ProtectionProfile] def __iter__(self): yield from self.pps.values() - def __getitem__(self, item: Tuple[str, str]) -> ProtectionProfile: + def __getitem__(self, item: Tuple[str, Optional[str]]) -> ProtectionProfile: return self.pps.__getitem__(item) - def __setitem__(self, key: Tuple[str, str], value: ProtectionProfile): + def __setitem__(self, key: Tuple[str, Optional[str]], value: ProtectionProfile): self.pps.__setitem__(key, value) def __contains__(self, key): diff --git a/sec_certs/helpers.py b/sec_certs/helpers.py index bf96eaa8..9198f5c5 100644 --- a/sec_certs/helpers.py +++ b/sec_certs/helpers.py @@ -100,13 +100,10 @@ def sanitize_date(record: Union[pd.Timestamp, date, np.datetime64]) -> Union[dat return record # type: ignore -def sanitize_string(record: Optional[str]) -> Optional[str]: - if not record: - return None - else: - # TODO: There is a sample with name 'ATMEL Secure Microcontroller AT90SC12872RCFT / AT90SC12836RCFT rev. I & J' that has to be unescaped twice - string = html.unescape(html.unescape(record)).replace("\n", "") - return " ".join(string.split()) +def sanitize_string(record: str) -> str: + # TODO: There is a sample with name 'ATMEL Secure Microcontroller AT90SC12872RCFT / AT90SC12836RCFT rev. I & J' that has to be unescaped twice + string = html.unescape(html.unescape(record)).replace("\n", "") + return " ".join(string.split()) def sanitize_security_levels(record: Union[str, set]) -> set: @@ -593,7 +590,7 @@ def search_only_headers_bsi(filepath: Path): def extract_keywords(filepath: Path) -> Tuple[str, Optional[Dict[str, Dict[str, int]]]]: try: - result = parse_cert_file(filepath, cc_search_rules, -1, sec_certs.constants.LINE_SEPARATOR)[0] + result = parse_cert_file(filepath, cc_search_rules, -1, constants.LINE_SEPARATOR)[0] processed_result = {} top_level_keys = list(result.keys()) diff --git a/sec_certs/sample/common_criteria.py b/sec_certs/sample/common_criteria.py index a0c41d13..994f56ca 100644 --- a/sec_certs/sample/common_criteria.py +++ b/sec_certs/sample/common_criteria.py @@ -256,7 +256,11 @@ class CommonCriteriaCert(Certificate, PandasSerializableType, ComplexSerializabl self.status = status self.category = category self.name = helpers.sanitize_string(name) - self.manufacturer = helpers.sanitize_string(manufacturer) + + self.manufacturer = None + if manufacturer: + self.manufacturer = helpers.sanitize_string(manufacturer) + self.scheme = scheme self.security_level = helpers.sanitize_security_levels(security_level) self.not_valid_before = helpers.sanitize_date(not_valid_before) diff --git a/sec_certs/sample/cpe.py b/sec_certs/sample/cpe.py index 1099c144..aeab6dc9 100644 --- a/sec_certs/sample/cpe.py +++ b/sec_certs/sample/cpe.py @@ -7,7 +7,7 @@ from sec_certs.serialization.pandas import PandasSerializableType @dataclass(init=False) class CPE(PandasSerializableType, ComplexSerializableType): - uri: Optional[str] + uri: str title: Optional[str] version: Optional[str] vendor: Optional[str] @@ -27,7 +27,7 @@ class CPE(PandasSerializableType, ComplexSerializableType): def __init__( self, - uri: Optional[str] = None, + uri: str, title: Optional[str] = None, start_version: Optional[Tuple[str, str]] = None, end_version: Optional[Tuple[str, str]] = None, diff --git a/sec_certs/sample/fips.py b/sec_certs/sample/fips.py index fe9665fc..01ac3f2d 100644 --- a/sec_certs/sample/fips.py +++ b/sec_certs/sample/fips.py @@ -636,7 +636,7 @@ class FIPSCertificate(Certificate, ComplexSerializableType): if match not in items_found[rule_str]: items_found[rule_str][match] = {} items_found[rule_str][match][constants.TAG_MATCH_COUNTER] = 0 - if sec_certs.constants.APPEND_DETAILED_MATCH_MATCHES: + if constants.APPEND_DETAILED_MATCH_MATCHES: items_found[rule_str][match][constants.TAG_MATCH_MATCHES] = [] # else: # items_found[rule_str][match][TAG_MATCH_MATCHES] = ['List of matches positions disabled. Set APPEND_DETAILED_MATCH_MATCHES to True'] @@ -647,7 +647,7 @@ class FIPSCertificate(Certificate, ComplexSerializableType): # line_number = get_line_number(lines, line_length_compensation, match_span[0]) # start index, end index, line number # items_found[rule_str][match][TAG_MATCH_MATCHES].append([match_span[0], match_span[1], line_number]) - if sec_certs.constants.APPEND_DETAILED_MATCH_MATCHES: + if constants.APPEND_DETAILED_MATCH_MATCHES: items_found[rule_str][match][constants.TAG_MATCH_MATCHES].append([match_span[0], match_span[1]]) # highlight all found strings (by xxxxx) from the input text and store the rest diff --git a/sec_certs/sample/protection_profile.py b/sec_certs/sample/protection_profile.py index 6ce2d00e..d8825ced 100644 --- a/sec_certs/sample/protection_profile.py +++ b/sec_certs/sample/protection_profile.py @@ -15,7 +15,7 @@ class ProtectionProfile(ComplexSerializableType): Object for holding protection profiles. """ - pp_name: Optional[str] + pp_name: str pp_link: Optional[str] = None pp_ids: Optional[FrozenSet[str]] = None diff --git a/tests/test_cc_heuristics.py b/tests/test_cc_heuristics.py index e2dd7855..13bff947 100644 --- a/tests/test_cc_heuristics.py +++ b/tests/test_cc_heuristics.py @@ -3,7 +3,7 @@ import datetime import shutil import tempfile from pathlib import Path -from typing import ClassVar, Dict +from typing import ClassVar, Dict, List from unittest import TestCase import tests.data.test_cc_heuristics @@ -17,15 +17,21 @@ from sec_certs.sample.protection_profile import ProtectionProfile class TestCommonCriteriaHeuristics(TestCase): - dataset_json_path: ClassVar[Path] = Path(tests.data.test_cc_heuristics.__path__[0]) / "vulnerable_dataset.json" + dataset_json_path: ClassVar[Path] = Path(tests.data.test_cc_heuristics.__path__[0]) / "vulnerable_dataset.json" # type: ignore # mypy issue #1422 data_dir_path: ClassVar[Path] = dataset_json_path.parent + tmp_dir: ClassVar[tempfile.TemporaryDirectory] + cc_dset: CCDataset + cve_dset: CVEDataset + cves: List[CVE] + cpe_dset: CPEDataset + cpes: List[CPE] @classmethod def setUpClass(cls) -> None: - cls.tmp_dir: ClassVar[tempfile.TemporaryDirectory] = tempfile.TemporaryDirectory() + cls.tmp_dir = tempfile.TemporaryDirectory() shutil.copytree(cls.data_dir_path, cls.tmp_dir.name, dirs_exist_ok=True) - cls.cc_dset: CCDataset = CCDataset.from_json(Path(cls.tmp_dir.name) / "vulnerable_dataset.json") + cls.cc_dset = CCDataset.from_json(Path(cls.tmp_dir.name) / "vulnerable_dataset.json") cls.cc_dset.process_protection_profiles() cls.cc_dset.download_all_pdfs() cls.cc_dset.convert_all_pdfs() diff --git a/tests/test_cc_txt_processing.py b/tests/test_cc_txt_processing.py index d33fa6f6..cc1cb23c 100644 --- a/tests/test_cc_txt_processing.py +++ b/tests/test_cc_txt_processing.py @@ -9,16 +9,18 @@ from sec_certs.dataset.common_criteria import CCDataset from sec_certs.sample.common_criteria import CommonCriteriaCert -class TestCommonCriteriaHeuristics(TestCase): - dataset_json_path: ClassVar[Path] = Path(tests.data.test_cc_heuristics.__path__[0]) / "vulnerable_dataset.json" +class TestCommonCriteriaTextProcessing(TestCase): + dataset_json_path: ClassVar[Path] = Path(tests.data.test_cc_heuristics.__path__[0]) / "vulnerable_dataset.json" # type: ignore # mypy issue #1422 data_dir_path: ClassVar[Path] = dataset_json_path.parent + tmp_dir: ClassVar[tempfile.TemporaryDirectory] + cc_dset: CCDataset @classmethod def setUpClass(cls) -> None: - cls.tmp_dir: ClassVar[tempfile.TemporaryDirectory] = tempfile.TemporaryDirectory() + cls.tmp_dir = tempfile.TemporaryDirectory() shutil.copytree(cls.data_dir_path, cls.tmp_dir.name, dirs_exist_ok=True) - cls.cc_dset: CCDataset = CCDataset.from_json(Path(cls.tmp_dir.name) / "vulnerable_dataset.json") + cls.cc_dset = CCDataset.from_json(Path(cls.tmp_dir.name) / "vulnerable_dataset.json") cls.cc_dset.download_all_pdfs() cls.cc_dset.convert_all_pdfs() diff --git a/tests/test_fips_oop.py b/tests/test_fips_oop.py index 74651acf..9eb04d67 100644 --- a/tests/test_fips_oop.py +++ b/tests/test_fips_oop.py @@ -18,7 +18,7 @@ def _set_up_dataset(td, certs): return dataset -def _set_up_dataset_for_full(td, certs, cpe_dset_path: Union[str, Path] = None, cve_dset_path: Union[str, Path] = None): +def _set_up_dataset_for_full(td, certs, cpe_dset_path: Path, cve_dset_path: Path): dataset = _set_up_dataset(td, certs) dataset.auxillary_datasets_dir.mkdir(exist_ok=True) -- cgit v1.3.1 From 77028627f6d2b1eb054f85ea05fa6fc9305d006a Mon Sep 17 00:00:00 2001 From: Adam Janovsky Date: Sun, 19 Dec 2021 11:51:15 +0100 Subject: flake8 compliance --- cc_cli.py | 4 ++-- examples/cc_oop_demo.py | 2 +- examples/fips_cpe_labeling.py | 1 - fips_cli.py | 3 --- sec_certs/cert_rules.py | 10 +++++----- sec_certs/dataset/common_criteria.py | 7 ++++--- sec_certs/dataset/cve.py | 6 +++--- sec_certs/dataset/fips.py | 2 +- sec_certs/helpers.py | 21 ++++++++++----------- sec_certs/model/cpe_matching.py | 7 ++----- sec_certs/sample/common_criteria.py | 10 +++++----- sec_certs/sample/cve.py | 2 +- sec_certs/sample/fips.py | 3 +-- tests/fips_test_utils.py | 2 +- tests/test_cc_heuristics.py | 2 -- tests/test_cc_oop.py | 3 +-- tests/test_fips_oop.py | 2 +- 17 files changed, 38 insertions(+), 49 deletions(-) (limited to 'tests') diff --git a/cc_cli.py b/cc_cli.py index bd9e586b..72a8de67 100755 --- a/cc_cli.py +++ b/cc_cli.py @@ -86,7 +86,7 @@ def main( dset: CCDataset = CCDataset.from_json(Path(inputpath)) if output: print( - f"Warning: you provided both input and output paths. The dataset from input path will get copied to output path." + "Warning: you provided both input and output paths. The dataset from input path will get copied to output path." ) dset.root_dir = output @@ -101,7 +101,7 @@ def main( dset = CCDataset( certs={}, root_dir=output, - name=f"CommonCriteria_dataset", + name="CommonCriteria_dataset", description=f"Full CommonCriteria dataset snapshot {datetime.now().date()}", ) dset.get_certs_from_web() diff --git a/examples/cc_oop_demo.py b/examples/cc_oop_demo.py index 60949cd1..46f4d882 100644 --- a/examples/cc_oop_demo.py +++ b/examples/cc_oop_demo.py @@ -43,7 +43,7 @@ def main(): dset._extract_data() # transform to pandas DataFrame - df = dset.to_pandas() + # df = dset.to_pandas() # Compute heuristics on the dataset dset._compute_heuristics() diff --git a/examples/fips_cpe_labeling.py b/examples/fips_cpe_labeling.py index 8b2d99d2..5cab7829 100644 --- a/examples/fips_cpe_labeling.py +++ b/examples/fips_cpe_labeling.py @@ -3,7 +3,6 @@ from datetime import datetime from pathlib import Path from sec_certs.dataset.fips import FIPSDataset -from sec_certs.model.evaluation import evaluate, get_validation_dgsts logger = logging.getLogger(__name__) diff --git a/fips_cli.py b/fips_cli.py index b1bca9c2..149d2f81 100755 --- a/fips_cli.py +++ b/fips_cli.py @@ -1,6 +1,5 @@ #!/usr/bin/env python3 import logging -import os import sys from datetime import datetime from pathlib import Path @@ -117,8 +116,6 @@ def main( stream_handler.setFormatter(formatter) handlers: List[logging.StreamHandler] = [file_handler] - script_dir = os.path.dirname(os.path.realpath(__file__)) - if output: output = Path(output) diff --git a/sec_certs/cert_rules.py b/sec_certs/cert_rules.py index 50278e83..8d0637b8 100644 --- a/sec_certs/cert_rules.py +++ b/sec_certs/cert_rules.py @@ -54,8 +54,8 @@ rules_protection_profiles = [ "BSI-(?:CC[-_]|)PP[-_]*.+?", "PP-SSCD.+?", "PP_DBMS_.+?" - # 'Protection Profile', - #'CCMB-20.+?', + # 'Protection Profile', + # 'CCMB-20.+?', "BSI-CCPP-.+?", "ANSSI-CC-PP.+?", "WBIS_V[0-9]\\.[0-9]", @@ -145,8 +145,8 @@ rules_cc_claims = [ rules_javacard = [ - #'(?:Java Card|JavaCard)', - #'(?:Global Platform|GlobalPlatform)', + # '(?:Java Card|JavaCard)', + # '(?:Global Platform|GlobalPlatform)', r"(?:Java Card|JavaCard) [2-3]\.[0-9](?:\.[0-9]|)", r"JC[2-3]\.[0-9](?:\.[0-9]|)", r"(?:Java Card|JavaCard) \(version [2-3]\.[0-9](?:\.[0-9]|)\)", @@ -404,7 +404,7 @@ rules_fips_remove_algorithm_ids = [ rules_fips_to_remove = [ # --- random words found --- r"[Ss]lot #\d", # a card slot, #2069 - r"[Ss]eals? ?\(?#\d - #\d", # #1232 + r"[Ss]eals? ?\(?#\d - #\d", # #1232 r"\[#\d*\]", # some certs use this as references r"CSP ?#\d", # #2795 r"[Pp]ower [Ss]upply #\d", # #604 diff --git a/sec_certs/dataset/common_criteria.py b/sec_certs/dataset/common_criteria.py index 785f7e62..b0116221 100644 --- a/sec_certs/dataset/common_criteria.py +++ b/sec_certs/dataset/common_criteria.py @@ -327,8 +327,8 @@ class CCDataset(Dataset, ComplexSerializableType): df["dgst"] = df.apply(lambda row: helpers.get_first_16_bytes_sha256(_get_primary_key_str(row)), axis=1) - df_base = df.loc[df.is_maintenance == False].copy() - df_main = df.loc[df.is_maintenance == True].copy() + df_base = df.loc[~df.is_maintenance].copy() + df_main = df.loc[df.is_maintenance].copy() df_base.report_link = df_base.report_link.map(map_ip_to_hostname) df_base.st_link = df_base.st_link.map(map_ip_to_hostname) @@ -424,7 +424,8 @@ class CCDataset(Dataset, ComplexSerializableType): table = tables[0] rows = list(table.find_all("tr")) - header, footer, body = rows[0], rows[1], rows[2:] + # header, footer = rows[0], rows[1] + body = rows[2:] # TODO: It's possible to obtain timestamp of the moment when the list was generated. It's identical for each table and should thus only be obtained once. Not necessarily in each table # timestamp = _get_timestamp_from_footer(footer) diff --git a/sec_certs/dataset/cve.py b/sec_certs/dataset/cve.py index 49cdad27..6e662ac6 100644 --- a/sec_certs/dataset/cve.py +++ b/sec_certs/dataset/cve.py @@ -8,7 +8,7 @@ import tempfile import zipfile from dataclasses import dataclass, field from pathlib import Path -from typing import Dict, Final, List, Optional, Set, Tuple, Union +from typing import Dict, Final, List, Optional, Set, Union import pandas as pd @@ -111,13 +111,13 @@ class CVEDataset(ComplexSerializableType): @classmethod def from_web(cls, start_year: int = 2002, end_year: int = datetime.datetime.now().year): - logger.info(f"Building CVE dataset from nist.gov website.") + logger.info("Building CVE dataset from nist.gov website.") with tempfile.TemporaryDirectory() as tmp_dir: cls.download_cves(tmp_dir, start_year, end_year) json_files = glob.glob(tmp_dir + "/*.json") all_cves = dict() - logger.info(f"Downloaded required resources. Building CVEDataset from jsons.") + logger.info("Downloaded required resources. Building CVEDataset from jsons.") results = process_parallel( cls.from_nist_json, json_files, diff --git a/sec_certs/dataset/fips.py b/sec_certs/dataset/fips.py index cea42eeb..d1ce2dea 100644 --- a/sec_certs/dataset/fips.py +++ b/sec_certs/dataset/fips.py @@ -13,7 +13,7 @@ from sec_certs import constants as constants from sec_certs import helpers as helpers from sec_certs import parallel_processing as cert_processing from sec_certs.config.configuration import config -from sec_certs.dataset.dataset import Dataset, logger +from sec_certs.dataset.dataset import Dataset from sec_certs.dataset.fips_algorithm import FIPSAlgorithmDataset from sec_certs.sample.certificate import Certificate from sec_certs.sample.fips import FIPSCertificate diff --git a/sec_certs/helpers.py b/sec_certs/helpers.py index 9198f5c5..3637fe38 100644 --- a/sec_certs/helpers.py +++ b/sec_certs/helpers.py @@ -1,4 +1,3 @@ -import copy import hashlib import html import logging @@ -10,14 +9,13 @@ from datetime import date from enum import Enum from multiprocessing.pool import ThreadPool from pathlib import Path -from typing import Any, Dict, Hashable, List, Optional, Sequence, Set, Tuple, Union +from typing import Dict, Hashable, List, Optional, Sequence, Set, Tuple, Union import matplotlib.pyplot as plt import numpy as np import pandas as pd import pikepdf import requests -from packaging.version import VERSION_PATTERN from PyPDF2 import PdfFileReader from tqdm import tqdm as tqdm_original @@ -227,7 +225,7 @@ def extract_pdf_metadata(filepath: Path): # TODO: Please, refactor me. I reallyyyyyyyyyyyyy need it!!!!!! -def search_only_headers_anssi(filepath: Path): +def search_only_headers_anssi(filepath: Path): # noqa: C901 class HEADER_TYPE(Enum): HEADER_FULL = 1 HEADER_MISSING_CERT_ITEM_VERSION = 2 @@ -273,11 +271,11 @@ def search_only_headers_anssi(filepath: Path): ), ( HEADER_TYPE.HEADER_FULL, - "Référence du rapport de certification(.+)Nom du produit(.+)Référence/version du produit(.+)Conformité aux profils de protection(.+)Critères d\’évaluation et version(.+)Niveau d\’évaluation(.+)Développeurs(.+)Centre d\’évaluation(.+)Accords de reconnaissance applicables", + "Référence du rapport de certification(.+)Nom du produit(.+)Référence/version du produit(.+)Conformité aux profils de protection(.+)Critères d\’évaluation et version(.+)Niveau d\’évaluation(.+)Développeurs(.+)Centre d\’évaluation(.+)Accords de reconnaissance applicables", # noqa: W605 ), ( HEADER_TYPE.HEADER_FULL, - "Référence du rapport de certification(.+)Nom du produit \\(référence/version\\)(.+)Nom de la TOE \\(référence/version\\)(.+)Conformité à un profil de protection(.+)Critères d\’évaluation et version(.+)Niveau d\’évaluation(.+)Développeurs(.+)Centre d’évaluation(.+)Accords de reconnaissance applicables", + "Référence du rapport de certification(.+)Nom du produit \\(référence/version\\)(.+)Nom de la TOE \\(référence/version\\)(.+)Conformité à un profil de protection(.+)Critères d\’évaluation et version(.+)Niveau d\’évaluation(.+)Développeurs(.+)Centre d’évaluation(.+)Accords de reconnaissance applicables", # noqa: W605 ), ( HEADER_TYPE.HEADER_FULL, @@ -491,7 +489,7 @@ def search_only_headers_anssi(filepath: Path): # TODO: Please refactor me. I need it so badlyyyyyy!!! -def search_only_headers_bsi(filepath: Path): +def search_only_headers_bsi(filepath: Path): # noqa: C901 LINE_SEPARATOR_STRICT = " " NUM_LINES_TO_INVESTIGATE = 15 rules_certificate_preface = [ @@ -561,7 +559,7 @@ def search_only_headers_bsi(filepath: Path): for m in re.finditer(rule_and_sep, whole_text): # check if previous rules had at least one match - if not constants.TAG_CERT_ID in items_found.keys(): + if constants.TAG_CERT_ID not in items_found.keys(): logger.error("ERROR: front page not found for file: {}".format(filepath)) match_groups = m.groups() @@ -649,13 +647,14 @@ def save_modified_cert_file(target_file, modified_cert_file_text, is_unicode_tex try: write_file.write(modified_cert_file_text) - except UnicodeEncodeError as e: + except UnicodeEncodeError: print("UnicodeDecodeError while writing file fragments back") finally: write_file.close() -def parse_cert_file(file_name, search_rules, limit_max_lines=-1, line_separator=LINE_SEPARATOR): +# TODO: Please, refactor me. +def parse_cert_file(file_name, search_rules, limit_max_lines=-1, line_separator=LINE_SEPARATOR): # noqa: C901 whole_text, whole_text_with_newlines, was_unicode_decode_error = load_cert_file( file_name, limit_max_lines, line_separator ) @@ -758,7 +757,7 @@ def load_cert_file(file_name, limit_max_lines=-1, line_separator=LINE_SEPARATOR) # we will estimate the line for searched matches # => we need to known how much lines were modified (removal of eoln..) # for removed newline and for any added separator - line_length_compensation = 1 - len(LINE_SEPARATOR) + # line_length_compensation = 1 - len(LINE_SEPARATOR) lines_included = 0 for line in lines: if limit_max_lines != -1 and lines_included >= limit_max_lines: diff --git a/sec_certs/model/cpe_matching.py b/sec_certs/model/cpe_matching.py index 042f6705..610b409a 100644 --- a/sec_certs/model/cpe_matching.py +++ b/sec_certs/model/cpe_matching.py @@ -1,13 +1,10 @@ import itertools -import json import logging -import operator import re -from pathlib import Path -from typing import Dict, List, Optional, Set, Tuple, Union +from typing import Dict, List, Optional, Set, Tuple from packaging.version import parse -from rapidfuzz import fuzz, process +from rapidfuzz import fuzz from sklearn.base import BaseEstimator import sec_certs.helpers as helpers diff --git a/sec_certs/sample/common_criteria.py b/sec_certs/sample/common_criteria.py index 994f56ca..a353ff61 100644 --- a/sec_certs/sample/common_criteria.py +++ b/sec_certs/sample/common_criteria.py @@ -432,11 +432,11 @@ class CommonCriteriaCert(Certificate, PandasSerializableType, ComplexSerializabl main_report_link = None main_st_link = None links = u.find_all("a") - for l in links: - if l.get("title").startswith("Maintenance Report:"): - main_report_link = CommonCriteriaCert.cc_url + l.get("href") - elif l.get("title").startswith("Maintenance ST"): - main_st_link = CommonCriteriaCert.cc_url + l.get("href") + for link in links: + if link.get("title").startswith("Maintenance Report:"): + main_report_link = CommonCriteriaCert.cc_url + link.get("href") + elif link.get("title").startswith("Maintenance ST"): + main_st_link = CommonCriteriaCert.cc_url + link.get("href") else: logger.error("Unknown link in Maintenance part!") maintenance_updates.add( diff --git a/sec_certs/sample/cve.py b/sec_certs/sample/cve.py index 94484374..2bc28c4a 100644 --- a/sec_certs/sample/cve.py +++ b/sec_certs/sample/cve.py @@ -1,7 +1,7 @@ import datetime import itertools from dataclasses import dataclass -from typing import Any, ClassVar, Dict, List, Optional, Tuple +from typing import ClassVar, Dict, List, Optional, Tuple from dateutil.parser import isoparse diff --git a/sec_certs/sample/fips.py b/sec_certs/sample/fips.py index 01ac3f2d..b66d11df 100644 --- a/sec_certs/sample/fips.py +++ b/sec_certs/sample/fips.py @@ -11,7 +11,6 @@ from dateutil import parser from tabula import read_pdf import sec_certs.constants as constants -from sec_certs import constants as constants from sec_certs import helpers from sec_certs.cert_rules import REGEXEC_SEP, fips_common_rules, fips_rules from sec_certs.config.configuration import config @@ -572,7 +571,7 @@ class FIPSCertificate(Certificate, ComplexSerializableType): algs_vals = list(cert.pdf_scan.keywords["rules_fips_algorithms"].values()) table_vals = [x["Certificate"] for x in cert.pdf_scan.algorithms] tables = [x.strip() for y in table_vals for x in y] - iterable = [l for x in algs_vals for l in list(x.keys())] + iterable = [alg for x in algs_vals for alg in list(x.keys())] iterable += tables all_algorithms = set() for x in iterable: diff --git a/tests/fips_test_utils.py b/tests/fips_test_utils.py index 89b61e7e..2fce325b 100644 --- a/tests/fips_test_utils.py +++ b/tests/fips_test_utils.py @@ -47,6 +47,6 @@ def generate_html(ids: List[str], path: Path): - """ + """ with open(path, "w") as f: f.write(f"{html_head}\n{html_body}\n") diff --git a/tests/test_cc_heuristics.py b/tests/test_cc_heuristics.py index 13bff947..caa6b1fb 100644 --- a/tests/test_cc_heuristics.py +++ b/tests/test_cc_heuristics.py @@ -1,5 +1,3 @@ -import copy -import datetime import shutil import tempfile from pathlib import Path diff --git a/tests/test_cc_oop.py b/tests/test_cc_oop.py index 0149a23d..2426476d 100644 --- a/tests/test_cc_oop.py +++ b/tests/test_cc_oop.py @@ -1,11 +1,10 @@ import filecmp -import json import os import shutil import tempfile from datetime import date, datetime from pathlib import Path -from tempfile import NamedTemporaryFile, TemporaryDirectory, mkstemp +from tempfile import NamedTemporaryFile, TemporaryDirectory from unittest import TestCase import sec_certs.constants as constants diff --git a/tests/test_fips_oop.py b/tests/test_fips_oop.py index 9eb04d67..17b3325a 100644 --- a/tests/test_fips_oop.py +++ b/tests/test_fips_oop.py @@ -1,7 +1,7 @@ import shutil from pathlib import Path from tempfile import TemporaryDirectory -from typing import ClassVar, Dict, Final, List, Optional, Union +from typing import Dict, Final, List from unittest import TestCase import tests.data.test_fips_oop -- cgit v1.3.1