Johan, Scott, Hannah, Roland, Heather, Ivan, John P
1 - GitHub review
a. OIDC - https://github.com/IdentityPython
New draft published for the federation draft (see blog
Next step will be to bring it up at the OIDF board meeting to see if anyone is opposed to
making this a standard (meeting on Thursday).
Rewrite of the JWGConnect stack is continuing. Session management is a big component of
the work in progress.
b. Satosa - https://github.com/IdentityPython/SATOSA
Working on IdP hinting, which backend to use, and reworking the base URL to allow it to
have a path. Christos is asking for a way to group front ends and back ends such that they
will only interact with each other, grouping them such that they can only talk to specific
IdPs or they can only talk through a specific backend. This might also be called a
multi-tenant Satosa instance.
• how would the microservices need to change so they react appropriately to the different
groupings? focus has been on the connection points at the front and back end. A
microservice is a backend module. On the config, we could say there is a path to that
class to load it, and it has a unique name. We could have the same python code invoked by
multiple configurations. Given the name is different and the config is different, if we
had groups we could use the microservice in the processing with this configuration, and
the other group could reuse the code with a different configuration.
• The microservice can have resource consuming qualities, so might not want to have
microservices duplicated, because it might consume the same resources.
• We'll have to change the configurations to support this multi-tenant model
• would like to preserve functionality where microservices receive query string
parameters or parts of URL; they'll need to be able to inspect the URL that was
invoked at the start of the flow.
Expect a new release soon for this and for pySAML2. CI is being reworked; will be
experimenting with GitHub actions.
Question re: Single logout (SLO) for Satosa - with a proxy, there is no actual state,
which makes SLO difficult. The service knows that the user came from the proxy, and it
will tell the proxy to logout the user. The proxy will get the logout request, it will
probably have the nameid, but there is no mapping to which was the initial home IdP of the
user, and what is the actual identifier for the user.
• Be aware that if anyone tries to solve this using third-party cookies, it will not work
with Safari users, probably won't work with Firefox, and soon won't work with
Google users (general deprecation of third-party cookies).
for a write up of the problems.
• To do this, there will have to be a place to store the state, probably on the server
side. We could also generate an identifier that only Satosa knows about, store it
somewhere (by default in memory, but could be a database). We could use these to map back
to the IdP and invoke an SLO request. This only addresses the ability to start the SLO
process, but there are other issues to consider beyond creating the request. There are
different types of logouts (front channel, back channel) that would need to be supported.
Front channel would require each service be contacted to logout, which won't work.
c. pySAML2 - https://github.com/IdentityPython/pysaml2
Will be adding a new filter on the metadata side to handle scopes. Will also be merging
some PRs from Giuseppe. Expect a new release soon.
d. pyFF - https://github.com/IdentityPython/pyFF