def test_upload_lsc_from_csv_reader_sucess(self):
general_metadata_dict = {
'VULDETECT':
'Checks if a vulnerable package version is present on the target host.',
'SOLUTION': 'Please install the updated package(s).',
'SOLUTION_TYPE': 'VendorFix',
'QOD_TYPE': 'package',
}
notus = NotusMetadataHandler(nvti=self.nvti,
metadata_path="./tests/notus")
notus.nvti.add_vt_to_cache.return_value = None
logging.Logger.debug = MagicMock()
path = Path("./tests/notus/example.csv").resolve()
purepath = PurePath(path).name
with path.open("r") as openfile:
for line_string in openfile:
if line_string.startswith("{"):
break
reader = DictReader(openfile)
ret = notus.upload_lsc_from_csv_reader(purepath,
general_metadata_dict,
reader)
self.assertTrue(ret)
logging.Logger.debug.assert_called_with(
"Loaded %d/%d advisories from %s", 1, 1, purepath)
def check_feed(self):
"""Check if there is a feed update.
Wait until all the running scans finished. Set a flag to announce there
is a pending feed update, which avoids to start a new scan.
"""
if not self.vts.is_cache_available:
return
current_feed = self.nvti.get_feed_version()
is_outdated = self.feed_is_outdated(current_feed)
# Check if the nvticache in redis is outdated
if not current_feed or is_outdated:
with self.feed_lock as fl:
if fl.has_lock():
self.initialized = False
Openvas.load_vts_into_redis()
notushandler = NotusMetadataHandler(nvti=self.nvti)
notushandler.update_metadata()
current_feed = self.nvti.get_feed_version()
self.set_vts_version(vts_version=current_feed)
vthelper = VtHelper(self.nvti)
self.vts.sha256_hash = (
vthelper.calculate_vts_collection_hash())
self.initialized = True
else:
logger.debug("The feed was not upload or it is outdated, "
"but other process is locking the update. "
"Trying again later...")
return
def test_get_csv_filepath(self):
path = Path("./tests/notus/example.csv").resolve()
notus = NotusMetadataHandler(metadata_path="./tests/notus/")
ret = notus._get_csv_filepaths()
self.assertEqual(ret, [path])
def test_check_advisory_dict(self):
advisory_dict = OrderedDict([
('OID', '1.3.6.1.4.1.25623.1.1.2.2020.1234'),
(
'TITLE',
'VendorOS: Security Advisory for git (VendorOS-2020-1234)',
),
('CREATION_DATE', '1600269468'),
('LAST_MODIFICATION', '1601380531'),
('SOURCE_PKGS', "['git']"),
('ADVISORY_ID', 'VendorOS-2020-1234'),
('CVSS_BASE_VECTOR', 'AV:N/AC:L/Au:N/C:C/I:C/A:C'),
('CVSS_BASE', '10.0'),
('ADVISORY_XREF', 'https://example.com'),
('DESCRIPTION', 'The remote host is missing an update.'),
('INSIGHT', 'buffer overflow'),
('AFFECTED', "'p1' package(s) on VendorOS V2.0SP1"),
('CVE_LIST', "['CVE-2020-1234']"),
(
'BINARY_PACKAGES_FOR_RELEASES',
"{'VendorOS V2.0SP1': ['p1-1.1']}",
),
('XREFS', '[]'),
])
notus = NotusMetadataHandler()
self.assertTrue(notus._check_advisory_dict(advisory_dict))
def test_is_checksum_correct_enabled_false(self):
notus = NotusMetadataHandler(nvti=self.nvti)
notus.nvti.get_file_checksum.return_value = "abc123"
notus._openvas_settings_dict = {'nasl_no_signature_check': 0}
self.assertFalse(
notus.is_checksum_correct(Path("./tests/notus/example.csv")))
def test_format_xrefs(self):
notus = NotusMetadataHandler()
ret = notus._format_xrefs("https://example.com",
["www.foo.net", "www.bar.net"])
self.assertEqual(
ret, "URL:https://example.com, URL:www.foo.net, URL:www.bar.net")
def test_is_checksum_correct_enabled_true(self):
notus = NotusMetadataHandler(nvti=self.nvti)
notus.nvti.get_file_checksum.return_value = (
"2f561b9be5d1a1194f49cd5a6a024dee15a0c0bc7d94287266d0e6358e737f4e")
notus._openvas_settings_dict = {'nasl_no_signature_check': 0}
self.assertTrue(
notus.is_checksum_correct(Path("./tests/notus/example.csv")))
def _get_vts_in_groups(
self,
filters: List[str],
) -> List[str]:
"""Return a list of vts which match with the given filter.
Arguments:
filters A list of filters. Each filter has key, operator and
a value. They are separated by a space.
Supported keys: family
Returns a list of vt oids which match with the given filter.
"""
settings = Openvas.get_settings()
notus_enabled = settings.get("table_driven_lsc")
vts_list = list()
families = dict()
notus = NotusMetadataHandler()
lsc_families_and_drivers = notus.get_family_driver_linkers()
oids = self.nvti.get_oids()
for _, oid in oids:
family = self.nvti.get_nvt_family(oid)
if family not in families:
families[family] = list()
families[family].append(oid)
for elem in filters:
key, value = elem.split('=')
# If the family is supported by Notus LSC and Notus
# is enabled
if (key == 'family' and notus_enabled
and value in lsc_families_and_drivers):
driver_oid = lsc_families_and_drivers.get(value)
vts_list.append(driver_oid)
logger.debug('Add Notus driver for family "%s"', value)
# If Notus disable or family not supported by notus.
elif key == 'family' and value in families:
vts_list.extend(families[value])
logger.debug('Add VTs collection for family "%s"', value)
return vts_list
def test_set_openvas_settings(self, MockOpenvas):
openvas = MockOpenvas()
openvas.get_settings.return_value = {'nasl_no_signature_check': 0}
notus = NotusMetadataHandler()
no_signature_check = notus.openvas_setting.get(
"nasl_no_signature_check")
self.assertEqual(no_signature_check, 0)
def test_metadata_path(self, MockOpenvas):
openvas = MockOpenvas()
openvas.get_settings.return_value = {'plugins_folder': './tests/notus'}
notus = NotusMetadataHandler()
self.assertIsNone(notus._metadata_path)
self.assertEqual(notus.metadata_path,
f'./tests/notus/{METADATA_DIRECTORY_NAME}/')
self.assertEqual(notus._metadata_path,
f'./tests/notus/{METADATA_DIRECTORY_NAME}/')
def test_check_field_names_lsc_missing(self):
notus = NotusMetadataHandler()
field_names_list = [
"OID",
"CREATION_DATE",
"LAST_MODIFICATION",
"SOURCE_PKGS",
"ADVISORY_ID",
"CVSS_BASE_VECTOR",
"CVSS_BASE",
"ADVISORY_XREF",
"DESCRIPTION",
"INSIGHT",
"AFFECTED",
"CVE_LIST",
"BINARY_PACKAGES_FOR_RELEASES",
"XREFS",
]
self.assertFalse(notus._check_field_names_lsc(field_names_list))
def test_update_metadata_success(self):
notus = NotusMetadataHandler(metadata_path="./tests/notus")
logging.Logger.warning = MagicMock()
path = Path("./tests/notus/example.csv").resolve()
purepath = PurePath(path).name
notus._get_csv_filepaths = MagicMock(return_value=[path])
notus.is_checksum_correct = MagicMock(return_value=True)
notus._check_field_names_lsc = MagicMock(return_value=True)
notus.upload_lsc_from_csv_reader = MagicMock(return_value=True)
notus.update_metadata()
logging.Logger.warning.assert_not_called()
def test_update_metadata_failed(self):
notus = NotusMetadataHandler(metadata_path="./tests/notus")
logging.Logger.warning = MagicMock()
path = Path("./tests/notus/example.csv").resolve()
notus._get_csv_filepaths = MagicMock(return_value=[path])
notus.is_checksum_correct = MagicMock(return_value=True)
notus._check_field_names_lsc = MagicMock(return_value=True)
notus.upload_lsc_from_csv_reader = MagicMock(return_value=False)
notus.update_metadata()
logging.Logger.warning.assert_called_with(
"Some advaisory was not loaded from %s", path.name)
def init(self, server: BaseServer) -> None:
self.scan_collection.init()
server.start(self.handle_client_stream)
self.scanner_info['version'] = Openvas.get_version()
self.set_params_from_openvas_settings()
with self.feed_lock.wait_for_lock():
Openvas.load_vts_into_redis()
notushandler = NotusMetadataHandler(nvti=self.nvti)
notushandler.update_metadata()
current_feed = self.nvti.get_feed_version()
self.set_vts_version(vts_version=current_feed)
logger.debug("Calculating vts integrity check hash...")
vthelper = VtHelper(self.nvti)
self.vts.sha256_hash = vthelper.calculate_vts_collection_hash()
self.initialized = True
def test_update_metadata_field_name_failed(self):
notus = NotusMetadataHandler(metadata_path="./tests/notus")
logging.Logger.warning = MagicMock()
path = Path("./tests/notus/example.csv").resolve()
notus._get_csv_filepaths = MagicMock(return_value=[path])
notus.is_checksum_correct = MagicMock(return_value=True)
notus._check_field_names_lsc = MagicMock(return_value=False)
notus.update_metadata()
logging.Logger.warning.assert_called_with(
f'Field names check for %s failed', path)
def test_update_metadata_warning(self):
notus = NotusMetadataHandler()
logging.Logger.warning = MagicMock()
path = Path("./tests/notus/example.csv").resolve()
notus._get_csv_filepaths = MagicMock(return_value=[path])
notus.is_checksum_correct = MagicMock(return_value=False)
notus.update_metadata()
logging.Logger.warning.assert_called_with(f'Checksum for %s failed',
path)
def test_is_checksum_correct_check_disable(self):
notus = NotusMetadataHandler()
notus._openvas_settings_dict = {'nasl_no_signature_check': 1}
self.assertTrue(notus.is_checksum_correct(Path("foo")))