Attendees: Johan L, Shayna, Ivan, Mikael, Matthew, Enrique, Hannah, Alex
0 - Agenda bash
1 - Project review
a. General
- Discuss whether we should move some of Roland's project repos (which
have been moved under Sunet) to be under IdPy:
- SUNET/openid4v - ??
- SUNET/satosa-idpy - frontend - becomes part of SATOSA
- SUNET/satosa-openid4vci - extension to proxy - becomes MR under
SATOSA
- SUNET/fedservice - under idpy
- SUNET/idpy-sdjwt - under idpy
- Need time to understand - should probably slack Roland about
what changes they are introducing
- Also there is a document that explains the process for adopting the
code under IdPy which Ivan was going to share.
b. OIDC libraries - https://github.com/IdentityPython (idpy-oidc,
JWTConnect-Python-CryptoJWT, etc)
- New MR(s) with Nikos introducing changes around resource indicators/
audience policies. The internal fork is also being synced with the
upstream.
c. Satosa - https://github.com/IdentityPython/SATOSA
- trying to get to release for LDAP plugin changes
d. pySAML2 - https://github.com/IdentityPython/pysaml2
- Want to make sure latest releases will work together (both Satosa and
pySAML2)
- trying to get to release for typing changes for the entity
categories
e. Any other project (pyFF, djangosaml2, pyMDOC-CBOR, etc)
- Enrique mentioned in issue in pyFF, where entities in different
federations have the same entity id. One possibility is that it
may be the
same entity registered to different federations, but also it could be two
different entities in different federations but they have the same entity
id. Enrique has the use case in Seamless Access, where entities are
registered in two different federations, in different entity
categories. He
needs to be able to merge certain entity attributes in this case.
- The issue and Enrique's notes on it can be found here:
https://github.com/IdentityPython/pyFF/issues/289
- The way things are now, the entity in the first federation would
be overwritten by the one in the second federation.
- We may want to merge different entity categories, which may
differ from one federation to another.
- For filtering in mdq, we would need the attributes, which could
have different values in different federations, to be merged.
- Enrique's PR was merged to allow select pipe to be able to
produce a list of entities with duplicates. But the
overwriting happens
before the select pipe - it happens in the load pipe - all
the entities
from all the sources are squashed into one dictionary, keyed
by entity id.
- One idea would be to keep the entities keyed not only by entity
id but also by metadata service in the load pipe, but there
is some concern
that this could introduce problems. When the user requests an
entity id,
how would we know which one to choose? Could this be handled
in the MDQ
service? Would the rest of the attributes give a fairly good
heuristic to
distinguish between those cases? The select pipe can default
to doing it
the way things currently work - overwriting the first with
the second - or
use a heuristic downstream to either merge the duplicated
entities or keep
them separate since they are different. Mikael warns that we
need to be
careful not to change the default heuristic - otherwise we
might break all
federations. A new heuristic would need to be approved for
each aggregator.
We need to better define what happens when we get conflicts
so someone will
be notified, instead of just getting the last loaded. We will need a
feature flag so we don't break deployments.
- Ivan wants to establish if this a current problem, or if we are
trying to think ahead to a potential problem, especially in
the case where
the entity ids are the same in two different federations but
the actual
entities are different. We should document that we make the
assumption that
there will not be different entities in different federations
that will
have the same entity id. However, If they are the same entity but in
different federations, there is an issue with the entity
exposing different
things in each federation.
- Merging multi-value attributes: What if there is an entity with
an entity category in InCommon (say, "hide from discovery")
that is not
available when that same entity is in eduGain? If we merge
them, something
that was not intentional would happen. Need to examine these
things more
thoughtfully before doing merging - some are based on policy.
- PyFF - Microsoft EntraID causes a problem with hash marks in
entity ids. pyFF doesn't support getting it by url, only by sha1sum. pyFF
refuses to load a file when hash marks appear in it.
- pyMDOC-CBOR
- will create an MR around a request for an improvement
2 - AOB
- Welcome to Alex - he has been working with Ivan looking at the
proxy/Satosam, focusing on projects under GÉANT CoreAII (formerly
eduteams). He has a lot of experience with different languages and
libraries, and has a lot of ideas on how we can approach things and
structure things better.
- Need to create a list of questions generated from Matthew's efforts to
write his own IdP / test SP, then work through a few of them at a time
weekly.
Enrique Pérez Arnaud has asked me to draw attention to notes he added to a
pyFF gihub issue, regarding duplicate entity ids in pyFF in different
federations. The notes can be found here:
https://github.com/IdentityPython/pyFF/issues/289#
I will also add this link to the discussion of this issue in the IdPy
developers meeting yesterday. The notes from that meeting will be out later
today.
Thank you,
Shayna Atkinson
SCG
*Idpy meeting 27 January 2025*
Attendees: Johan L, Shayna, Ivan, Mikael, Matthew, Enrique, Hannah
0 - Agenda bash
1 - Project review
a. General -
- Documentation pain points run-through / mock saml workflow / mock oidc
workflow
- Matthew has a github repo that mocks up a SAML authentication flow
using pytest. Pysaml is needed for a client to write more
than one identity
provider, and a service provider to test those identity providers -
https://github.com/xenophonf/mock-saml-flow
- Has a configuration for IdP and SP from his Satosa
configuration.
- There is some documentation for the configuration, but one
challenge is the configuration is entirely a mapping. There's
no typing
hints, things aren't discoverable in his development environment.
- Doesn't want to get into Flask, just wants to concentrate on
using what paysaml2 calls a Server and a Client. However, there is no
documentation on the classes and methods to use.
- No API documentation
- the simple examples included in code base just tell you how to
run it; not how to use the code
- one option is to go to the example code and try to figure out
how to develop an SP or IdP, but reading the source code is
really hard.
- what is repoze?
- it's not clear where to start. First guess is to start in idp_
uwsgi.py, skimming for things like url routes (where do
authentication requests come in/go out?). Only able to
find a SSO class.
How is this invoked?
- Conclusion: it takes too long to figure out how to find the
basics of what you need to know.
- Another option - test suite. Not successful here either.
- Next option - reading through Satosa code. Found Server class.
There are no type annotations, no document string for the
method to create.
There is some document strings for the other functions, some
params, some
information, but not enough to know what to use when. Found the
create_authn_response() method but there is no information on
what should
be provided for a good saml response or what structure it
should follow -
the only way to get this information is trial and error.
- idpy-oidc documentation looked more promising
- Encouraged by newer style for the documentation page.
- Wanted to write a small RP - looked at client documentation
- There is a workflow, describing the process and a high level
overview of how oidc RPs work. Very helpful.
- API documentation is lacking. No method signatures. For
example, is issuer_id the only argument the begin() method
takes? But the
Tier1 API design is good.
- No examples on how to instantiate the IdP
- Left reading through the source code again, trying to intuit
from example code and test code how to do it.
- When looking to write code to have a test OP (to test RP) -
Server code - the documentation only tells you how the
configuration
directives work. No API calls, no example code, no examples of
instantiation.
- SQLAlchemy ORM is an example of great documentation on how to
get going - type annotations, explaining what each parameter
is for, etc.
- For mock saml - took 2 months to write 179 lines of code
- Kushal has tried to document some examples -
https://kushaldas.in/learningsaml - unfortunately this starts from
a place beyond where Matthew's knowledge is
- Ivan is the person Matthew and Hannah will need to talk to to
get their project going. First focus on SAML backend for Service, SAML
Frontend for Idp. This won't give the complete picture but
it's a start.
- For Service:
https://github.com/IdentityPython/SATOSA/blob/master/src/satosa/backends/sa…,
especially authn_request and authn_response
- For an IDP:
https://github.com/IdentityPython/SATOSA/blob/master/src/satosa/frontends/s…,
esp handle_authn_request and _handle_authn_response
- Ivan acknowledges there is not developer documentation
- initial step to address docstrings
- Need to define public API methods and documentation - this
would 90-95% of what you can do with SAML
- The examples are old, and sometimes create confusion (for
example, the Server in pysaml2 is an IdP, the Server in
examples is a wsgi
server, the Server in Satosa is a proxy server).
- A referenced example against a SAML trace would be very
helpful
b. OIDC libraries - https://github.com/IdentityPython (idpy-oidc,
JWTConnect-Python-CryptoJWT, etc)
c. Satosa - https://github.com/IdentityPython/SATOSA
- LDAP plugin release coming
- Matthew will have a new SATOSA Docker image out new week
d. pySAML2 - https://github.com/IdentityPython/pysaml2
- release coming to address xml enc changes and introducing types around
entity categories from Frederik and Johan.
e. Any other project (pyFF, djangosaml2, pyMDOC-CBOR, etc)
- Roland's code has been moved under Sunet - mostly related to openid
federation and credential/wallet. Let's have a discussion whether some of
these need to be moved under IdPy
- SUNET/openid4v
- SUNET/satosa-idpy
- SUNET/satosa-openid4vci
- SUNET/fedservice
- SUNET/idpy-sdjwt
2 - AOB
3 - Action items
- pull out questions Matthew raised one by one and document them
- For example some classes were machine generated based on schema
changes (Matthew suspected this) - perhaps we should add docstrings to
explain how/when this was don
Attendees: Johan L, Shayna, Ivan, Mikael, Hannah, Matthew
0 - Agenda bash
1 - Project review
a. General -
- Find a new time slot for a weekly meeting - Mondays 12-13 UTC
- Find a time slot for a review of "documentation pain points"
meeting with Matthew E -we will take time from the 27 January meeting
- Ivan will send a message to the board, to discuss transitioning to
a different model (running services)
b. OIDC libraries - https://github.com/IdentityPython (idpy-oidc,
JWTConnect-Python-CryptoJWT, etc)
- Roland - discussion of PRs in stages vs one big one - Ivan will reach
out to him again. Mikael reports there is a workshop going on
about handing
over the keys to the kingdom.
- there will be a PR coming regarding audience policies
- before the open id connect frontend/library can release a new
token, and include an audience as a claim in the token, this
audience can
be setup with certain rules. There is a specification in the
RFC that the
client can request certain audiences can be included in the
token, in the
audience claim, using the resource indicator.
- How the OP will decide if they will do this or not is more
complicated. The OP will process the request and will see the
client wants
the audiences in the auth claim, so it applies a filter. But
what if it
doesn't? How does it signal that it didn't respect what the client
requested? No matter what, ultimately the OP will decide
which audiences go
into the auth claim.
- But what if the policy changes over time? The OP may be reloaded
with a new policy. The client will use a token or give one to
an RS, and we
need to take into consideration that the policy may have changed when
replying from the different endpoints where the audience can have
participation.
- What happens if we can't refresh our access token because a
policy changed? What happens if you are allowed to do more
things than were
requested? The potential change over time spans is the tricky
part, and may
cause the OP to deny a request.
- Need to introduce a hook in the right places where the audience
will be set/returned/displayed to apply the policy needed.
- Nikos has gone through the PR Roland opened - looks good and was
tested - will be merged.
c. Satosa - https://github.com/IdentityPython/SATOSA
- Ivan (speaking for both SATOSA and pysaml2) will work on the next
stages of release, incorporating different categories of PRs -
he has some
changes locally but hasn't pushed them yet
- username, ldap plugins
- Johan's request for typings
- support xml encoding version 1.1 (?)
d. pySAML2 - https://github.com/IdentityPython/pysaml2
- Making sure compatible with python 3.13 - should do this with all
code. Has been addressed for pyff (see below)
e. Any other project (pyFF, djangosaml2, pyMDOC-CBOR, etc)
- Conversations with Enrique around pyff - need discussion with spec
authors around trustinfo elements- Matthew Stewart will ask the working
group for their help to expand on the specification and
capabilities. There
are some questions about processing the list of preferred/exclusively
trusted identity providers, done through the services metadata or another
structure - a JSON payload with a list of sets of IdPs. During the
processing of the list, it is possible that what has already
been processed
is getting overwritten. It shouldn't happen that the same list should be
entered twice. How should this be handled? Should it be up to the
implementers; should we throw an error or a warning? Need to
determine how
to handle these edge cases. Should this invalidate the service
such that we
don't continue to process its metadata? Should we skip the
repeated entity,
use the last entity, etc?
- Mikael added a github action to make sure they can build pyff with
latest python release. This should probably be done for all code.
2 - AOB
- Change meeting invite and ensure Enrique and Alex are added
- Matthew is going to post his mock SAML workflow writeup to the
idpy-discuss list. He is doing a similar writeup for the idpy-oidc
libraries. It is a narrow example of the authentication flow,
mocking up an
OP and RP, simulating a request and response and processing the response.
He may be able to share some of that with us at the next meeting. It is
using pytest but not simulating things like a web browser.
Attendees: Shayna, Ivan, Mikael, Matthew, Hannah
This meeting was a 2025 kickoff. We discussed ideas, goals and plans for
the IdPy project so that we can keep momentum going and make a better
experience for deployers, developers, and end users.
- Ivan's take: Idpy provides tooling that you can put together in a
flexible manner. But only if you know what you're doing!
- Not a lot of people are using these tools that are provided because
the domain is complex, and the way they are being provided is
not optimal.
- there could be a push to move from tooling/libraries to running
services
- configuration is mostly done for you, with minimal changes
- this might also convince people to contribute back, as they
would not be spending as much time getting things set up
- this would include adding more documentation and improving the
documentation that is there
- this probably needs to be a board level discussion; Leif needs
to agree; GEANT and Christos
- then get buy-in from the users like Giuseppe, CESNET, and
stakeholders
- Nikos working on oidc parts, Mikael and Enrique are working on
pyff
- There are resourcing issues
- need a dedicated person for idpy tools to combine tools as a
service, and someone to help with UX parts
- Alex is working closely with Ivan - looking at SATOSA, pysaml2
- Matthew - are there resources we should be reaching out to ?
Ivan: there is a divide between opensource projects and financing.
- GÉANT finances many projects/tools/services, including some of
the IdPy projects
- Who is using SATOSA? Italian government and some agencies,
SUNET, GÉANT (Core AI, incubator projects), Italian
federation, CESnet
(czech) and CERN. Norwegian projects (NORDnet, CSC)
- Mikael: It will probably be easier to get testing/ quality
assurance help than pure development
- There seems to be a lack of a plan
- What are the priorities? Can we adopt some sort of project
management process? For instance, how do we get single logout
incorporated?
- The calls are supposed to help with that, but right now there is
nothing official to keep a plan in place and keep it moving forward.
- The time is the issue.
- We can use Github's project functionalities - have planning
calls, use Kanban?
- We should Increase the cadence of this meeting to weekly instead
of bi-weekly
- Need to plan for new features/capabilities, protocol changes
from the things we us : for example from OIDC /OpendID foundation
- Need to address usability - deployer, developer, end-user
- the meeting becomes a check-in - what are you working on, what's
finished, what's in your way? And also sprint planning /
customer delivery,
product backlog annual review
- We need to formalize that in meeting agenda - 10 minutes backlog
grooming (are we working on the right things at the right
time?). Then what
are you working on? What have we finished? What's blocking
progress? Can we
connect people?
- Do we need to check in with the board? Maybe give the board a
monthly report showing our progress. This will drum up
further support for
the project.
- May need to change the meeting time.
- Ivan is currently spending 2 days a month on idpy tools - he is
hoping to increase this
Steps to focus on before next meeting:
- We should invite Enrique & Alex to the meeting - also try to find a
time to meet on a weekly basis
- Ivan can send a message to the board, to discuss transitioning to a
different model (running services)
- Ivan will work on the next stages of release, incorporating different
categories of PRs.
- Shayna will look into/ learn about what we can use from the Agile
methodology to improve our meetings/project direction
- Matthew would like to see documentation be a first priority. Mikael
echoed Matthew's frustration with the current state of documentation.
Examples of good documentation that help a developer get set up quickly:
SQL Alchemy documentation (deploying an ORM); another is the Typer python
package for building CLI. We should initially focus on:
- pysaml2 documentation - HOW to use classes, functions, constants?
- deployment guide for SATOSA
