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_add_keyword_too_short(self, client_with_db):
client = client_with_db[0]
db = client_with_db[1]
endpoint = '/server/create_db'
headers = {
"X-API-Key": AUTH_API_KEY
}
info("GET {}".format(endpoint))
response = client.get(BASE_PATH + endpoint, headers=headers)
assert_equal(response.status_code, 200, "Check status code")
endpoint = '/server/add_keyword'
headers['Content-Type'] = 'application/x-www-form-urlencoded'
data = {
'keyword': 'key'
}
info("POST {}".format(endpoint))
response = client.post(BASE_PATH + endpoint, headers=headers, data=data)
j = data_to_json(response.data)
assert_equal(response.status_code, 400, "Check status code")
field = "detail"
expected_value = "Keyword too short - min 4 signs"
assert_dict_contains_key(j, field, "Check if dict contains given key - \"{}\"".format(field))
assert_equal(j[field], expected_value, "Check if item \"{}\" is equal to \"{}\"".format(field, expected_value))
field = "status"
expected_value = 400
assert_dict_contains_key(j, field, "Check if dict contains given key - \"{}\"".format(field))
assert_equal(j[field], expected_value, "Check if item \"{}\" is equal to \"{}\"".format(field, expected_value))
field = "title"
expected_value = "Bad Request"
assert_dict_contains_key(j, field, "Check if dict contains given key - \"{}\"".format(field))
assert_equal(j[field], expected_value, "Check if item \"{}\" is equal to \"{}\"".format(field, expected_value))
def test_get_entropy_zero(self):
string = "aaa"
info("Checked string - {}".format(string))
e = get_entropy(string)
info("Calculated entropy: {}".format(e))
assert_equal(e, 0,
"Check if calculated entropy is equal to predicted one")
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_verify_by_urlscan_malicious(self, client_with_db):
client = client_with_db[0]
endpoint = '/verify/by_urlscan'
malicious_url = get_test_phishing_domain()
data = {'url': '{}'.format(malicious_url)}
headers = {'Content-Type': "application/json"}
info("POST {}".format(endpoint))
response = client.post(BASE_PATH + endpoint,
data=json.dumps(data),
headers=headers)
assert_equal(response.status_code, 200, "Check status code")
if response.status_code == 202:
pytest.skip(
"urlscan.io returned status 202 - url \"{}\" is invalid".
format(malicious_url))
j = data_to_json(response.data)
field = "status"
expected_value = "malicious"
assert_dict_contains_key(
j, field,
"Check if dict contains given key - \"{}\"".format(field))
if j[field] == "good":
pytest.skip(
"urlscan.io returned malicious domain as good - url \"{}\" is invalid"
.format(malicious_url))
assert_equal(
j[field], expected_value,
"Check if item \"{}\" is equal to \"{}\"".format(
field, expected_value))
def test_url_to_domain_schema_without_query(self):
test_url = "example.com"
expected_url = "example.com"
info("Requested URL: {}".format(test_url))
result = url_helper.url_to_domain(test_url)
assert_type(result, str, "Check if returned result is of correct type")
assert_equal(result, expected_url, "Check if method returned correct url")
def test_get_entropy(self):
string = "ab"
info("Checked string - {}".format(string))
e = get_entropy(string)
info("Calculated entropy: {}".format(e))
assert_true(e > 0, "Check if calculated entropy is bigger than 0")
assert_equal(e, 1,
"Check if calculated entropy is equal to predicted one")
def test_verify_entropy_good(self):
malicious_url = "abc"
info("Requested URL: {}".format(malicious_url))
result = uv.verify_entropy('test_domain')
assert_type(result, bool,
"Check if returned result is of correct type")
assert_equal(result, False, "Check if method returned correct verdict")
def test_get_urlscan_details_wrong_url(self):
url = token_hex(32)
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_equal(resp.status_code, 202,
"Check if correct status code was returned")
def test_add_ip_correct(self, mock_add_ip):
ip = "127.0.0.1"
mocked_id = randint(1, 10)
# Mock Goodies response
mock_add_ip.return_value = mocked_id
status, cid = db_helper.add_ip(ip)
assert_true(status, "Check if method return correct status")
assert_type(cid, int, "Check if id is correct int")
assert_equal(cid, mocked_id, "Check if returned id is as expected")
def test_verify_entropy_malicious(self):
malicious_url = "abcdefghijklmnoprstukv/!$#%^#$#@"
info("Requested URL: {}".format(malicious_url))
result = uv.verify_entropy(malicious_url)
assert_type(result, bool,
"Check if returned result is of correct type")
assert_equal(result, True, "Check if method returned correct verdict")
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_add_cert_invalid(self, mock_add_cert):
# Mock Cert response
mocked_id = -1
mock_add_cert.return_value = mocked_id
info("Created mock Cert with id: {}".format(mocked_id))
status, cid = db_helper.add_cert(".")
assert_false(status, "Check if method return correct status")
assert_equal(cid, mocked_id, "Check if method returned correct id")
def test_calculate_distance_zero(self):
base = "test"
target = base
info("Base keyword: {}".format(base))
info("Target keyword: {}".format(target))
l = calculate_levenstein(base, target)
assert_type(l, int, "Check if proper type is returned")
assert_equal(l, 0, "Check if proper distance is calculated")
def test_add_baddie_correct(self, mock_add_baddie):
mocked_id = 1
mock_add_baddie.return_value = mocked_id
info("Created mock Baddie with id: {}".format(mocked_id))
cid = db_helper.add_baddie(None, None, None, None, None, None, None)
assert_type(cid, int, "Check if id is correct int")
assert_equal(cid, mocked_id, "Check if method returned correct id")
# TODO More unit tests
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_database_creation(self, client_with_db):
client = client_with_db[0]
endpoint = '/server/create_db'
headers = {
"X-API-Key": AUTH_API_KEY
}
info("GET {}".format(endpoint))
response = client.get(BASE_PATH + endpoint, headers=headers)
assert_equal(response.status_code, 200, "Check status code")
j = data_to_json(response.data)
field = "message"
expected_value = "Database created."
assert_dict_contains_key(j, field, "Check if dict contains given key - \"{}\"".format(field))
assert_equal(j[field], expected_value, "Check if item \"{}\" is equal to \"{}\"".format(field, expected_value))
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_match_keyword(self, mock_goodie):
fake = Faker()
mocked_keyword = fake.domain_word()
# Mock Goodies response
mock_goodie.return_value = [{'good_keyword': mocked_keyword}]
info("Created mock Goodie with keyword: {}".format(mocked_keyword))
domain = "{}x.com".format(mocked_keyword)
info("Requested domain - {}".format(domain))
l = match_keyword(domain)
assert_type(l, tuple, "Check if proper tuple is returned")
assert_true(l[0], "Check if keyword matches domain")
assert_equal(l[1], mocked_keyword,
"Check if returned keyword is equal to mocked one")
def test_details_crtsh(self, client_with_db):
client = client_with_db[0]
endpoint = '/details/crtsh'
data = {'url': 'example.com'}
headers = {'Content-Type': "application/json"}
info("POST {}".format(endpoint))
response = client.post(BASE_PATH + endpoint,
data=json.dumps(data),
headers=headers)
assert_equal(response.status_code, 200, "Check status code")
j = data_to_json(response.data)
field = "details"
assert_dict_contains_key(
j, field,
"Check if dict contains given key - \"{}\"".format(field))
field = "caid"
assert_dict_contains_key(
j['details'], field,
"Check if dict contains given key - \"{}\"".format(field))
field = "registered_at"
assert_dict_contains_key(
j['details'], field,
"Check if dict contains given key - \"{}\"".format(field))
field = "subject"
assert_dict_contains_key(
j['details'], field,
"Check if dict contains given key - \"{}\"".format(field))
field = "org_name"
assert_dict_contains_key(
j['details']['subject'], field,
"Check if dict contains given key - \"{}\"".format(field))
field = "country"
assert_dict_contains_key(
j['details']['subject'], field,
"Check if dict contains given key - \"{}\"".format(field))
field = "issuer"
assert_dict_contains_key(
j['details'], field,
"Check if dict contains given key - \"{}\"".format(field))
field = "common_name"
assert_dict_contains_key(
j['details']['issuer'], field,
"Check if dict contains given key - \"{}\"".format(field))
field = "multi_dns_amount"
assert_dict_contains_key(
j['details'], field,
"Check if dict contains given key - \"{}\"".format(field))
def test_details_ip_by_url_wrong_url(self, client_with_db):
client = client_with_db[0]
endpoint = '/details/ip_by_url'
data = {
'url': 'hppt://no_url'
}
headers = {
'Content-Type': "application/json"
}
info("POST {} with URL: {}".format(endpoint, 'hppt://no_url'))
response = client.post(BASE_PATH + endpoint, data=json.dumps(data), headers=headers)
j = data_to_json(response.data)
assert_equal(response.status_code, 202, "Check status code")
field = "message"
expected_value = "Correct request but it returned no data"
assert_dict_contains_key(j, field, "Check if dict contains given key - \"{}\"".format(field))
assert_equal(j[field], expected_value, "Check if item \"{}\" is equal to \"{}\"".format(field, expected_value))
def test_verify_domain_in_baddies_not_exists(self, mock_get_all_baddies):
# Mock Baddies response
mocked_list = [{
"domain_name": "example.com"
}, {
"domain_name": "not-example.com"
}]
mock_get_all_baddies.return_value = mocked_list
info("Created mock Baddies list: {}".format(mocked_list))
test_domain = "definitely-not-example.com"
info("Requested domain: {}".format(test_domain))
result = uv.verify_domain_in_baddies(test_domain)
assert_type(result, bool,
"Check if returned result is of correct type")
assert_equal(result, False, "Check if method returned correct verdict")
def test_verify_by_crt(self, client_with_db):
client = client_with_db[0]
endpoint = '/verify/by_crt'
data = {
'url': 'google.com'
}
headers = {
'Content-Type': "application/json"
}
info("POST {}".format(endpoint))
response = client.post(BASE_PATH + endpoint, data=json.dumps(data), headers=headers)
assert_equal(response.status_code, 200, "Check status code")
j = data_to_json(response.data)
field = "status"
expected_value = "good"
assert_dict_contains_key(j, field, "Check if dict contains given key - \"{}\"".format(field))
assert_equal(j[field], expected_value, "Check if item \"{}\" is equal to \"{}\"".format(field, expected_value))
def test_details_keywords(self, client_with_db):
client = client_with_db[0]
endpoint = '/details/keywords'
data = {
'url': 'google.com'
}
headers = {
'Content-Type': "application/json"
}
info("POST {} with URL: {}".format(endpoint, 'google.com'))
response = client.post(BASE_PATH + endpoint, data=json.dumps(data), headers=headers)
assert_equal(response.status_code, 200, "Check status code")
j = data_to_json(response.data)
field = "details"
assert_dict_contains_key(j, field, "Check if dict contains given key - \"{}\"".format(field))
field = "matched_keyword"
expected_value = 'google'
assert_dict_contains_key(j['details'], field, "Check if dict contains given key - \"{}\"".format(field))
assert_equal(j['details'][field], expected_value, "Check if item \"{}\" is equal to \"{}\"".format(field, expected_value))
def client_with_db():
info("Set up Flask client with db", pre=True)
flask_app = connexion.FlaskApp(__name__,
specification_dir="../../../src/swagger")
flask_app.app.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI
flask_app.app.config[
'SQLALCHEMY_TRACK_MODIFICATIONS'] = SQLALCHEMY_TRACK_MODIFICATIONS
flask_app.app.json_encoder = json.JSONEncoder
flask_app.add_api('swagger.yml', base_path=BASE_PATH, arguments=arguments)
db = SQLAlchemy(flask_app.app)
environ['COUNT_FAILED'] = '1'
with flask_app.app.test_client() as c:
setup_endpoint = '/server/create_db'
headers = {"X-API-Key": AUTH_API_KEY}
info("GET {}".format(setup_endpoint))
response = c.get(BASE_PATH + setup_endpoint, headers=headers)
assert_equal(response.status_code, 200, "Check status code")
yield c, db
db.session.remove()
db.drop_all()
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_verify_by_sfbrowsing_malicious(self, client_with_db):
client = client_with_db[0]
endpoint = '/verify/by_sfbrowsing'
data = {'url': 'http://malware.testing.google.test/testing/malware/'}
headers = {'Content-Type': "application/json"}
info("POST {} with URL: {}".format(
endpoint, 'http://malware.testing.google.test/testing/malware/'))
response = client.post(BASE_PATH + endpoint,
data=json.dumps(data),
headers=headers)
assert_equal(response.status_code, 200, "Check status code")
j = data_to_json(response.data)
field = "status"
expected_value = "malicious"
assert_dict_contains_key(
j, field,
"Check if dict contains given key - \"{}\"".format(field))
assert_equal(
j[field], expected_value,
"Check if item \"{}\" is equal to \"{}\"".format(
field, expected_value))
def test_verify_by_crt_wrong_data(self, client_with_db):
client = client_with_db[0]
endpoint = '/verify/by_crt'
data = {'temp': 'example.com'}
headers = {'Content-Type': "application/json"}
info("POST {} with URL: {}".format(endpoint, 'example.com'))
response = client.post(BASE_PATH + endpoint,
data=json.dumps(data),
headers=headers)
j = data_to_json(response.data)
assert_equal(response.status_code, 400, "Check status code")
field = "detail"
expected_value = "'url' is a required property"
assert_dict_contains_key(
j, field,
"Check if dict contains given key - \"{}\"".format(field))
assert_equal(
j[field], expected_value,
"Check if item \"{}\" is equal to \"{}\"".format(
field, expected_value))
field = "title"
expected_value = "Bad Request"
assert_dict_contains_key(
j, field,
"Check if dict contains given key - \"{}\"".format(field))
assert_equal(
j[field], expected_value,
"Check if item \"{}\" is equal to \"{}\"".format(
field, expected_value))
