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))