feat: rebranded from vpn-router to linux-manager.

This commit is contained in:
slawek committed 2026-11-22 09:51:07 +01:00
1 parent 8efe21bfa6
commit 85a1ffa21f
238 files changed
+5010 -3761

No files matched your search

@@ -0,0 +1,982 @@
"""The server's OpenID Provider, for the web service, with python3-oauthlib and python3-jwt.
While oidc.enabled is true, the web service answers OpenID Connect at the issuer linuxmanager.oidc_issuer, its HTTPS site
that Caddy serves; the web service answers it only on the loopback address, where Caddy passes the requests. The users
of the server's directory sign in, with the password and the TOTP code or with a passkey (linuxmanager_passkeys), to its
clients, the service accounts with redirect URIs or grants (linuxmanager_users.client_settings): a client's ID is its name
and its secret its password, sent with HTTP Basic authentication or in the body of the token request; a public client
sends only its ID. A client with allowed groups admits only their members; a service account never signs in as a user.
GET /.well-known/openid-configuration the discovery document
GET /oidc/jwks the public key the ID tokens and the access tokens are signed with
GET, POST /oidc/authorize the authorization code flow, PKCE with S256 required; the sign-in page while
the browser has no session, or with prompt=login or an older one than max_age
POST /oidc/login the sign-in page's form: the name, the password and the code, or a passkey
POST /oidc/passkey begin a sign-in with a passkey: {"id", "options"}
POST /oidc/token exchange a code, a refresh token or a device code for tokens, or a client's
credentials for an access token
POST /oidc/device_authorization begin the device authorization grant (RFC 8628): a device code and a user code
GET, POST /oidc/device the page where the user enters the user code, signs in and is asked to allow
the device
POST /oidc/device/decide allow or deny the device
GET, POST /oidc/userinfo the claims of the user an access token was issued for
GET /oidc/logout end the session, then go to a post-logout redirect URI of the client
The grants: authorization_code for a client with redirect URIs, client_credentials, by which a confidential client
gets an access token as itself, and the device code, as the client's grants give them, each with refresh_token but
client_credentials. A client asks for tokens for a resource, a service account, with resource (RFC 8707), its name or
<issuer>/<name>, or by the resource's scopes it asks for, <resource>:<scope>, of its client scopes; without one the
tokens are for the client itself.
ID tokens are RS256 JWTs signed with KEY, an RSA key the web service makes on its first run on the server, named by the
RFC 7638 thumbprint of its public key, for the client. Access tokens are RS256 JWTs of RFC 9068 with the same key, for
the resource or the client: iss, sub, aud, client_id, iat, exp, jti, scope, roles, the claims of the scopes, and of a
user auth_time and amr. sub is the entryUUID of the user's entry, so a user added again under the same name is another
subject. The scopes: openid, required but with client_credentials, which refuses it; profile, preferred_username and
the names; email; groups, the names of the user's groups; their claims are in the ID token, the access token and the
userinfo answer; and the scopes of the resources. roles are the roles of the resource assigned to the user or service
account or a group of it (linuxmanager_users.roles_held), read at every issue; the ID token and the userinfo answer have
those of the client. A code is valid CODE_SECONDS, an access token and an ID token ACCESS_SECONDS, a refresh token
REFRESH_SECONDS, used once, and a device code DEVICE_SECONDS, polled at most every DEVICE_INTERVAL seconds, 5 more after
each poll that came too soon. A session, the cookie COOKIE of the issuer's /oidc/ path, lasts SESSION_SECONDS. Codes,
tokens, device codes and sessions are kept in the database of linuxmanager_auth as their SHA-256
(linuxmanager_auth.OIDC_SQL); linuxmanager_auth.revoke removes a user's or a service account's. A client is registered by an
administrator, so a user is not asked for consent, but for a device, which the user allows on the server's page.
"""
import base64
import collections
import contextlib
import datetime
import hashlib
import http.cookies
import json
import pathlib
import secrets
import time
import types
import urllib.parse
import jinja2
import jwt
import ldap
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from oauthlib.common import Request, add_params_to_uri
from oauthlib.oauth2 import (AccessDeniedError, FatalClientError, InvalidClientError, InvalidGrantError,
InvalidRequestError, InvalidScopeError, OAuth2Error, UnauthorizedClientError,
UnsupportedGrantTypeError)
from oauthlib.oauth2.rfc6749 import utils
from oauthlib.oauth2.rfc6749.grant_types.base import GrantTypeBase
from oauthlib.oauth2.rfc6749.tokens import random_token_generator
from oauthlib.openid import RequestValidator, Server
from oauthlib.openid.connect.core.exceptions import LoginRequired
import linuxmanager
import linuxmanager_auth
import linuxmanager_ldap
import linuxmanager_passkeys
import linuxmanager_users
KEY = pathlib.Path('/etc/linux-manager/oidc.key')
KEY_BITS = 3072
CODE_SECONDS = 60
ACCESS_SECONDS = 300
REFRESH_SECONDS = 8 * 3600
SESSION_SECONDS = 8 * 3600
DEVICE_SECONDS = 600
DEVICE_INTERVAL = 5
#: The grant type of the device authorization grant.
DEVICE_GRANT = 'urn:ietf:params:oauth:grant-type:device_code'
#: A user code: USER_CODE_LENGTH of these letters, shown in two halves.
USER_CODE_LETTERS = 'BCDFGHJKLMNPQRSTVWXZ'
USER_CODE_LENGTH = 8
COOKIE = 'linux_manager_oidc'
#: The claims of each scope but openid, which gives sub.
SCOPE_CLAIMS = {
'profile': ('preferred_username', 'name', 'given_name', 'family_name'),
'email': ('email',),
'groups': ('groups',),
}
SCOPES = ('openid', *SCOPE_CLAIMS)
#: The authentication methods (RFC 8176) of a sign-in with a password, with a password and a TOTP code, and with a
#: passkey, which verifies the user; a service account's client credentials are its password.
PASSWORD_AMR = ['pwd']
OTP_AMR = ['pwd', 'otp']
PASSKEY_AMR = ['hwk', 'user']
SERVICE_AMR = ['pwd']
TEMPLATE = 'oidc-page.html.j2'
#: The headers of the pages: no framing, and nothing loaded but from the page itself and the server.
PAGE_HEADERS = [('Content-Security-Policy', "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; "
"connect-src 'self'; frame-ancestors 'none'")]
#: The headers of oauthlib's answers that the web service sets itself.
OWN_HEADERS = ('content-type', 'cache-control', 'content-length')
#: A user's sign-in at the OpenID Provider: the user name, when, a datetime, and how (amr).
Session = collections.namedtuple('Session', 'name auth_time amr')
_pages = jinja2.Environment(loader=jinja2.FileSystemLoader(str(linuxmanager.TEMPLATE_DIR)), autoescape=True,
undefined=jinja2.StrictUndefined)
class InvalidTarget(OAuth2Error):
"""A resource that is unknown, or more than one (RFC 8707)."""
error = 'invalid_target'
class AuthorizationPending(OAuth2Error):
"""A device code the user has not yet allowed or denied (RFC 8628)."""
error = 'authorization_pending'
class SlowDown(OAuth2Error):
"""A device code polled sooner than its interval (RFC 8628)."""
error = 'slow_down'
class ExpiredToken(OAuth2Error):
"""A device code that has expired (RFC 8628)."""
error = 'expired_token'
def ensure_key():
"""Make the signing key when it is missing."""
if KEY.is_file() and KEY.stat().st_size:
return
key = rsa.generate_private_key(public_exponent=65537, key_size=KEY_BITS)
KEY.parent.mkdir(parents=True, exist_ok=True)
KEY.touch(mode=0o600)
KEY.chmod(0o600)
KEY.write_bytes(key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
serialization.NoEncryption()))
def private_key():
return serialization.load_pem_private_key(KEY.read_bytes(), None)
def public_jwk(key):
"""The JWK of the key's public key, its kid the RFC 7638 thumbprint."""
numbers = key.public_key().public_numbers()
jwk = {'e': numbers.e, 'kty': 'RSA', 'n': numbers.n}
jwk = {name: linuxmanager_auth.b64encode(value.to_bytes((value.bit_length() + 7) // 8, 'big')) if isinstance(value, int)
else value for name, value in jwk.items()}
thumbprint = hashlib.sha256(json.dumps(jwk, sort_keys=True, separators=(',', ':')).encode()).digest()
return {**jwk, 'kid': linuxmanager_auth.b64encode(thumbprint), 'use': 'sig', 'alg': 'RS256'}
def sign(claims, headers=None):
"""The claims as an RS256 JWT with the key's kid and the headers given."""
key = private_key()
return jwt.encode(claims, key, algorithm='RS256', headers={'kid': public_jwk(key)['kid'], **(headers or {})})
def discovery(issuer, resource_scopes):
"""The discovery document of OpenID Connect Discovery 1.0, with the device authorization endpoint of RFC 8628;
resource_scopes are the scopes of the resources."""
return {
'issuer': issuer,
'authorization_endpoint': f'{issuer}/oidc/authorize',
'token_endpoint': f'{issuer}/oidc/token',
'device_authorization_endpoint': f'{issuer}/oidc/device_authorization',
'userinfo_endpoint': f'{issuer}/oidc/userinfo',
'jwks_uri': f'{issuer}/oidc/jwks',
'end_session_endpoint': f'{issuer}/oidc/logout',
'scopes_supported': [*SCOPES, *resource_scopes],
'response_types_supported': ['code'],
'response_modes_supported': ['query'],
'grant_types_supported': ['authorization_code', 'refresh_token', 'client_credentials', DEVICE_GRANT],
'subject_types_supported': ['public'],
'id_token_signing_alg_values_supported': ['RS256'],
'token_endpoint_auth_methods_supported': ['client_secret_basic', 'client_secret_post', 'none'],
'code_challenge_methods_supported': ['S256'],
'claims_supported': ['iss', 'sub', 'aud', 'exp', 'iat', 'auth_time', 'nonce', 'amr', 'at_hash', 'client_id',
'scope', 'roles', *(claim for claims in SCOPE_CLAIMS.values() for claim in claims)],
}
@contextlib.contextmanager
def directory():
"""A connection to the server's directory as the user manager account, for reading."""
connection = linuxmanager_ldap.manager()
try:
yield connection
finally:
connection.unbind_s()
def account_of(name):
"""A namespace of the linuxmanager_users.summary of the service account of the name, else None."""
if not isinstance(name, str):
return None
with directory() as connection:
try:
user = linuxmanager_users.summary(linuxmanager_users.entry(connection, name))
except linuxmanager_users.Failure:
return None
return types.SimpleNamespace(**user) if user['service'] else None
def client_of(client_id):
"""The client of the ID, a namespace of its linuxmanager_users.summary with client_id, when it is an enabled service
account with redirect URIs or grants; else None."""
account = account_of(client_id)
if account is None or not account.enabled or not (account.redirect_uris or account.grants):
return None
account.client_id = client_id
return account
def resource_of(name):
"""The resource of the name, a namespace of its linuxmanager_users.summary, when it is an enabled service account that
is not internal; else None."""
account = account_of(name)
return account if account is not None and account.enabled and not account.internal else None
def resource_scopes():
"""The scopes of every resource, <resource>:<scope>, sorted."""
with directory() as connection:
users = linuxmanager_users.list_users(connection)['users']
return sorted(f'{user["name"]}:{scope}' for user in users
if user['service'] and user['enabled'] and not user['internal'] for scope in user['resource_scopes'])
def account_claims(connection, name):
"""The summary of the entry of the name and its claims of every scope, with sub; Failure when there is none."""
user = linuxmanager_users.summary(linuxmanager_users.entry(connection, name))
groups = sorted(linuxmanager_users.groups_of(connection, name))
uuid = connection.search_s(linuxmanager_users.dn_of(name), ldap.SCOPE_BASE, attrlist=['entryUUID'])[0][1]['entryUUID']
full = ' '.join(part for part in (user['first_name'], user['last_name']) if part)
claims = {'sub': uuid[0].decode(), 'preferred_username': name, 'name': full or None, 'given_name': user['first_name'],
'family_name': user['last_name'], 'email': user['email'], 'groups': groups}
return user, {claim: value for claim, value in claims.items() if value is not None}
def subject(name, client):
"""The claims of every scope of the user, with sub, when the user may sign in to the client: an enabled, unlocked
user who is not a service account, a member of one of the client's allowed groups when it has any; else None."""
with directory() as connection:
try:
user, claims = account_claims(connection, name)
except linuxmanager_users.Failure:
return None
if user['service'] or not user['enabled'] or user['locked']:
return None
if client.allowed_groups and not set(client.allowed_groups) & set(claims['groups']):
return None
return claims
def service_subject(name):
"""The claims of every scope of the service account, with sub."""
with directory() as connection:
return account_claims(connection, name)[1]
def roles_at(resource, name):
"""The roles of the resource the user or service account holds."""
with directory() as connection:
return linuxmanager_users.roles_held(connection, resource, name)
def claims_of(person, scopes):
"""The claims of the scopes of a subject's claims (subject)."""
return {'sub': person['sub'], **{claim: person[claim] for scope in scopes for claim in SCOPE_CLAIMS.get(scope, ())
if claim in person}}
def target_of(issuer, resource, scopes):
"""The name of the resource a request with the resource parameter, None when absent, and the scopes names, None
for none; InvalidTarget when they name more than one or one that is not a resource."""
names = {scope.partition(':')[0] for scope in scopes if scope not in SCOPES}
if resource is not None:
names.add(resource[len(issuer) + 1:] if isinstance(resource, str) and resource.startswith(f'{issuer}/') else resource)
if not names:
return None
if len(names) > 1:
raise InvalidTarget(description='the resource and the scopes name more than one resource')
name = names.pop()
if resource_of(name) is None:
raise InvalidTarget(description=f'{name} is not a resource')
return name
def scopes_allowed(client, scopes, target, grant_type):
"""Whether the client may ask for the scopes: openid, required but by client_credentials, which refuses it, the
other scopes of SCOPES, and those of its client scopes that belong to the target."""
for scope in scopes:
if scope not in SCOPES and (scope not in client.client_scopes or scope.partition(':')[0] != target):
return False
return ('openid' not in scopes) if grant_type == 'client_credentials' else ('openid' in scopes)
def same_redirect(registered, given):
"""Whether the redirect URI given is the registered one; an http URI of a loopback host may have any port (RFC 8252
7.3)."""
if registered == given:
return True
try:
wanted, found = urllib.parse.urlsplit(registered), urllib.parse.urlsplit(given)
# A port that is not a number makes .port raise ValueError.
wanted.port, found.port
except (ValueError, TypeError, AttributeError):
return False
return wanted.scheme == 'http' and wanted.hostname in linuxmanager_users.LOOPBACK_HOSTS and not found.fragment and \
(wanted.scheme, wanted.hostname, wanted.path, wanted.query) == (found.scheme, found.hostname, found.path, found.query)
def cookie_value(cookies):
"""The value of the session cookie in a Cookie header, or ''."""
try:
morsel = http.cookies.SimpleCookie(cookies or '').get(COOKIE)
except http.cookies.CookieError:
return ''
return morsel.value if morsel is not None else ''
def session_of(cfg, cookies):
"""The unexpired Session the session cookie in a Cookie header names, or None."""
value = cookie_value(cookies)
if not value:
return None
with linuxmanager_auth.database(cfg) as connection:
row = connection.execute('SELECT * FROM oidc_session_get(%s)', (linuxmanager_auth.digest(value),)).fetchone()
return Session(*row) if row else None
def access_token(cfg, request):
"""The access token of a token request: a JWT of RFC 9068 for the request's target, or the client."""
now = int(time.time())
client_id = request.client.client_id
service = request.grant_type == 'client_credentials'
name = client_id if service else request.user
person = service_subject(client_id) if service else request.oidc_person
target = getattr(request, 'oidc_target', None)
claims = {**claims_of(person, request.scopes), 'iss': linuxmanager.oidc_issuer(cfg), 'aud': target or client_id,
'client_id': client_id, 'iat': now, 'exp': now + ACCESS_SECONDS, 'jti': secrets.token_urlsafe(16),
'scope': ' '.join(request.scopes)}
roles = roles_at(target or client_id, name)
if roles:
claims['roles'] = roles
if not service:
claims.update({'auth_time': int(request.auth_time.timestamp()), 'amr': request.amr})
return sign(claims, {'typ': 'at+jwt'})
class Validator(RequestValidator):
"""The checks and the storage of oauthlib's server for the server's clients, users and database.
The grants are those of validate_grant_type, with PKCE S256 for the authorization code. The values of a code, a
token, a device code or a session found are kept on the request as oidc_code, oidc_scopes and oidc_person, the
resource the tokens are for as oidc_target.
"""
def __init__(self, cfg):
super().__init__()
self.cfg = cfg
def fetch(self, sql, values):
with linuxmanager_auth.database(self.cfg) as connection:
return connection.execute(sql, values).fetchone()
def call(self, *statements):
with linuxmanager_auth.database(self.cfg) as connection:
for sql, values in statements:
connection.execute(sql, values)
def session(self, request):
return session_of(self.cfg, request.headers.get('Cookie'))
def check_target(self, request, stored):
"""Refuse a resource parameter that names another resource than the one the grant was made for."""
resource = getattr(request, 'resource', None)
if 'resource' in request.duplicate_params or \
resource is not None and target_of(linuxmanager.oidc_issuer(self.cfg), resource, []) != stored:
raise InvalidTarget(description='the grant was made for another resource', request=request)
request.oidc_target = stored
# Clients.
def validate_client_id(self, client_id, request, *args, **kwargs):
request.client = client_of(client_id)
return request.client is not None
def validate_redirect_uri(self, client_id, redirect_uri, request, *args, **kwargs):
return any(same_redirect(uri, redirect_uri) for uri in request.client.redirect_uris)
def get_default_redirect_uri(self, client_id, request, *args, **kwargs):
return None
def validate_response_type(self, client_id, response_type, client, request, *args, **kwargs):
return response_type == 'code'
def validate_scopes(self, client_id, scopes, client, request, *args, **kwargs):
"""Whether the client may ask for the scopes; the resource they are for is kept as oidc_target."""
if 'resource' in request.duplicate_params:
raise InvalidTarget(description='give one resource', request=request)
try:
request.oidc_target = target_of(linuxmanager.oidc_issuer(self.cfg), getattr(request, 'resource', None), scopes)
except InvalidTarget as error:
raise InvalidTarget(description=error.description, request=request)
return scopes_allowed(client, scopes, request.oidc_target, request.grant_type)
def get_default_scopes(self, client_id, request, *args, **kwargs):
return [] if request.grant_type == 'client_credentials' else ['openid']
def is_pkce_required(self, client_id, request):
return True
def client_authentication_required(self, request, *args, **kwargs):
"""Whether the client must sign the request with its secret: unless it is a public client named by client_id."""
client = client_of(request.client_id)
return client is None or not client.public_client
def authenticate_client(self, request, *args, **kwargs):
"""Check the client's secret, the password of its service account, given with HTTP Basic authentication, its
ID and secret form-encoded (RFC 6749 2.3.1), or in the body; a public client has none."""
name, secret = request.client_id, request.client_secret
header = request.headers.get('Authorization', '')
if header[:6].lower() == 'basic ':
try:
name, _, secret = base64.b64decode(header[6:].strip(), validate=True).decode().partition(':')
except (ValueError, UnicodeDecodeError):
return False
name, secret = urllib.parse.unquote_plus(name), urllib.parse.unquote_plus(secret)
client = client_of(name)
if client is None or client.public_client:
return False
try:
linuxmanager_users.login(name, secret, None)
except linuxmanager_users.Failure:
return False
request.client = client
return True
def authenticate_client_id(self, client_id, request, *args, **kwargs):
"""Accept a public client by its ID."""
client = client_of(client_id)
if client is None or not client.public_client:
return False
request.client = client
return True
def validate_grant_type(self, client_id, grant_type, client, request, *args, **kwargs):
"""The grants of the client: authorization_code with redirect URIs, client_credentials but for a public client,
the device code, and refresh_token with either of the first and the last."""
grants = set(client.grants) - ({'client_credentials'} if client.public_client else set())
if client.redirect_uris:
grants.add('authorization_code')
if 'device_code' in grants:
grants.add(DEVICE_GRANT)
if grants & {'authorization_code', DEVICE_GRANT}:
grants.add('refresh_token')
return grant_type in grants
def validate_user(self, username, password, client, request, *args, **kwargs):
return False
# Codes.
def save_authorization_code(self, client_id, code, request, *args, **kwargs):
self.call(('CALL oidc_code_save(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
(linuxmanager_auth.digest(code['code']), client_id, request.user, request.redirect_uri, request.scopes,
request.nonce, request.code_challenge, request.code_challenge_method, request.auth_time, request.amr,
getattr(request, 'oidc_target', None), CODE_SECONDS)))
def code(self, code):
row = self.fetch('SELECT * FROM oidc_code_get(%s)', (linuxmanager_auth.digest(code),)) if isinstance(code, str) else None
return dict(zip(('client_id', 'name', 'redirect_uri', 'scopes', 'nonce', 'code_challenge', 'code_challenge_method',
'auth_time', 'amr', 'resource'), row)) if row else None
def get_authorization_code_scopes(self, client_id, code, redirect_uri, request):
found = self.code(code)
return found['scopes'] if found else []
def validate_code(self, client_id, code, client, request, *args, **kwargs):
found = self.code(code)
if found is None or found['client_id'] != client_id:
return False
person = subject(found['name'], client)
if person is None:
return False
self.check_target(request, found['resource'])
request.user, request.scopes, request.auth_time, request.amr = found['name'], found['scopes'], found['auth_time'], found['amr']
request.oidc_code, request.oidc_person = found, person
return True
def get_code_challenge(self, code, request):
return request.oidc_code['code_challenge']
def get_code_challenge_method(self, code, request):
return request.oidc_code['code_challenge_method']
def confirm_redirect_uri(self, client_id, code, redirect_uri, client, request, *args, **kwargs):
return redirect_uri == request.oidc_code['redirect_uri']
def get_authorization_code_nonce(self, client_id, code, redirect_uri, request):
return request.oidc_code['nonce']
def invalidate_authorization_code(self, client_id, code, request, *args, **kwargs):
self.call(('CALL oidc_code_delete(%s)', (linuxmanager_auth.digest(code),)))
# Device codes.
def poll_device(self, code, request):
"""Poll the device code for the request's client: with the user's sign-in on the request when the user allowed
it, else the error RFC 8628 gives."""
row = self.fetch('SELECT * FROM oidc_device_poll(%s)', (linuxmanager_auth.digest(code),)) \
if isinstance(code, str) and code else None
found = dict(zip(('client_id', 'scopes', 'resource', 'state', 'name', 'auth_time', 'amr', 'expired', 'too_soon'),
row)) if row else None
if found is None or found['client_id'] != request.client.client_id:
raise InvalidGrantError(description='the device code is unknown', request=request)
if found['expired']:
raise ExpiredToken(description='the device code has expired', request=request)
if found['state'] == 'pending':
raise (SlowDown if found['too_soon'] else AuthorizationPending)(request=request)
if found['state'] == 'denied':
self.call(('CALL oidc_device_delete(%s)', (linuxmanager_auth.digest(code),)))
raise AccessDeniedError(description='the user denied the device', request=request)
person = subject(found['name'], request.client)
if person is None:
raise AccessDeniedError(description=f'{found["name"]} may not sign in to this client', request=request)
self.check_target(request, found['resource'])
request.user, request.scopes, request.auth_time, request.amr = found['name'], found['scopes'], found['auth_time'], found['amr']
request.oidc_person = person
def delete_device(self, code):
self.call(('CALL oidc_device_delete(%s)', (linuxmanager_auth.digest(code),)))
# Tokens.
def token(self, token, kind):
row = self.fetch('SELECT * FROM oidc_token_get(%s, %s)', (linuxmanager_auth.digest(token), kind)) \
if isinstance(token, str) and token else None
return dict(zip(('client_id', 'name', 'scopes', 'auth_time', 'amr', 'resource'), row)) if row else None
def save_bearer_token(self, token, request, *args, **kwargs):
"""Keep the access token and the refresh token; a refresh token that was exchanged is used up. A token of
client_credentials is kept for its service account."""
if request.grant_type == 'client_credentials':
name, auth_time, amr = request.client.client_id, datetime.datetime.now(datetime.timezone.utc), SERVICE_AMR
else:
name, auth_time, amr = request.user, request.auth_time, request.amr
values = (request.client.client_id, name, request.scopes, auth_time, amr, getattr(request, 'oidc_target', None))
statements = [('CALL oidc_token_save(%s, %s, %s, %s, %s, %s, %s, %s, %s)',
(linuxmanager_auth.digest(token['access_token']), 'access', *values, ACCESS_SECONDS))]
if token.get('refresh_token'):
statements.append(('CALL oidc_token_save(%s, %s, %s, %s, %s, %s, %s, %s, %s)',
(linuxmanager_auth.digest(token['refresh_token']), 'refresh', *values, REFRESH_SECONDS)))
if request.grant_type == 'refresh_token':
statements.append(('CALL oidc_token_delete(%s)', (linuxmanager_auth.digest(request.refresh_token),)))
self.call(*statements)
def validate_refresh_token(self, refresh_token, client, request, *args, **kwargs):
found = self.token(refresh_token, 'refresh')
if found is None or found['client_id'] != client.client_id:
return False
person = subject(found['name'], client)
if person is None:
return False
self.check_target(request, found['resource'])
request.user, request.auth_time, request.amr = found['name'], found['auth_time'], found['amr']
request.oidc_scopes, request.oidc_person = found['scopes'], person
return True
def get_original_scopes(self, refresh_token, request, *args, **kwargs):
return request.oidc_scopes
def validate_bearer_token(self, token, scopes, request):
found = self.token(token, 'access')
if found is None or not set(scopes) <= set(found['scopes']):
return False
client = client_of(found['client_id'])
person = subject(found['name'], client) if client else None
if person is None:
return False
request.client, request.user, request.oidc_scopes, request.oidc_person = client, found['name'], found['scopes'], person
return True
def get_userinfo_claims(self, request):
claims = claims_of(request.oidc_person, request.oidc_scopes)
roles = roles_at(request.client.client_id, request.user)
return {**claims, 'roles': roles} if roles else claims
# OpenID Connect.
def finalize_id_token(self, id_token, token, token_handler, request):
now = int(time.time())
id_token.update(claims_of(request.oidc_person, request.scopes))
id_token.update({'iss': linuxmanager.oidc_issuer(self.cfg), 'exp': now + ACCESS_SECONDS,
'auth_time': int(request.auth_time.timestamp()), 'amr': request.amr})
roles = roles_at(request.client.client_id, request.user)
if roles:
id_token['roles'] = roles
return sign(id_token)
def validate_silent_login(self, request):
session = self.session(request)
return session is not None and subject(session.name, request.client) is not None
def validate_silent_authorization(self, request):
return True
def validate_user_match(self, id_token_hint, scopes, claims, request):
"""Whether the user of the session, when there is one, is the subject of an ID token the server signed."""
session = self.session(request) if id_token_hint else None
if session is None:
return True
try:
hint = jwt.decode(id_token_hint, private_key().public_key(), algorithms=['RS256'],
options={'verify_exp': False, 'verify_aud': False})
except jwt.InvalidTokenError:
return False
person = subject(session.name, request.client)
return person is not None and hint.get('sub') == person['sub']
class DeviceCodeGrant(GrantTypeBase):
"""The token request of the device authorization grant (RFC 8628): a device code the user allowed gives an access
token, a refresh token and, with openid, an ID token; until then the request is answered authorization_pending or
slow_down."""
def create_token_response(self, request, token_handler):
headers = self._get_default_headers()
try:
self.validate_token_request(request)
except OAuth2Error as error:
headers.update(error.headers)
return headers, error.json, error.status_code
token = token_handler.create_token(request, refresh_token=True)
if 'openid' in request.scopes:
token['id_token'] = self.request_validator.finalize_id_token(
{'aud': request.client.client_id, 'iat': int(time.time())}, token, token_handler, request)
self.request_validator.save_token(token, request)
self.request_validator.delete_device(request.device_code)
return headers, json.dumps(token), 200
def validate_token_request(self, request):
if request.grant_type != DEVICE_GRANT:
raise UnsupportedGrantTypeError(request=request)
for param in ('grant_type', 'device_code'):
if param in request.duplicate_params:
raise InvalidRequestError(description=f'Duplicate {param} parameter.', request=request)
request.device_code = getattr(request, 'device_code', None)
if not request.device_code:
raise InvalidRequestError(description='Missing device_code parameter.', request=request)
if self.request_validator.client_authentication_required(request):
if not self.request_validator.authenticate_client(request):
raise InvalidClientError(request=request)
elif not self.request_validator.authenticate_client_id(request.client_id, request):
raise InvalidClientError(request=request)
self.validate_grant_type(request)
self.request_validator.poll_device(request.device_code, request)
def user_code_of(value):
"""The user code a user typed, without the dash and spaces, in capitals; '' when it is not one."""
code = ''.join(character for character in (value or '').upper() if character.isalnum())
return code if len(code) == USER_CODE_LENGTH and all(character in USER_CODE_LETTERS for character in code) else ''
def device_authorization(validator, cfg, text, headers):
"""Answer a device authorization request (RFC 8628 3.1): the client, public by client_id or confidential with its
secret, with the device_code grant, the scopes and the resource; the device code, the user code and the
verification URIs."""
issuer = linuxmanager.oidc_issuer(cfg)
request = Request(f'{issuer}/oidc/device_authorization', 'POST', text, headers)
for param in ('scope', 'resource'):
if param in request.duplicate_params:
raise InvalidRequestError(description=f'Duplicate {param} parameter.', request=request)
if validator.client_authentication_required(request):
if not validator.authenticate_client(request):
raise InvalidClientError(request=request)
elif not validator.authenticate_client_id(request.client_id, request):
raise InvalidClientError(request=request)
if not validator.validate_grant_type(request.client.client_id, DEVICE_GRANT, request.client, request):
raise UnauthorizedClientError(description='the client may not use the device authorization grant', request=request)
scopes = utils.scope_to_list(request.scope) or ['openid']
target = target_of(issuer, getattr(request, 'resource', None), scopes)
if not scopes_allowed(request.client, scopes, target, DEVICE_GRANT):
raise InvalidScopeError(description='the client may not ask for these scopes; openid is required', request=request)
device_code = secrets.token_urlsafe(32)
user_code = ''.join(secrets.choice(USER_CODE_LETTERS) for _ in range(USER_CODE_LENGTH))
with linuxmanager_auth.database(cfg) as connection:
connection.execute('CALL oidc_device_save(%s, %s, %s, %s, %s, %s, %s)',
(linuxmanager_auth.digest(device_code), linuxmanager_auth.digest(user_code), request.client.client_id,
scopes, target, DEVICE_INTERVAL, DEVICE_SECONDS))
shown = f'{user_code[:USER_CODE_LENGTH // 2]}-{user_code[USER_CODE_LENGTH // 2:]}'
return document(200, {'device_code': device_code, 'user_code': shown, 'verification_uri': f'{issuer}/oidc/device',
'verification_uri_complete': f'{issuer}/oidc/device?' + urllib.parse.urlencode({'user_code': shown}),
'expires_in': DEVICE_SECONDS, 'interval': DEVICE_INTERVAL})
def device_of(cfg, user_code):
"""The waiting device code of a user code, {client_id, scopes, resource}, or None."""
code = user_code_of(user_code)
if not code:
return None
with linuxmanager_auth.database(cfg) as connection:
row = connection.execute('SELECT * FROM oidc_device_find(%s)', (linuxmanager_auth.digest(code),)).fetchone()
return dict(zip(('client_id', 'scopes', 'resource'), row)) if row else None
def page(status, cfg, title, message='', error='', form=False, request='', name='', headers=(), action='/oidc/login',
device=False, user_code='', decide=False, items=()):
"""An HTML page of TEMPLATE: a message, an error and items; with form the sign-in form, posted to action with the
authorization request, or with device the user code field, with or without the sign-in fields; with decide the
Allow and Deny buttons of the device of the user code."""
body = _pages.get_template(TEMPLATE).render(title=title, message=message, error=error, form=form, request=request,
name=name, issuer=linuxmanager.oidc_issuer(cfg), action=action, device=device,
user_code=user_code, decide=decide, items=list(items))
return status, 'text/html; charset=utf-8', body.encode(), [*PAGE_HEADERS, *headers]
def document(status, value, headers=()):
return status, 'application/json', json.dumps(value, indent=2).encode() + b'\n', list(headers)
def relayed(headers, body, status):
"""An answer of oauthlib's server, without the headers the web service sets."""
kind = next((value for name, value in headers.items() if name.lower() == 'content-type'), 'application/json')
return status, kind, (body or '').encode(), [(name, value) for name, value in headers.items()
if name.lower() not in OWN_HEADERS]
def redirect(location, headers=()):
return 302, 'text/plain; charset=utf-8', b'', [('Location', location), *headers]
def cookie(value, seconds):
return 'Set-Cookie', f'{COOKIE}={value}; Path=/oidc/; Max-Age={seconds}; Secure; HttpOnly; SameSite=Lax'
def sign_in(form):
"""The name and the amr of a sign-in with the form's name, password and code, or its passkey; Failure when it is
refused, ValueError when the passkey's answer is not JSON."""
if form.get('passkey_id'):
with linuxmanager_users.session() as connection:
name = linuxmanager_passkeys.login_complete(connection, form['passkey_id'], json.loads(form.get('credential', '')))
return name, PASSKEY_AMR
name, code = form.get('name', '').strip(), form.get('code', '').strip()
linuxmanager_users.login(name, form.get('password', ''), code or None)
with directory() as connection:
if linuxmanager_users.service(linuxmanager_users.entry(connection, name)):
raise linuxmanager_users.Failure('the name, the password or the code is wrong', 5)
return name, OTP_AMR if code else PASSWORD_AMR
def start_session(cfg, name, amr):
"""Start a session of the user: a namespace of the Session and the header that sets its cookie."""
value = secrets.token_urlsafe(32)
with linuxmanager_auth.database(cfg) as connection:
connection.execute('CALL oidc_session_save(%s, %s, %s, %s)', (linuxmanager_auth.digest(value), name, amr, SESSION_SECONDS))
return types.SimpleNamespace(session=Session(name, datetime.datetime.now(datetime.timezone.utc), amr),
cookie=cookie(value, SESSION_SECONDS))
def authorize(server, cfg, params, headers, fresh=None, name='', error=''):
"""Answer an authorization request, the query or the form params: the sign-in page while the browser has no
session, or with prompt=login or max_age older than the session, else a redirect to the client with a code.
fresh is the session of a sign-in just made, which counts whatever prompt and max_age say; the redirect then sets
its cookie, fresh.cookie. error is why a sign-in failed: the sign-in page shows it, filled with the name.
"""
uri = f'{linuxmanager.oidc_issuer(cfg)}/oidc/authorize?{params}'
try:
scopes, info = server.validate_authorization_request(uri, 'GET', None, headers)
except FatalClientError as error:
return page(error.status_code, cfg, 'The sign-in request is refused', error=error.description or error.error)
except OAuth2Error as error:
if not error.redirect_uri:
return page(error.status_code, cfg, 'The sign-in request is refused', error=error.description or error.error)
return redirect(error.in_uri(error.redirect_uri))
request = info['request']
title = f'Sign in to {request.client.display_name or request.client.client_id}'
if info.get('code_challenge_method') != 'S256':
return redirect(InvalidRequestError(description='PKCE with code_challenge_method S256 is required',
request=request).in_uri(request.redirect_uri))
if error:
return page(401, cfg, title, error=error, form=True, request=params, name=name)
session = fresh.session if fresh else session_of(cfg, headers.get('Cookie'))
max_age = getattr(request, 'max_age', None)
stale = session is not None and isinstance(max_age, str) and max_age.isdigit() and \
time.time() - session.auth_time.timestamp() > int(max_age)
prompt = info.get('prompt') or set()
if session is None or (not fresh and ('login' in prompt or stale)):
if 'none' in prompt:
return redirect(LoginRequired(request=request).in_uri(request.redirect_uri))
return page(200, cfg, title, form=True, request=params, name=name)
if subject(session.name, request.client) is None:
if fresh:
return redirect(AccessDeniedError(description=f'{session.name} may not sign in to this client',
request=request).in_uri(request.redirect_uri), [fresh.cookie])
return page(403, cfg, title, error=f'{session.name} may not sign in here; sign in as another user.', form=True,
request=params)
answer, _, _ = server.create_authorization_response(uri, 'GET', None, headers, scopes, credentials={
'user': session.name, 'auth_time': session.auth_time, 'amr': session.amr})
return redirect(answer['Location'], [fresh.cookie] if fresh else [])
def login(server, cfg, form, headers):
"""Sign a user in with the sign-in page's form, start the session and go on with its authorization request."""
params = form.get('request', '')
name = form.get('name', '').strip()
try:
name, amr = sign_in(form)
except linuxmanager_users.Failure as failure:
return authorize(server, cfg, params, headers, name=name, error=str(failure))
except ValueError:
return authorize(server, cfg, params, headers, name=name, error='the passkey is not accepted')
return authorize(server, cfg, params, headers, fresh=start_session(cfg, name, amr))
def device_page(cfg, status=200, signed_in=False, user_code='', name='', error='', headers=()):
"""The page where the user enters the user code of a device, with the sign-in fields unless signed_in."""
return page(status, cfg, 'Sign in on a device', message='Enter the code the device shows.', error=error,
form=not signed_in, name=name, headers=headers, action='/oidc/device', device=True, user_code=user_code)
def device(cfg, form, headers):
"""The device page's form: sign in when the browser has no session, then ask the user to allow the device of the
user code."""
user_code, fresh = form.get('user_code', ''), None
session = session_of(cfg, headers.get('Cookie'))
if session is None:
try:
name, amr = sign_in(form)
except linuxmanager_users.Failure as failure:
return device_page(cfg, 401, user_code=user_code, name=form.get('name', '').strip(), error=str(failure))
except ValueError:
return device_page(cfg, 401, user_code=user_code, name=form.get('name', '').strip(),
error='the passkey is not accepted')
fresh = start_session(cfg, name, amr)
session = fresh.session
extra = [fresh.cookie] if fresh else []
found = device_of(cfg, user_code)
client = client_of(found['client_id']) if found else None
if client is None:
return device_page(cfg, 400, signed_in=True, user_code=user_code, error='the code is wrong or has expired',
headers=extra)
shown = client.display_name or client.client_id
if subject(session.name, client) is None:
return device_page(cfg, 403, signed_in=True, user_code=user_code, headers=extra,
error=f'{session.name} may not sign in to {shown}')
items = ([f'resource: {found["resource"]}'] if found['resource'] else []) + [f'scope: {scope}' for scope in found['scopes']]
return page(200, cfg, f'Allow {shown}?', message=f'{shown} asks to sign in as {session.name} on a device.',
items=items, decide=True, user_code=user_code_of(user_code), headers=extra)
def decide(cfg, form, headers):
"""Allow or deny the device of the user code as the user of the session."""
session = session_of(cfg, headers.get('Cookie'))
if session is None:
return device_page(cfg, 401, user_code=form.get('user_code', ''), error='sign in first')
found = device_of(cfg, form.get('user_code', ''))
client = client_of(found['client_id']) if found else None
if client is None or subject(session.name, client) is None:
return device_page(cfg, 400, signed_in=True, user_code=form.get('user_code', ''),
error='the code is wrong or has expired')
allowed = form.get('decision') == 'allow'
with linuxmanager_auth.database(cfg) as connection:
decided = connection.execute('SELECT oidc_device_decide(%s, %s, %s, %s, %s)',
(linuxmanager_auth.digest(user_code_of(form['user_code'])), session.name,
session.auth_time, session.amr, allowed)).fetchone()[0]
if not decided:
return device_page(cfg, 400, signed_in=True, error='the code is wrong or has expired')
shown = client.display_name or client.client_id
if allowed:
return page(200, cfg, 'The device is signed in', message=f'{shown} is signed in as {session.name}. You can return '
'to the device.')
return page(200, cfg, 'The device is denied', message=f'{shown} is not signed in.')
def logout(cfg, query, headers):
"""End the session the cookie names, then go to post_logout_redirect_uri, with state, when it is a post-logout
redirect URI of the client that client_id or the audience of id_token_hint names; else show that the user is
signed out."""
values = dict(urllib.parse.parse_qsl(query))
value = cookie_value(headers.get('Cookie'))
if value:
with linuxmanager_auth.database(cfg) as connection:
connection.execute('CALL oidc_session_delete(%s)', (linuxmanager_auth.digest(value),))
client_id = values.get('client_id')
if not client_id and values.get('id_token_hint'):
try:
audience = jwt.decode(values['id_token_hint'], private_key().public_key(), algorithms=['RS256'],
options={'verify_exp': False, 'verify_aud': False}).get('aud')
except jwt.InvalidTokenError:
audience = None
client_id = audience[0] if isinstance(audience, list) and audience else audience
client = client_of(client_id)
target = values.get('post_logout_redirect_uri')
expired = cookie('', 0)
if client is not None and target in client.post_logout_redirect_uris:
return redirect(add_params_to_uri(target, [('state', values['state'])]) if values.get('state') else target, [expired])
return page(200, cfg, 'Signed out', message='You are signed out of the server.', headers=[expired])
def answer(method, target, headers, body):
"""Answer a request of the OpenID Provider: the HTTP status, the content type, the body and [(header, value)]; 404
while oidc.enabled is false. target is the path with the query, headers a mapping of the request's headers and
body its bytes; HEAD is answered as GET."""
path, _, query = target.partition('?')
method = 'GET' if method == 'HEAD' else method
try:
cfg = linuxmanager.load_config()
if not cfg['oidc']['enabled']:
return 404, 'text/plain; charset=utf-8', b'Not found\n', []
issuer = linuxmanager.oidc_issuer(cfg)
headers = dict(headers.items())
text = body.decode('utf-8', 'replace') if body else ''
validator = Validator(cfg)
server = Server(validator, token_expires_in=ACCESS_SECONDS, token_generator=lambda request: access_token(cfg, request),
refresh_token_generator=random_token_generator)
server.grant_types[DEVICE_GRANT] = DeviceCodeGrant(validator)
if (method, path) == ('GET', '/.well-known/openid-configuration'):
return document(200, discovery(issuer, resource_scopes()))
if (method, path) == ('GET', '/oidc/jwks'):
return document(200, {'keys': [public_jwk(private_key())]})
if path == '/oidc/authorize' and method in ('GET', 'POST'):
return authorize(server, cfg, query if method == 'GET' else text, headers)
if (method, path) == ('POST', '/oidc/login'):
return login(server, cfg, dict(urllib.parse.parse_qsl(text)), headers)
if (method, path) == ('POST', '/oidc/passkey'):
return document(200, linuxmanager_passkeys.login_begin())
if (method, path) == ('POST', '/oidc/token'):
return relayed(*server.create_token_response(f'{issuer}{path}', 'POST', text, headers))
if (method, path) == ('POST', '/oidc/device_authorization'):
return device_authorization(validator, cfg, text, headers)
if (method, path) == ('GET', '/oidc/device'):
signed_in = session_of(cfg, headers.get('Cookie')) is not None
return device_page(cfg, signed_in=signed_in, user_code=dict(urllib.parse.parse_qsl(query)).get('user_code', ''))
if (method, path) == ('POST', '/oidc/device'):
return device(cfg, dict(urllib.parse.parse_qsl(text)), headers)
if (method, path) == ('POST', '/oidc/device/decide'):
return decide(cfg, dict(urllib.parse.parse_qsl(text)), headers)
if path == '/oidc/userinfo' and method in ('GET', 'POST'):
return relayed(*server.create_userinfo_response(f'{issuer}{target}', method, text or None, headers))
if (method, path) == ('GET', '/oidc/logout'):
return logout(cfg, query, headers)
return 404, 'text/plain; charset=utf-8', b'Not found\n', []
except OAuth2Error as error:
return error.status_code, 'application/json', error.json.encode(), list(error.headers.items())
except linuxmanager_users.Failure as failure:
return document(400 if failure.status == 2 else 500, {'error': str(failure)})
except (ldap.LDAPError, OSError) as exc:
return document(500, {'error': f'the OpenID Provider failed: {exc}'})
except linuxmanager_auth.DatabaseError as exc:
return document(500, {'error': str(exc)})
except SystemExit as exc:
return document(500, {'error': str(exc.code)})
except ValueError as exc:
return document(400, {'error': 'invalid_request', 'error_description': str(exc)})