From 6c1fbd84ed498841b252ba7eb3a7d81a9ea77d15 Mon Sep 17 00:00:00 2001 From: Sixto Martin Date: Mon, 17 Jun 2024 19:26:28 +0200 Subject: [PATCH] Fix tests due expiration and unavailable remote idps, remove freezegun and update dependencies from demos (#412) * Fix tests. Remove freezegun * Update Django Demo dependency to avoid reported vulnerabilities * Update Tornado Demo dependency to avoid reported vulnerabilities * Fix lint * Removing references to Python3.5 as CI failed due pip install cert issues --- .github/workflows/python-package.yml | 1 - README.md | 1 - demo-django/requirements.txt | 2 +- demo-tornado/requirements.txt | 2 +- pyproject.toml | 3 +- setup.py | 2 - .../invalids/not_before_failed.xml.base64 | 2 +- ...pted_assertion_encrypted_nameid.xml.base64 | 2 +- ...d_response_without_inresponseto.xml.base64 | 2 +- .../saml2_tests/idp_metadata_parser_test.py | 16 ++-- .../src/OneLogin/saml2_tests/response_test.py | 54 ++++++------- tests/src/OneLogin/saml2_tests/utils_test.py | 76 +++++++++++-------- 12 files changed, 87 insertions(+), 76 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 109cfae2..c251a1ed 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -18,7 +18,6 @@ jobs: fail-fast: false matrix: python-version: - - "3.5" - "3.6" - "3.7" - "3.8" diff --git a/README.md b/README.md index e651cdcf..f197e552 100644 --- a/README.md +++ b/README.md @@ -217,7 +217,6 @@ This folder contains a Pyramid project that will be used as demo to show how to This folder contains a Tornado project that will be used as demo to show how to add SAML support to the Tornado Framework. ``views.py`` (with its ``settings.py``) is the main Flask file that has all the code, this file uses the templates stored at the ``templates`` folder. In the ``saml`` folder we found the ``certs`` folder to store the X.509 public and private key, and the SAML toolkit settings (``settings.json`` and ``advanced_settings.json``). -It requires python3.5 (it's using tornado 6.0.3) #### setup.py #### diff --git a/demo-django/requirements.txt b/demo-django/requirements.txt index 3cf7bed6..c4d84d80 100644 --- a/demo-django/requirements.txt +++ b/demo-django/requirements.txt @@ -1,2 +1,2 @@ -Django==4.1.10 +Django==4.1.13 python3-saml diff --git a/demo-tornado/requirements.txt b/demo-tornado/requirements.txt index 9b1bd132..0f21d3ed 100644 --- a/demo-tornado/requirements.txt +++ b/demo-tornado/requirements.txt @@ -1 +1 @@ -tornado==6.3.3 +tornado==6.4.1 diff --git a/pyproject.toml b/pyproject.toml index 5d1bcd6b..d59ef2fb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -52,13 +52,12 @@ flake8 = { version = ">=3.6.0, <=5.0.0", optional = true} #ipdb = "^0.13.9" #[tool.poetry.group.test.dependencies] -freezegun= { version = ">=0.3.11, <=1.1.0", optional = true} pytest = { version = ">=4.6.11", optional = true} coverage = { version = ">=4.5.2", optional = true} #pylint = ">=1.9.4" [tool.poetry.extras] -test = ["flake8", "freezegun", "pytest", "coverage"] +test = ["flake8", "pytest", "coverage"] #[tool.poetry.group.test] #optional = true diff --git a/setup.py b/setup.py index 352ea892..1c28f73e 100644 --- a/setup.py +++ b/setup.py @@ -14,7 +14,6 @@ 'Intended Audience :: System Administrators', 'Operating System :: OS Independent', 'Programming Language :: Python :: 2.7', - 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', @@ -43,7 +42,6 @@ extras_require={ 'test': ( 'coverage>=4.5.2', - 'freezegun>=0.3.11, <=1.1.0', # 'pylint>=1.9.4', 'flake8>=3.6.0, <=5.0.0', 'pytest>=4.6', diff --git a/tests/data/responses/invalids/not_before_failed.xml.base64 b/tests/data/responses/invalids/not_before_failed.xml.base64 index de62f5e4..8a2ffd3d 100644 --- a/tests/data/responses/invalids/not_before_failed.xml.base64 +++ b/tests/data/responses/invalids/not_before_failed.xml.base64 @@ -1 +1 @@ -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 \ No newline at end of file diff --git a/tests/data/responses/valid_encrypted_assertion_encrypted_nameid.xml.base64 b/tests/data/responses/valid_encrypted_assertion_encrypted_nameid.xml.base64 index 83431af3..33eaf12d 100644 --- a/tests/data/responses/valid_encrypted_assertion_encrypted_nameid.xml.base64 +++ b/tests/data/responses/valid_encrypted_assertion_encrypted_nameid.xml.base64 @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/tests/data/responses/valid_response_without_inresponseto.xml.base64 b/tests/data/responses/valid_response_without_inresponseto.xml.base64 index 120a6c3c..64fcaba0 100644 --- a/tests/data/responses/valid_response_without_inresponseto.xml.base64 +++ b/tests/data/responses/valid_response_without_inresponseto.xml.base64 @@ -1 +1 @@ -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 \ No newline at end of file diff --git a/tests/src/OneLogin/saml2_tests/idp_metadata_parser_test.py b/tests/src/OneLogin/saml2_tests/idp_metadata_parser_test.py index 3d027ed1..a8ea3f9b 100644 --- a/tests/src/OneLogin/saml2_tests/idp_metadata_parser_test.py +++ b/tests/src/OneLogin/saml2_tests/idp_metadata_parser_test.py @@ -46,16 +46,16 @@ def testGetMetadata(self): Tests the get_metadata method of the OneLogin_Saml2_IdPMetadataParser """ with self.assertRaises(Exception): - data = OneLogin_Saml2_IdPMetadataParser.get_metadata('http://google.es') + data = OneLogin_Saml2_IdPMetadataParser.get_metadata('http://google.es', validate_cert=False) try: - data = OneLogin_Saml2_IdPMetadataParser.get_metadata('https://idp.testshib.org/idp/shibboleth') + data = OneLogin_Saml2_IdPMetadataParser.get_metadata('https://raw.githubusercontent.com/SAML-Toolkits/python3-saml/master/tests/data/metadata/testshib-providers.xml', validate_cert=False) self.assertTrue(data is not None and data is not {}) except URLError: pass def testGetMetadataWithHeaders(self): - data = OneLogin_Saml2_IdPMetadataParser.get_metadata('https://samltest.id/saml/providers', + data = OneLogin_Saml2_IdPMetadataParser.get_metadata('https://raw.githubusercontent.com/SAML-Toolkits/python3-saml/master/tests/data/metadata/testshib-providers.xml', validate_cert=False, headers={'User-Agent': 'Mozilla/5.0'}) self.assertIsNotNone(data) self.assertIn(b'entityID=', data) @@ -65,10 +65,10 @@ def testParseRemote(self): Tests the parse_remote method of the OneLogin_Saml2_IdPMetadataParser """ with self.assertRaises(Exception): - data = OneLogin_Saml2_IdPMetadataParser.parse_remote('http://google.es') + data = OneLogin_Saml2_IdPMetadataParser.parse_remote('http://google.es', validate_cert=False) try: - data = OneLogin_Saml2_IdPMetadataParser.parse_remote('https://idp.testshib.org/idp/shibboleth') + data = OneLogin_Saml2_IdPMetadataParser.parse_remote('https://raw.githubusercontent.com/SAML-Toolkits/python3-saml/master/tests/data/metadata/testshib-providers.xml', validate_cert=False) except URLError: xml = self.file_contents(join(self.data_path, 'metadata', 'testshib-providers.xml')) data = OneLogin_Saml2_IdPMetadataParser.parse(xml) @@ -96,10 +96,10 @@ def testParseRemoteWithHeaders(self): """ Tests the parse_remote method passing headers of the OneLogin_Saml2_IdPMetadataParser """ - data = OneLogin_Saml2_IdPMetadataParser.parse_remote('https://samltest.id/saml/providers') - self.assertEqual(data['idp']['entityId'], 'https://samltest.id/saml/idp') + data = OneLogin_Saml2_IdPMetadataParser.parse_remote('https://raw.githubusercontent.com/SAML-Toolkits/python3-saml/master/tests/data/metadata/testshib-providers.xml', validate_cert=False) + self.assertEqual(data['idp']['entityId'], 'https://idp.testshib.org/idp/shibboleth') self.assertIsNotNone(data['idp']['singleSignOnService']['url']) - self.assertIsNotNone(data['idp']['x509certMulti']) + self.assertIsNotNone(data['idp']['x509cert']) def testParse(self): """ diff --git a/tests/src/OneLogin/saml2_tests/response_test.py b/tests/src/OneLogin/saml2_tests/response_test.py index 87a8c246..b0bf66b5 100644 --- a/tests/src/OneLogin/saml2_tests/response_test.py +++ b/tests/src/OneLogin/saml2_tests/response_test.py @@ -4,10 +4,8 @@ from base64 import b64decode from lxml import etree -from datetime import datetime -from datetime import timedelta -from freezegun import freeze_time import json +import sys from os.path import dirname, join, exists import unittest from xml.dom.minidom import parseString @@ -1565,22 +1563,28 @@ def testIsInValidEncIssues_2(self): request_data = { 'script_name': '', 'request_uri': '?acs', + 'http_host': 'pytoolkit.com', + 'server_port': 8000 } - for separate_port in (False, True): - if separate_port: - request_data.update({ - 'http_host': 'pytoolkit.com', - 'server_port': 8000, - }) - else: - request_data.update({ - 'http_host': 'pytoolkit.com:8000', - }) - - message_2 = self.file_contents(join(self.data_path, 'responses', 'valid_encrypted_assertion_encrypted_nameid.xml.base64')) - response_6 = OneLogin_Saml2_Response(settings_2, message_2) - self.assertFalse(response_6.is_valid(request_data)) - self.assertEqual('The attributes have expired, based on the SessionNotOnOrAfter of the AttributeStatement of this Response', response_6.get_error()) + + message_2 = self.file_contents(join(self.data_path, 'responses', 'valid_encrypted_assertion_encrypted_nameid.xml.base64')) + response_6 = OneLogin_Saml2_Response(settings_2, message_2) + + if sys.version_info > (3, 2, 0): + with self.assertWarns(Warning): + self.assertFalse(response_6.is_valid(request_data)) + self.assertEqual('The attributes have expired, based on the SessionNotOnOrAfter of the AttributeStatement of this Response', response_6.get_error()) + + request_data = { + 'script_name': '', + 'request_uri': '?acs', + 'http_host': 'pytoolkit.com:8000', + } + + message_2 = self.file_contents(join(self.data_path, 'responses', 'valid_encrypted_assertion_encrypted_nameid.xml.base64')) + response_6 = OneLogin_Saml2_Response(settings_2, message_2) + self.assertFalse(response_6.is_valid(request_data)) + self.assertEqual('The attributes have expired, based on the SessionNotOnOrAfter of the AttributeStatement of this Response', response_6.get_error()) def testIsInValidCert(self): """ @@ -1863,15 +1867,11 @@ def testIsValidWithoutInResponseTo(self): xml = self.file_contents(join(self.data_path, 'responses', 'valid_response_without_inresponseto.xml.base64')) response = OneLogin_Saml2_Response(settings, xml) - not_on_or_after = datetime.strptime('2014-02-19T09:37:01Z', '%Y-%m-%dT%H:%M:%SZ') - not_on_or_after -= timedelta(seconds=150) - - with freeze_time(not_on_or_after): - self.assertTrue(response.is_valid({ - 'https': 'on', - 'http_host': 'pitbulk.no-ip.org', - 'script_name': 'newonelogin/demo1/index.php?acs' - })) + self.assertTrue(response.is_valid({ + 'https': 'on', + 'http_host': 'pitbulk.no-ip.org', + 'script_name': 'newonelogin/demo1/index.php?acs' + })) def testIsValidRaisesExceptionWhenRaisesArgumentIsTrue(self): """ diff --git a/tests/src/OneLogin/saml2_tests/utils_test.py b/tests/src/OneLogin/saml2_tests/utils_test.py index f1e66453..1bb59b65 100644 --- a/tests/src/OneLogin/saml2_tests/utils_test.py +++ b/tests/src/OneLogin/saml2_tests/utils_test.py @@ -6,6 +6,7 @@ from lxml import etree from os.path import dirname, join, exists import unittest +import sys from xml.dom.minidom import parseString from onelogin.saml2 import compat @@ -175,10 +176,14 @@ def testGetselfhost(self): exception = context.exception self.assertIn("No hostname defined", str(exception)) - request_data = { - 'server_name': 'example.com' - } - self.assertEqual('example.com', OneLogin_Saml2_Utils.get_self_host(request_data)) + if sys.version_info > (3, 2, 0): + request_data = { + 'server_name': 'example.com' + } + with self.assertWarns(Warning) as context: + self_host = OneLogin_Saml2_Utils.get_self_host(request_data) + + self.assertEqual('example.com', self_host) request_data = { 'http_host': 'example.com' @@ -223,37 +228,48 @@ def testGetSelfURLhost(self): } self.assertEqual('http://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) - request_data['server_port'] = '80' - self.assertEqual('http://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) + if sys.version_info > (3, 2, 0): + with self.assertWarns(Warning) as context: + request_data['server_port'] = '80' + self.assertEqual('http://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) - request_data['server_port'] = '81' - self.assertEqual('http://example.com:81', OneLogin_Saml2_Utils.get_self_url_host(request_data)) + with self.assertWarns(Warning) as context: + request_data['server_port'] = '81' + self.assertEqual('http://example.com:81', OneLogin_Saml2_Utils.get_self_url_host(request_data)) - request_data['server_port'] = '443' - self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) + with self.assertWarns(Warning) as context: + request_data['server_port'] = '443' + self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) del request_data['server_port'] request_data['https'] = 'on' self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) - request_data['server_port'] = '444' - self.assertEqual('https://example.com:444', OneLogin_Saml2_Utils.get_self_url_host(request_data)) + if sys.version_info > (3, 2, 0): + with self.assertWarns(Warning) as context: + request_data['server_port'] = '444' + self.assertEqual('https://example.com:444', OneLogin_Saml2_Utils.get_self_url_host(request_data)) - request_data['server_port'] = '443' - request_data['request_uri'] = '' - self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) + with self.assertWarns(Warning) as context: + request_data['server_port'] = '443' + request_data['request_uri'] = '' + self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) - request_data['request_uri'] = '/' - self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) + with self.assertWarns(Warning) as context: + request_data['request_uri'] = '/' + self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) - request_data['request_uri'] = 'onelogin/' - self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) + with self.assertWarns(Warning) as context: + request_data['request_uri'] = 'onelogin/' + self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) - request_data['request_uri'] = '/onelogin' - self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) + with self.assertWarns(Warning) as context: + request_data['request_uri'] = '/onelogin' + self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) - request_data['request_uri'] = 'https://example.com/onelogin/sso' - self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) + with self.assertWarns(Warning) as context: + request_data['request_uri'] = 'https://example.com/onelogin/sso' + self.assertEqual('https://example.com', OneLogin_Saml2_Utils.get_self_url_host(request_data)) request_data2 = { 'request_uri': 'example.com/onelogin/sso' @@ -728,47 +744,47 @@ def testAddSign(self): self.assertIn('', xml_authn_signed) res = parseString(xml_authn_signed) - ds_signature = res.firstChild.firstChild.nextSibling.nextSibling + ds_signature = res.firstChild.firstChild.nextSibling.nextSibling.nextSibling self.assertIn('ds:Signature', ds_signature.tagName) xml_authn_dom = parseString(xml_authn) xml_authn_signed_2 = compat.to_string(OneLogin_Saml2_Utils.add_sign(xml_authn_dom.toxml(), key, cert)) self.assertIn('', xml_authn_signed_2) res_2 = parseString(xml_authn_signed_2) - ds_signature_2 = res_2.firstChild.firstChild.nextSibling.nextSibling + ds_signature_2 = res_2.firstChild.firstChild.nextSibling.nextSibling.nextSibling self.assertIn('ds:Signature', ds_signature_2.tagName) xml_authn_signed_3 = compat.to_string(OneLogin_Saml2_Utils.add_sign(xml_authn_dom.firstChild.toxml(), key, cert)) self.assertIn('', xml_authn_signed_3) res_3 = parseString(xml_authn_signed_3) - ds_signature_3 = res_3.firstChild.firstChild.nextSibling.nextSibling + ds_signature_3 = res_3.firstChild.firstChild.nextSibling.nextSibling.nextSibling self.assertIn('ds:Signature', ds_signature_3.tagName) xml_authn_etree = etree.fromstring(xml_authn) xml_authn_signed_4 = compat.to_string(OneLogin_Saml2_Utils.add_sign(xml_authn_etree, key, cert)) self.assertIn('', xml_authn_signed_4) res_4 = parseString(xml_authn_signed_4) - ds_signature_4 = res_4.firstChild.firstChild.nextSibling.nextSibling + ds_signature_4 = res_4.firstChild.firstChild.nextSibling.nextSibling.nextSibling self.assertIn('ds:Signature', ds_signature_4.tagName) xml_authn_signed_5 = compat.to_string(OneLogin_Saml2_Utils.add_sign(xml_authn_etree, key, cert)) self.assertIn('', xml_authn_signed_5) res_5 = parseString(xml_authn_signed_5) - ds_signature_5 = res_5.firstChild.firstChild.nextSibling.nextSibling + ds_signature_5 = res_5.firstChild.firstChild.nextSibling.nextSibling.nextSibling.nextSibling self.assertIn('ds:Signature', ds_signature_5.tagName) xml_logout_req = b64decode(self.file_contents(join(self.data_path, 'logout_requests', 'logout_request.xml.base64'))) xml_logout_req_signed = compat.to_string(OneLogin_Saml2_Utils.add_sign(xml_logout_req, key, cert)) self.assertIn('', xml_logout_req_signed) res_6 = parseString(xml_logout_req_signed) - ds_signature_6 = res_6.firstChild.firstChild.nextSibling.nextSibling + ds_signature_6 = res_6.firstChild.firstChild.nextSibling.nextSibling.nextSibling self.assertIn('ds:Signature', ds_signature_6.tagName) xml_logout_res = b64decode(self.file_contents(join(self.data_path, 'logout_responses', 'logout_response.xml.base64'))) xml_logout_res_signed = compat.to_string(OneLogin_Saml2_Utils.add_sign(xml_logout_res, key, cert)) self.assertIn('', xml_logout_res_signed) res_7 = parseString(xml_logout_res_signed) - ds_signature_7 = res_7.firstChild.firstChild.nextSibling.nextSibling + ds_signature_7 = res_7.firstChild.firstChild.nextSibling.nextSibling.nextSibling self.assertIn('ds:Signature', ds_signature_7.tagName) xml_metadata = self.file_contents(join(self.data_path, 'metadata', 'metadata_settings1.xml'))