Package: djangosaml2idp2
djangosaml2idpdjangosaml2idp implements the Identity Provider side of the SAML2 protocol for Django.
It builds on top ofPySAML2, and is production-ready.Any contributions, feature requests, proposals, ideas … are welcome! See theCONTRIBUTING documentfor some info.About the forkForked from the originalhttps://github.com/OTA-Insight/djangosaml2idpto provide bugfixes and upgrades to python and django support.
Published tohttps://pypi.org/project/djangosaml2idp2/.InstallationPySAML2 usesXML Security Librarybinary to sign SAML assertions, so you need to install
it either through your operating system package or by compiling the source code. It doesn’t matter where the final executable is installed because
you will need to set the full path to it in the configuration stage. XmlSec is available (at least) for Debian, OSX and Alpine Linux.Now you can install the djangosaml2idp package using pip. This will also install PySAML2 and its dependencies automatically:pip install djangosaml2idpConfiguration & UsageThe first thing you need to do is adddjangosaml2idpto the list of installed apps:INSTALLED_APPS = (
    'django.contrib.admin',
    'djangosaml2idp',
    ...
)Now includedjangosaml2idpin your project by adding it in the url config:from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^idp/', include('djangosaml2idp.urls')),
    url(r'^admin/', admin.site.urls),
    ...
]Run the migrations for the app.In your Django settings, configure your IdP. Configuration follows thePySAML2 configuration. The IdP from the example project looks like this:import saml2
from saml2.saml import NAMEID_FORMAT_EMAILADDRESS, NAMEID_FORMAT_UNSPECIFIED
from saml2.sigver import get_xmlsec_binary

LOGIN_URL = '/login/'
BASE_URL = 'http://localhost:9000/idp'

