From 7c638b245a4573b83f7027069e609c51f3da6bca Mon Sep 17 00:00:00 2001 From: Josip Mrden Date: Wed, 20 Mar 2024 12:19:12 +0100 Subject: [PATCH] Add SAML authentication auth module --- release/debian/conffiles | 1 + release/rpm/memgraph.spec.in | 1 + src/auth/CMakeLists.txt | 4 ++ src/auth/reference_modules/saml/saml.py | 51 +++++++++++++++++++ src/auth/reference_modules/saml/settings.json | 30 +++++++++++ 5 files changed, 87 insertions(+) create mode 100644 src/auth/reference_modules/saml/saml.py create mode 100644 src/auth/reference_modules/saml/settings.json diff --git a/release/debian/conffiles b/release/debian/conffiles index 125dfed845..4578de95fa 100644 --- a/release/debian/conffiles +++ b/release/debian/conffiles @@ -1,4 +1,5 @@ /etc/memgraph/memgraph.conf /etc/memgraph/apoc_compatibility_mappings.json /etc/memgraph/auth_module/ldap.example.yaml +/etc/memgraph/auth_module/saml/settings.json /etc/logrotate.d/memgraph diff --git a/release/rpm/memgraph.spec.in b/release/rpm/memgraph.spec.in index f0ce3044e7..23cd052bbf 100644 --- a/release/rpm/memgraph.spec.in +++ b/release/rpm/memgraph.spec.in @@ -134,6 +134,7 @@ echo "Don't forget to switch to the 'memgraph' user to use Memgraph" || exit 1 %config(noreplace) "/etc/memgraph/memgraph.conf" %config(noreplace) "/etc/memgraph/apoc_compatibility_mappings.json" %config(noreplace) "/etc/memgraph/auth_module/ldap.example.yaml" +%config(noreplace) "/etc/memgraph/auth_module/saml/settings.json" %config(noreplace) "/etc/logrotate.d/memgraph" @CPACK_RPM_USER_INSTALL_FILES@ diff --git a/src/auth/CMakeLists.txt b/src/auth/CMakeLists.txt index 49c8258c4d..527be0a323 100644 --- a/src/auth/CMakeLists.txt +++ b/src/auth/CMakeLists.txt @@ -29,3 +29,7 @@ install(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/reference_modules/ldap.py DESTINATION lib/memgraph/auth_module) install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/reference_modules/ldap.example.yaml DESTINATION /etc/memgraph/auth_module) +install(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/reference_modules/saml/saml.py + DESTINATION lib/memgraph/auth_module/saml) +install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/reference_modules/saml/settings.json + DESTINATION /etc/memgraph/auth_module/saml) diff --git a/src/auth/reference_modules/saml/saml.py b/src/auth/reference_modules/saml/saml.py new file mode 100644 index 0000000000..64c655f738 --- /dev/null +++ b/src/auth/reference_modules/saml/saml.py @@ -0,0 +1,51 @@ +#!/usr/bin/python3 +import io +import json +from os.path import dirname + +from onelogin.saml2.auth import OneLogin_Saml2_Auth +from onelogin.saml2.settings import OneLogin_Saml2_Settings + + +def init_saml_auth(req): + saml_settings = OneLogin_Saml2_Settings(custom_base_path=dirname(__file__)) + auth = OneLogin_Saml2_Auth(req, saml_settings) + return auth + + +def prepare_request(password): + # Dummy password Base64 encoded SAMLResponse assertion to be validated against the x509 certificate + # Delete this part as the Base64 encoded SAMLResponse needs to be inserted in the password field + # when communicating with the driver + password = "<?xml version="1.0" encoding="UTF-8"?><samlp:Response Destination="http://localhost:8000/?acs" ID="_4235c1cfe0a90f78b81b" InResponseTo="ONELOGIN_9ce74cd7e77bde48495825f3a0198dd5d92645d2" IssueInstant="2024-03-19T14:49:30.420Z" Version="2.0" xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol" xmlns:xs="http://www.w3.org/2001/XMLSchema"><saml:Issuer Format="urn:oasis:names:tc:SAML:2.0:nameid-format:entity" xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion">https://saml.example.com/entityid</saml:Issuer><Signature xmlns="http://www.w3.org/2000/09/xmldsig#"><SignedInfo><CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/><SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"/><Reference URI="#_4235c1cfe0a90f78b81b"><Transforms><Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/><Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/></Transforms><DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/><DigestValue>uW9J2ryBfm2wjvH53mcm8bauavjJK6x4m8t5LXxlWe0=</DigestValue></Reference></SignedInfo><SignatureValue>LnNqIGIDhSyw592e7XF28iKp+Sc5TS7nLSgfnrNhiqmm0vkDrdWZv2A7cJcDrdpzcVRnLyDPToNLYGPoenctWxfeahdbSyLG04E6CP0oG3WXXizzVHrxUcWpy7RcNlzyItg+X90TOhgQIJkExitVcB4IbWhW6pmFRECG9H/kRa1/isA0m+2+ITRl+kymzBe+ljAtrjWSm1lZz+iR+oGObQ+CwUcbBmY9CHmwinVNDTAvrI0eBljVswwiZAOcNRgIIk5pF/i44VDA5gbLgJ87zfZs46zCYME+9gd0S3yTvXg37eXA9rsgsA+7E2D3XdJLsS87thcIQBgpDac09KFl4Q==</SignatureValue><KeyInfo><X509Data><X509Certificate>MIIC4jCCAcoCCQC33wnybT5QZDANBgkqhkiG9w0BAQsFADAyMQswCQYDVQQGEwJV
SzEPMA0GA1UECgwGQm94eUhRMRIwEAYDVQQDDAlNb2NrIFNBTUwwIBcNMjIwMjI4
MjE0NjM4WhgPMzAyMTA3MDEyMTQ2MzhaMDIxCzAJBgNVBAYTAlVLMQ8wDQYDVQQK
DAZCb3h5SFExEjAQBgNVBAMMCU1vY2sgU0FNTDCCASIwDQYJKoZIhvcNAQEBBQAD
ggEPADCCAQoCggEBALGfYettMsct1T6tVUwTudNJH5Pnb9GGnkXi9Zw/e6x45DD0
RuRONbFlJ2T4RjAE/uG+AjXxXQ8o2SZfb9+GgmCHuTJFNgHoZ1nFVXCmb/Hg8Hpd
4vOAGXndixaReOiq3EH5XvpMjMkJ3+8+9VYMzMZOjkgQtAqO36eAFFfNKX7dTj3V
pwLkvz6/KFCq8OAwY+AUi4eZm5J57D31GzjHwfjH9WTeX0MyndmnNB1qV75qQR3b
2/W5sGHRv+9AarggJkF+ptUkXoLtVA51wcfYm6hILptpde5FQC8RWY1YrswBWAEZ
NfyrR4JeSweElNHg4NVOs4TwGjOPwWGqzTfgTlECAwEAATANBgkqhkiG9w0BAQsF
AAOCAQEAAYRlYflSXAWoZpFfwNiCQVE5d9zZ0DPzNdWhAybXcTyMf0z5mDf6FWBW
5Gyoi9u3EMEDnzLcJNkwJAAc39Apa4I2/tml+Jy29dk8bTyX6m93ngmCgdLh5Za4
khuU3AM3L63g7VexCuO7kwkjh/+LqdcIXsVGO6XDfu2QOs1Xpe9zIzLpwm/RNYeX
UjbSj5ce/jekpAw7qyVVL4xOyh8AtUW1ek3wIw1MJvEgEPt0d16oshWJpoS1OT8L
r/22SvYEo3EmSGdTVGgk3x3s+A0qWAqTcyjr7Q4s/GKYRFfomGwz0TZ4Iw1ZN99M
m0eo2USlSRTVl7QHRTuiuSThHpLKQQ==</X509Certificate></X509Data></KeyInfo></Signature><samlp:Status xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"><samlp:StatusCode Value="urn:oasis:names:tc:SAML:2.0:status:Success"/></samlp:Status><saml:Assertion ID="_a21105ddc0afdee40291" IssueInstant="2024-03-19T14:49:30.420Z" Version="2.0" xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion" xmlns:xs="http://www.w3.org/2001/XMLSchema"><saml:Issuer Format="urn:oasis:names:tc:SAML:2.0:nameid-format:entity" xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion">https://saml.example.com/entityid</saml:Issuer><Signature xmlns="http://www.w3.org/2000/09/xmldsig#"><SignedInfo><CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/><SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"/><Reference URI="#_a21105ddc0afdee40291"><Transforms><Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/><Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/></Transforms><DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/><DigestValue>Ejy3Pk7uxFLa9yS4f/xGUcPkLA+zjDEtYFaXdiKf9ac=</DigestValue></Reference></SignedInfo><SignatureValue>n9K8zVGtISiOKEtv21bBub9CD4vBrCdcj7waZ6GmU2ptg5A/n/VRoVg7a65QTE3K16luY1fNoBSBdQfm1i/oyHhQnHjWZMialJ7skWN+i1rQmtP9OehfVh5hq1ASgGXg6eeZ1/FSXQL6ybVDRKqFc5DEXCGLnYwVnxsFBk9M+6AlqWhNCnKHG8FUQKldXgZJS6LggE6NaqNekrA3f2XHrSblwhGTI3zVViJm1Sy+9duTXQXSoK+z6r59a9kEpygw/DMPI3d7/p/gQStX8WfAblDVp6rzHtaOLqb+sN4LfpR5GiV5Bipq/BSiLXaM2NxSFgk/Ys9KJiCM8Zil95R/oA==</SignatureValue><KeyInfo><X509Data><X509Certificate>MIIC4jCCAcoCCQC33wnybT5QZDANBgkqhkiG9w0BAQsFADAyMQswCQYDVQQGEwJV
SzEPMA0GA1UECgwGQm94eUhRMRIwEAYDVQQDDAlNb2NrIFNBTUwwIBcNMjIwMjI4
MjE0NjM4WhgPMzAyMTA3MDEyMTQ2MzhaMDIxCzAJBgNVBAYTAlVLMQ8wDQYDVQQK
DAZCb3h5SFExEjAQBgNVBAMMCU1vY2sgU0FNTDCCASIwDQYJKoZIhvcNAQEBBQAD
ggEPADCCAQoCggEBALGfYettMsct1T6tVUwTudNJH5Pnb9GGnkXi9Zw/e6x45DD0
RuRONbFlJ2T4RjAE/uG+AjXxXQ8o2SZfb9+GgmCHuTJFNgHoZ1nFVXCmb/Hg8Hpd
4vOAGXndixaReOiq3EH5XvpMjMkJ3+8+9VYMzMZOjkgQtAqO36eAFFfNKX7dTj3V
pwLkvz6/KFCq8OAwY+AUi4eZm5J57D31GzjHwfjH9WTeX0MyndmnNB1qV75qQR3b
2/W5sGHRv+9AarggJkF+ptUkXoLtVA51wcfYm6hILptpde5FQC8RWY1YrswBWAEZ
NfyrR4JeSweElNHg4NVOs4TwGjOPwWGqzTfgTlECAwEAATANBgkqhkiG9w0BAQsF
AAOCAQEAAYRlYflSXAWoZpFfwNiCQVE5d9zZ0DPzNdWhAybXcTyMf0z5mDf6FWBW
5Gyoi9u3EMEDnzLcJNkwJAAc39Apa4I2/tml+Jy29dk8bTyX6m93ngmCgdLh5Za4
khuU3AM3L63g7VexCuO7kwkjh/+LqdcIXsVGO6XDfu2QOs1Xpe9zIzLpwm/RNYeX
UjbSj5ce/jekpAw7qyVVL4xOyh8AtUW1ek3wIw1MJvEgEPt0d16oshWJpoS1OT8L
r/22SvYEo3EmSGdTVGgk3x3s+A0qWAqTcyjr7Q4s/GKYRFfomGwz0TZ4Iw1ZN99M
m0eo2USlSRTVl7QHRTuiuSThHpLKQQ==</X509Certificate></X509Data></KeyInfo></Signature><saml:Subject xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"><saml:NameID Format="urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress">jackson@example.com</saml:NameID><saml:SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer"><saml:SubjectConfirmationData InResponseTo="ONELOGIN_9ce74cd7e77bde48495825f3a0198dd5d92645d2" NotOnOrAfter="2024-03-19T14:54:30.420Z" Recipient="http://localhost:8000/?acs"/></saml:SubjectConfirmation></saml:Subject><saml:Conditions NotBefore="2024-03-19T14:44:30.420Z" NotOnOrAfter="2024-03-19T14:54:30.420Z" xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"><saml:AudienceRestriction><saml:Audience>http://localhost:5000/metadata/</saml:Audience></saml:AudienceRestriction></saml:Conditions><saml:AuthnStatement AuthnInstant="2024-03-19T14:49:30.420Z" SessionIndex="ONELOGIN_9ce74cd7e77bde48495825f3a0198dd5d92645d2" xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"><saml:AuthnContext><saml:AuthnContextClassRef>urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport</saml:AuthnContextClassRef></saml:AuthnContext></saml:AuthnStatement><saml:AttributeStatement xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"><saml:Attribute Name="id" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified"><saml:AttributeValue xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:string">1dda9fb491dc01bd24d2423ba2f22ae561f56ddf2376b29a11c80281d21201f9</saml:AttributeValue></saml:Attribute><saml:Attribute Name="email" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified"><saml:AttributeValue xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:string">jackson@example.com</saml:AttributeValue></saml:Attribute><saml:Attribute Name="firstName" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified"><saml:AttributeValue xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:string">jackson</saml:AttributeValue></saml:Attribute><saml:Attribute Name="lastName" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified"><saml:AttributeValue xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:string">jackson</saml:AttributeValue></saml:Attribute></saml:AttributeStatement></saml:Assertion></samlp:Response>" + return { + "post_data": {"SAMLResponse": password}, + } + + +def authenticate(username, password): + # Validates the assertion using the SAML authentication protocol and authorizes the user + # with the proper role + # Change logic in order to determine the user's respective role + request = prepare_request(password) + auth = init_saml_auth(request) + + auth.process_response(request_id=None) + errors = auth.get_errors() + + if not auth.is_authenticated(): + return {"authenticated": False, "role": ""} + + attrs = auth.get_attributes() + + return {"authenticated": True, "role": "moderator"} + + +if __name__ == "__main__": + # Part specific to Memgraph's communication with the auth module + input_stream = io.FileIO(1000, mode="r") + output_stream = io.FileIO(1001, mode="w") + while True: + params = json.loads(input_stream.readline().decode("ascii")) + ret = authenticate(**params) + output_stream.write((json.dumps(ret) + "\n").encode("ascii")) diff --git a/src/auth/reference_modules/saml/settings.json b/src/auth/reference_modules/saml/settings.json new file mode 100644 index 0000000000..677fa63088 --- /dev/null +++ b/src/auth/reference_modules/saml/settings.json @@ -0,0 +1,30 @@ +{ + "strict": false, + "debug": true, + "sp": { + "entityId": "http://localhost:5000/metadata/", + "assertionConsumerService": { + "url": "http://localhost:8000/?acs", + "binding": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST" + }, + "singleLogoutService": { + "url": "http://localhost:5000/?sls", + "binding": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect" + }, + "NameIDFormat": "urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified", + "x509cert": "", + "privateKey": "" + }, + "idp": { + "entityId": "https://saml.example.com/entityid", + "singleSignOnService": { + "url": "https://mocksaml.com/api/saml/sso", + "binding": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect" + }, + "singleLogoutService": { + "url": "https://app.onelogin.com/trust/saml2/http-redirect/slo/", + "binding": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect" + }, + "x509cert": "MIIC4jCCAcoCCQC33wnybT5QZDANBgkqhkiG9w0BAQsFADAyMQswCQYDVQQGEwJVSzEPMA0GA1UECgwGQm94eUhRMRIwEAYDVQQDDAlNb2NrIFNBTUwwIBcNMjIwMjI4MjE0NjM4WhgPMzAyMTA3MDEyMTQ2MzhaMDIxCzAJBgNVBAYTAlVLMQ8wDQYDVQQKDAZCb3h5SFExEjAQBgNVBAMMCU1vY2sgU0FNTDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALGfYettMsct1T6tVUwTudNJH5Pnb9GGnkXi9Zw/e6x45DD0RuRONbFlJ2T4RjAE/uG+AjXxXQ8o2SZfb9+GgmCHuTJFNgHoZ1nFVXCmb/Hg8Hpd4vOAGXndixaReOiq3EH5XvpMjMkJ3+8+9VYMzMZOjkgQtAqO36eAFFfNKX7dTj3VpwLkvz6/KFCq8OAwY+AUi4eZm5J57D31GzjHwfjH9WTeX0MyndmnNB1qV75qQR3b2/W5sGHRv+9AarggJkF+ptUkXoLtVA51wcfYm6hILptpde5FQC8RWY1YrswBWAEZNfyrR4JeSweElNHg4NVOs4TwGjOPwWGqzTfgTlECAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAAYRlYflSXAWoZpFfwNiCQVE5d9zZ0DPzNdWhAybXcTyMf0z5mDf6FWBW5Gyoi9u3EMEDnzLcJNkwJAAc39Apa4I2/tml+Jy29dk8bTyX6m93ngmCgdLh5Za4khuU3AM3L63g7VexCuO7kwkjh/+LqdcIXsVGO6XDfu2QOs1Xpe9zIzLpwm/RNYeXUjbSj5ce/jekpAw7qyVVL4xOyh8AtUW1ek3wIw1MJvEgEPt0d16oshWJpoS1OT8Lr/22SvYEo3EmSGdTVGgk3x3s+A0qWAqTcyjr7Q4s/GKYRFfomGwz0TZ4Iw1ZN99Mm0eo2USlSRTVl7QHRTuiuSThHpLKQQ==" + } +}