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
Hey all,
I'm trying to pick some times for a meeting to discuss the current state
of the Identity Python documentation.
https://doodle.com/meeting/participate/id/aQjjKW5b
Best wishes,
Matthew
--
"The reason that ed is the standard editor is to remind you that
things could be worse, and once were." -- Tim Lavoie in comp.lang.lisp
Attendees: Johan W, Shayna, Ivan
0 - Agenda bash
1 - Project review
a. General -
b. OIDC libraries - https://github.com/IdentityPython (idpy-oidc,
JWTConnect-Python-CryptoJWT, etc)
- Ivan chatted with Roland and people from SUNET about the things Roland
has split up into multiple MRs, related to wallets and
federation. This way
they can be reviewed and incorporated slowly into the
idpy-oidc library.
- This work is needed by some people sooner - so need to create a
release from a branch which will be marked as a
development release- e.g.
5.1.dev0.
- This will be considered a pre-release. Regular users will not
get it unless they explicitly request it using a specific flag or
installation (e.g., pip install idpy-oidc=xxxx)
- some things currently in the library may break as part of
this pre-release- tests cannot cover all edge cases
c. Satosa - https://github.com/IdentityPython/SATOSA
- Still trying to get the release out - sometime today hopefully? Will
contact Matthew after tagging and posting to pypi, to address
changes for
the container image due to the loss of samltest.id
- would like to transition to use Poetry like pySAML2 does- makes
it easier to package releases, do version bumps, etc.
d. pySAML2 - https://github.com/IdentityPython/pysaml2
- local cleanup, revamping of dependencies coming up
e. Any other project (pyFF, djangosaml2, pyMDOC-CBOR, etc)
2 - AOB
- Next meeting will be 8 January 2025. Happy Holidays!
*Idpy meeting 20 November 2024*
Attendees: Johan W, Johan L, Shayna, Ivan, Roland, Hannah S, Ali H, Mikael F
0 - Agenda bash
1 - Project review
a. General -
b. OIDC libraries - https://github.com/IdentityPython (idpy-oidc,
JWTConnect-Python-CryptoJWT, etc)
- Roland's big PR - lots of changes to idpyoidc. He will divide into
smaller chunks and issue as PRs.
- upcoming work on audience policies - GRnet
c. Satosa - https://github.com/IdentityPython/SATOSA
- Ivan has prepared new patches/releases - haven't posted but has the
tags locally. Will announce on slack when the new version is available.
- plan to merge in stages
- Ivan has been getting requests to easily setup an environment to
run satosa and run it locally. He has been thinking about doing something
similar to the reflector backend (the reflector backend, instead of going
out to a actual idp, immediately creates a payload and returns a
response).
To start the flow we need a service - create something like the reflector
backend which will act as a frontend. It will directly trigger a
flow when
you try to access it, and once it gets a response it will just show the
response. Then we don't need to involve any other service that acts as an
SP or IdP. Can configure how we want IdP to behave. Frederik from Umea
Universitat - plugin that displayed a page and allowed you to insert your
own values for attributes; it also created several profiles.
Would like to
try and build on this.
- Single logout discussion with Hannah Sebuliba
- Met with Ivan and Ali in January 2024 to try and merge the work she
had done into Satosa. There are some conflicts and Hannah would like
guidance how to proceed.
- In provious discussions, the recommendation was to hide the
single logout capabilities behind a flag in order to control
when they are
enabled, so that changes will not affect existing workflows.
This allows
merging without breaking, and testing and testing and fixing
things as we
go along. Then when everything looks good, either remove the
flag, or keep
it so people have the option to enable or disable the feature.
- Important to document what the new features are - what bindings
are supported, what the checks that are implemented actually
do, verify
messages, signatures, and identifiers within logout request
and response
messages.
- The most important thing is to record what we do with the state.
To support logout we need to keep state, The state has to do with the
sessions, the identifiers of the users, and the identifiers
of requests
that came in and correspond to the logout message. Also
allows us to avoid
attacks where someone could send logout requests using an
identifier they
found somewhere.
- It would be good to update the state diagrams
- Hannah felt an important idea was to move the session handling
to SATOSA rather than SAML ends - this is under discussion
- Ali's work has the storage within SATOSA - some parts of the
storage are in the frontend or backend. There is a map
between frontends
and backends connecting the session. The logout request should not be
specific to only one protocol. This required the session to
be kept within
SATOSA. Currently Ali's work supports Postgres. Can add other
adapters.
Also has the logout enabled flag.
- There are differences in the work Ali and Hannah have done, not
just the protocol but also the flow itself. Hannah has worked on SP
initiated logout - with SAML SPs and only logs out SAML IdPs.
It will not
log out OIDC-based IdPs. Ali worked on the OP initiated
logout. Even so,
the requirements and the state that needs to be kept are very similar.
- Need to get back to original code and review it. Should be able
to merge PRs independently, as long as they are behind the
feature flag.
Storage - abstract managed by the proxy and not related to
the protocols
directly. This will add some complexity before and can be
messy. Ivan is
not totally sure this is the right way. If code is kept
isolated, should
work.
- There was some discussion on 1) whether the flag should be the
same or separate for each protocol. Ivan seemed to think it
should be the
same overall. 2) Whether the logout should work for both protocols (no
matter which protocol initiates the logout, SPs and IdPs from both
protocols are logged out). Ivan thinks eventually it should
work this way
but initially each developer should focus on the protocol
they have been
working with.
- Hannah asks are there any services to use as test RP/OP? At one
time Ivan had done someting simple with Apache module -
modauth openidc
https://github.com/OpenIDC/mod_auth_openidc. Ivan doesn't think
she should worry about that right now. Merge the initial
patches and then
worry about oidc.
d. pySAML2 - https://github.com/IdentityPython/pysaml2
e. Any other project (pyFF, djangosaml2, pyMDOC-CBOR, etc)
- new release coming that will allow filtering of idps based on trust
authority. Discovery service parts are being tested right now.
- two phases - information processed by pyff - produces artifacts
that are fed into thiss-ds and are searchable by users.
- maybe there can be an information session on this during a
future meeting.
2 - AOB
- Roland has big demo on digital wallet coming up in Paris.
- He has created a document with Giuseppe about profiling the federation
specification.