SAML_IDP_CONFIG = {
    'debug' : DEBUG,
    'xmlsec_binary': get_xmlsec_binary(['/opt/local/bin', '/usr/bin']),
    'entityid': '%s/metadata' % BASE_URL,
    'description': 'Example IdP setup',

    'service': {
        'idp': {
            'name': 'Django localhost IdP',
            'endpoints': {
                'single_sign_on_service': [
                    ('http://localhost:9000/idp/sso/post/', saml2.BINDING_HTTP_POST),
                    ('http://localhost:9000/idp/sso/redirect/', saml2.BINDING_HTTP_REDIRECT),
                ],
                "single_logout_service": [
                    ("http://localhost:9000/idp/slo/post/", saml2.BINDING_HTTP_POST),
                    ("http://localhost:9000/idp/slo/redirect/", saml2.BINDING_HTTP_REDIRECT)
                ],
            },
            'name_id_format': [NAMEID_FORMAT_EMAILADDRESS, NAMEID_FORMAT_UNSPECIFIED],
            'sign_response': True,
            'sign_assertion': True,
            'want_authn_requests_signed': True,
        },
    },

    # Signing
    'key_file': BASE_DIR + '/certificates/private.key',
    'cert_file': BASE_DIR + '/certificates/public.cert',
    # Encryption
    'encryption_keypairs': [{
        'key_file': BASE_DIR + '/certificates/private.key',
        'cert_file': BASE_DIR + '/certificates/public.cert',
    }],
    'valid_for': 365 * 24,
}Notice the configuration requires a private key and public certificate to be available on the filesystem in order to sign and encrypt messages.Next the Service Providers and their configuration need to be added, this is done via the Django admin interface. Add an entry for each SP which speaks to thie IdP.
Add a copy of the local metadata xml, or set a remote metadata url. Add an attribute mapping for user attributes to SAML fields or leave the default mapping which will be prefilled.Several attributes can be overriden per SP. If they aren’t overridden explicitly, they will use the ‘global’ settings which can be configured for your Django installation.
If those aren’t set, some defaults will be used, as indicated in the admin when you configre a SP.
The resulting configuration of a SP, with merged settings of its own and the instance settings and defaults, is shown in the admin as a summary.Further optional configuration optionsIn theSAML_IDP_SPCONFIGsetting you can define aprocessor, its value being a string with dotted path to a class.
This is a hook to customize some access control checks. By default, the includedBaseProcessoris used, which allows every user to login on the IdP.
You can customize this behaviour by subclassing theBaseProcessorand overriding itshas_access(self, request)method. This method should return true or false, depending if the user has permission to log in for the SP / IdP.
The processor has the SP entity ID available asself._entity_id, and received the request (with an authenticated request.user on it) as parameter to thehas_accessfunction.
This way, you should have the necessary flexibility to perform whatever checks you need.
An exampleprocessor subclasscan be found in the IdP of the included example.
Use this metadata xml to configure your SP. Place the metadata xml from that SP in the location specified in the config dict (sp_metadata.xml in the example above).Without custom setting, users will be identified by theUSERNAME_FIELDproperty on the user Model you use. By Django defaults this will be the username.
You can customize which field is used for the identifier by addingSAML_IDP_DJANGO_USERNAME_FIELDto your settings with as value the attribute to use on your user instance.Other settings you can set as defaults to be used if not overriden by an SP areSAML_AUTHN_SIGN_ALG,SAML_AUTHN_DIGEST_ALG, andSAML_ENCRYPT_AUTHN_RESPONSE. They can be set if desired in the django settings, in which case they will be used for all ServiceProviders configuration on this instance if they don’t override it. E.g.:SAML_AUTHN_SIGN_ALG = saml2.xmldsig.SIG_RSA_SHA256
SAML_AUTHN_DIGEST_ALG = saml2.xmldsig.DIGEST_SHA256In case your SP does not properly expose validuntil in metadata, you can provide fallback setting for it using:SAML_IDP_FALLBACK_EXPIRATION_DAYS = 30The default value for the fieldsprocessorandattribute_mappingin theServiceProvidercan be set via the settings (the values displayed here are the defaults):SAML_IDP_SP_FIELD_DEFAULT_PROCESSOR = 'djangosaml2idp.processors.BaseProcessor'
SAML_IDP_SP_FIELD_DEFAULT_ATTRIBUTE_MAPPING = {"email": "email", "first_name": "first_name", "last_name": "last_name", "is_staff": "is_staff", "is_superuser": "is_superuser"}Customizing error handlingdjangosaml2idp renders a very basic error page if it encounters an error, indicating an error occured, which error, and possibly an extra message.
The HTTP status code is dependant on which error occured. It also logs the exception with error severity.
You can customize this by using theSAML_IDP_ERROR_VIEW_CLASSsetting. Set this to a dotted import path to your custom (class based) view in order to use that one.
You’ll likely want this to use your own template and styling to display and error message.
If you subclass the provideddjangosaml2idp.error_views.SamlIDPErrorView, you have the following variables available for use in the template:exceptionthe exception instance that occurredexception_typethe class of the exception that occurredexception_msgthe message from the exception (by doingstr(exception))extra_messageif no specific exception given, a message indicating something went wrong, or an additional message next to theexception_msgThe simplest override is to subclass theSamlIDPErrorViewand only using your own error template.
You can use any Class-Based-View for this; it’s not necessary to subclass the builtin error view.
The example project contains a ready to use example of this; uncomment theSAML_IDP_ERROR_VIEW_CLASSsetting and it will use a custom view with custom template.Multi Factor Authentication supportThere are three main components to adding multiple factor support.Subclass djangosaml2idp.processors.BaseProcessor as outlined above. You will need to override theenable_multifactor()method to check whether or not multifactor should be enabled for a user. (If it should allways be enabled for all users simply hard code to True). By default it unconditionally returns False and no multifactor is enforced.Sublass thedjangosaml2idp.views.ProcessMultiFactorViewview to make the appropriate calls for your environment. Implement your custom verification logic in themultifactor_is_validmethod: this could call a helper script, an internal SMS triggering service, a data source only the IdP can access or an external second factor provider (e.g. Symantec VIP). By default this view will log that it was called then redirect.3. Add an entry to settings.py with a string representing the path to your multifactor view. The first package should be the app name:SAML_IDP_MULTIFACTOR_VIEW = “this.is.the.path.to.your.multifactor.viewRunning the test suiteInstall the dev dependencies inrequirements-dev.txt:pip install -r requirements-dev.txtRun the test suite from the project root:tox -e format  # to run linting
tox -e py3.7-django3.0  # to run the tests
tox -e typing  # to run typechecking, this is allowed to failTests will be ran using CI when opening a merge request as well.Example projectThe directoryexample_projectcontains a barebone demo setup to demonstrate the login-logout functionality.
It consists of a Service Provider implemented withdjangosaml2and an Identity Provider usingdjangosaml2idp.
The readme in that folder contains more information on how to run it.