def test_get_sfbrowsing_details(self):
url = "example.com"
url_body = {"url": url}
info("Requested url body: {}".format(url_body))
resp = get_sfbrowsing_details(url_body)
assert_type(resp, Response,
"Check if returned result is of correct type")
assert_equal(resp.status_code, 200,
"Check if correct status code was returned")
json_data = json.loads(resp.data.decode('utf-8'))
assert_type(json_data, dict,
"Check if returned result is of correct type")
assert_not_empty(json_data, "Check if returned dict is not empty")
field = "details"
assert_dict_contains_key(
json_data, field,
"Check if returned dict contains '{}' key".format(field))
field = "url"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
assert_equal(json_data['details'][field], url,
"Check if correct url was returned")
field = "malicious"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
def test_get_entropy_details(self):
url = "exampleawdawdefgrgdheqafrty3452rf.comc"
url_body = {"url": url}
info("Requested url body: {}".format(url_body))
resp = get_entropy_details(url_body)
assert_type(resp, Response,
"Check if returned result is of correct type")
assert_equal(resp.status_code, 200,
"Check if correct status code was returned")
json_data = json.loads(resp.data.decode('utf-8'))
assert_type(json_data, dict,
"Check if returned result is of correct type")
assert_not_empty(json_data, "Check if returned dict is not empty")
field = "details"
assert_dict_contains_key(
json_data, field,
"Check if returned dict contains '{}' key".format(field))
field = "entropy"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
assert_equal(
json_data['details'][field],
pytest.approx(json_data['details'][field], 0.01),
"Check if returned entropy is properly rounded to 2 decimal places"
)
def test_get_ip_details(self):
ip = "1.1.1.1"
ip_body = {"ip": ip}
info("Requested ip body: {}".format(ip_body))
resp = get_ip_details(ip_body)
assert_type(resp, Response,
"Check if returned result is of correct type")
assert_equal(resp.status_code, 200,
"Check if correct status code was returned")
json_data = json.loads(resp.data.decode('utf-8'))
assert_type(json_data, dict,
"Check if returned result is of correct type")
assert_not_empty(json_data, "Check if returned dict is not empty")
field = "details"
assert_dict_contains_key(
json_data, field,
"Check if returned dict contains '{}' key".format(field))
field = "country"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
field = "ip"
expected = ip
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
assert_equal(json_data['details'][field], expected,
"Check if correct status code was returned")
field = "asn"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
def test_search_newest(self, urlscan_data):
url = urlscan_data[0]
info("Requested URL: {}".format(url))
r, date = search_newest(url)
assert_type(r, dict, "Check if returned search data is valid dict")
assert_not_empty(r, "Check if returned search data is not empty")
assert_type(date, datetime, "Check if returned search data is valid datetime object")
def test_get_cert_results(self):
domain = "example.com"
info("Requested domain - {}".format(domain))
l = get_results(domain)
assert_type(
l, dict,
"Check if returned object with certificate details is proper dict")
assert_not_empty(l, "Check if cert details dict is not empty")
def test_summary(self, urlscan_data):
uid = urlscan_data[1]
result_url = "https://urlscan.io/api/v1/result/{}".format(uid)
info("GET {}".format(result_url))
response = get(result_url)
assert_equal(response.status_code, 200, "Check if response's status code is correct (200)")
r = summary(response.json())
assert_type(r, dict, "Check if returned search data is valid dict")
assert_not_empty(r, "Check if returned search data is not empty")
def test_get_ip_details_reserved_range(self):
ip = "127.0.0.1"
info("Requested ip - {}".format(ip))
details = get_ip_details(ip)
assert_type(details, dict, "Check if returned results are of type dict")
assert_not_empty(details, "Check if returned results are not empty")
field = 'status'
expected = 'reserved_range'
assert_equal(details[field], expected, "Check if returned status is equal to expected one")
field = 'ip'
expected = ip
assert_equal(details[field], expected, "Check if returned ip is equal to expected one")
def test_get_urlscan_details(self):
url = "example.com"
url_body = {"url": url}
info("Requested url body: {}".format(url_body))
resp = get_crtsh_details(url_body)
assert_type(resp, Response,
"Check if returned result is of correct type")
assert_is_in(resp.status_code, [200, 202],
"Check if correct status code was returned")
if resp.status_code == 202:
info("Returned 202 - skipping rest of asserts")
return
json_data = json.loads(resp.data.decode('utf-8'))
assert_type(json_data, dict,
"Check if returned result is of correct type")
assert_not_empty(json_data, "Check if returned dict is not empty")
field = "details"
assert_dict_contains_key(
json_data, field,
"Check if returned dict contains '{}' key".format(field))
field = "caid"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
field = "registered_at"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
field = "subject"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
field = "issuer"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
field = "multi_dns_amount"
assert_dict_contains_key(
json_data['details'], field,
"Check if returned dict contains '{}' key".format(field))
field = "org_name"
assert_dict_contains_key(
json_data['details']['subject'], field,
"Check if returned dict contains '{}' key".format(field))
field = "country"
assert_dict_contains_key(
json_data['details']['subject'], field,
"Check if returned dict contains '{}' key".format(field))
field = "common_name"
assert_dict_contains_key(
json_data['details']['issuer'], field,
"Check if returned dict contains '{}' key".format(field))
def test_lookup_url_malicious(self):
url = 'http://malware.testing.google.test/testing/malware/'
info("Requested url - {}".format(url))
l = lookup_url(url)
assert_type(l, dict, "Check if proper dict is returned")
assert_not_empty(l, "Check if response is not empty")
field = "url"
expected = url
assert_dict_contains_key(l, field, "Check if url is in response")
assert_equal(l[field], expected, "Check if proper url is returned")
field = "malicious"
expected = True
assert_dict_contains_key(l, field, "Check if malicious is in response")
assert_equal(l[field], expected, "Check if proper status is returned")
def test_lookup_url(self):
url = "google.com"
info("Requested url - {}".format(url))
l = lookup_url(url)
assert_type(l, dict, "Check if proper dict is returned")
assert_not_empty(l, "Check if response is not empty")
field = "url"
expected = url
assert_dict_contains_key(l, field, "Check if url is in response")
assert_equal(l[field], expected, "Check if proper url is returned")
field = "malicious"
expected = False
assert_dict_contains_key(l, field, "Check if malicious is in response")
assert_equal(l[field], expected, "Check if proper status is returned")
def test_verify_api(self):
info("Requested api key: {}".format(AUTH_API_KEY))
result = security.verify_api(apikey=AUTH_API_KEY, required_scopes=None)
assert_type(result, dict,
"Check if returned result is of correct type")
assert_not_empty(result, "Check if returned dict is not empty")
field = "auth_type"
expected = "apiKey"
assert_dict_contains_key(
result, field,
"Check if returned dict contains '{}' key".format(field))
assert_equal(result[field], expected,
"Check if correct auth type was returned")
field = "apiKey"
expected = AUTH_API_KEY
assert_dict_contains_key(
result, field,
"Check if returned dict contains '{}' key".format(field))
assert_equal(result[field], expected,
"Check if correct api key was returned")
def test_get_ip_details(self):
ip = "8.8.8.8"
info("Requested ip - {}".format(ip))
details = get_ip_details(ip)
assert_type(details, dict, "Check if returned results are of type dict")
assert_not_empty(details, "Check if returned results are not empty")
def test_results(self, urlscan_data):
uid = urlscan_data[1]
info("Requested id: {}".format(uid))
r = results(uid, wait_time=10)
assert_type(r, dict, "Check if returned search data is valid dict")
assert_not_empty(r, "Check if returned search data is not empty")
def test_search(self, urlscan_data):
url = urlscan_data[0]
info("Requested URL: {}".format(url))
r = search(url)
assert_type(r, list, "Check if returned search data is valid list")
assert_not_empty(r, "Check if returned search data is not empty")
def test_get_phishing_domains():
l = get_phishing_domains()
assert_type(
l, list,
"Check if returned object with phishing domains is proper list")
assert_not_empty(l, "Check if list of phishing domains is not empty")
