feature: the OpenID Provider has the client credentials and device authorization grants, public clients, and service accounts as resources with roles and scopes in JWT access tokens.
Release / release (push) Successful in 17s
Release / release (push) Successful in 17s
This commit is contained in:
1 parent
3ed79c7563
commit
3c4c5a8c32
15 files changed
+1572
-240
No files matched your search
@@ -18,6 +18,9 @@ vpnRouterConsoleLogin TRUE to the system over the local socket.
|
||||
|
||||
ou=pki holds the router's PKI (vpnrouter_pki): an entry per CA, and under it an entry per
|
||||
certificate the CA issued. Private keys are readable by root alone, the database's root DN.
|
||||
|
||||
ou=roles holds the roles of the resources of the OpenID Provider: an entry per role,
|
||||
cn=<resource>:<role>, whose members are the groups, users and service accounts it is assigned to.
|
||||
"""
|
||||
|
||||
import os
|
||||
@@ -39,6 +42,7 @@ GROUPS = f'ou=groups,{BASE}'
|
||||
SERVICES = f'ou=services,{BASE}'
|
||||
POLICIES = f'ou=policies,{BASE}'
|
||||
PKI = f'ou=pki,{BASE}'
|
||||
ROLES = f'ou=roles,{BASE}'
|
||||
DEFAULT_POLICY = f'cn=default,{POLICIES}'
|
||||
TOTP_PARAMS = f'cn=totp,{POLICIES}'
|
||||
MANAGER = f'cn=user-manager,{SERVICES}'
|
||||
@@ -71,7 +75,12 @@ OVERLAYS = ('ppolicy', 'otp')
|
||||
#: passkey of the user as JSON (vpnrouter_passkeys). A service account with vpnRouterRedirectUri
|
||||
#: is a client of the OpenID Provider (vpnrouter_oidc): the URIs it is sent back to after a sign-in
|
||||
#: and, vpnRouterPostLogoutRedirectUri, after a sign-out, and vpnRouterAllowedGroup, the DNs of the
|
||||
#: groups whose members may sign in to it. vpnRouterAuthority is a CA of the PKI: its
|
||||
#: groups whose members may sign in to it; vpnRouterGrantType, the further grants it may use,
|
||||
#: vpnRouterPublicClient, whether it has no secret, and vpnRouterClientScope, the scopes of
|
||||
#: resources it may ask for, as <resource>:<scope>. A service account with vpnRouterResourceScope
|
||||
#: is a resource of the OpenID Provider with those scopes. vpnRouterRole is a role of a resource,
|
||||
#: named cn=<resource>:<role>, with the DNs of the groups and accounts it is assigned to in
|
||||
#: member. vpnRouterAuthority is a CA of the PKI: its
|
||||
#: certificate and CRL (cACertificate and certificateRevocationList of RFC 4523), its key, the
|
||||
#: CSR it waits with for the offline root, the number of its last CRL, where the CRL came from,
|
||||
#: and when it was retired. vpnRouterCertificate is a certificate a CA issued, named by its
|
||||
@@ -112,18 +121,29 @@ SCHEMA_ATTRIBUTE_TYPES = (
|
||||
"OpenID Connect client' EQUALITY caseExactMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{1024} )",
|
||||
f"( {SCHEMA_OID}.1.19 NAME 'vpnRouterAllowedGroup' DESC 'VPN router: a group whose members may sign in to an "
|
||||
"OpenID Connect client' EQUALITY distinguishedNameMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )",
|
||||
f"( {SCHEMA_OID}.1.20 NAME 'vpnRouterGrantType' DESC 'VPN router: a grant an OpenID Connect client may use besides "
|
||||
"the authorization code' EQUALITY caseExactMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{64} )",
|
||||
f"( {SCHEMA_OID}.1.21 NAME 'vpnRouterPublicClient' DESC 'VPN router: whether an OpenID Connect client has no secret' "
|
||||
"EQUALITY booleanMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 SINGLE-VALUE )",
|
||||
f"( {SCHEMA_OID}.1.22 NAME 'vpnRouterClientScope' DESC 'VPN router: a scope of a resource an OpenID Connect client "
|
||||
"may ask for' EQUALITY caseExactMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{128} )",
|
||||
f"( {SCHEMA_OID}.1.23 NAME 'vpnRouterResourceScope' DESC 'VPN router: a scope of a resource of the OpenID Provider' "
|
||||
"EQUALITY caseExactMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{64} )",
|
||||
)
|
||||
SCHEMA_OBJECT_CLASSES = (
|
||||
f"( {SCHEMA_OID}.2.1 NAME 'vpnRouterAccount' DESC 'VPN router: properties of a user or a Manager-only account' "
|
||||
"SUP top AUXILIARY MAY ( mail $ vpnRouterScope $ displayName $ description $ vpnRouterConsoleLogin $ "
|
||||
"vpnRouterConsoleAccount $ vpnRouterWireGuardPeer $ vpnRouterPasskey $ vpnRouterRedirectUri $ "
|
||||
"vpnRouterPostLogoutRedirectUri $ vpnRouterAllowedGroup ) )",
|
||||
"vpnRouterPostLogoutRedirectUri $ vpnRouterAllowedGroup $ vpnRouterGrantType $ vpnRouterPublicClient $ "
|
||||
"vpnRouterClientScope $ vpnRouterResourceScope ) )",
|
||||
f"( {SCHEMA_OID}.2.2 NAME 'vpnRouterAuthority' DESC 'VPN router: a CA of the PKI' SUP top STRUCTURAL MUST cn "
|
||||
"MAY ( cACertificate $ certificateRevocationList $ vpnRouterPrivateKey $ vpnRouterCertificateRequest $ "
|
||||
"vpnRouterCRLNumber $ vpnRouterCRLSource $ vpnRouterRetired ) )",
|
||||
f"( {SCHEMA_OID}.2.3 NAME 'vpnRouterCertificate' DESC 'VPN router: a certificate a CA of the PKI issued' SUP top "
|
||||
"STRUCTURAL MUST serialNumber MAY ( cn $ userCertificate $ vpnRouterPrivateKey $ vpnRouterKind $ vpnRouterTemplate $ "
|
||||
"vpnRouterSubjectAltName $ vpnRouterNotAfter $ vpnRouterRevoked $ vpnRouterRevocationReason ) )",
|
||||
f"( {SCHEMA_OID}.2.4 NAME 'vpnRouterRole' DESC 'VPN router: a role of a resource of the OpenID Provider' SUP top "
|
||||
"STRUCTURAL MUST cn MAY ( description $ member ) )",
|
||||
)
|
||||
|
||||
#: The TOTP parameters: digits, the OID of HMAC-SHA1, seconds per time step, and the time steps accepted before and after now.
|
||||
@@ -152,6 +172,7 @@ ACCESS = (
|
||||
f'to attrs=oathSecret by dn.exact="{MANAGER}" =w by * none',
|
||||
f'to dn.subtree="{USERS}" by dn.exact="{MANAGER}" manage by * read',
|
||||
f'to dn.subtree="{GROUPS}" by dn.exact="{MANAGER}" manage by * read',
|
||||
f'to dn.subtree="{ROLES}" by dn.exact="{MANAGER}" manage by * read',
|
||||
'to * by * read',
|
||||
)
|
||||
|
||||
@@ -333,7 +354,7 @@ def provision():
|
||||
database = _ensure_database(connection)
|
||||
_ensure_overlays(connection, database)
|
||||
_ensure_entry(connection, BASE, {'objectClass': [b'dcObject', b'organization'], 'dc': [b'vpn-router'], 'o': [b'vpn-router']})
|
||||
for unit in (USERS, GROUPS, SERVICES, POLICIES, PKI):
|
||||
for unit in (USERS, GROUPS, SERVICES, POLICIES, PKI, ROLES):
|
||||
_ensure_entry(connection, unit, {'objectClass': [b'organizationalUnit'], 'ou': [unit.split(',')[0][3:].encode()]})
|
||||
_ensure_entry(connection, DEFAULT_POLICY, {
|
||||
'objectClass': [b'organizationalRole', b'pwdPolicy'],
|
||||
|
||||
@@ -3,28 +3,45 @@
|
||||
While oidc.enabled is true, the web service answers OpenID Connect at the issuer vpnrouter.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 router's directory sign in, with the password and the TOTP code or with a passkey (vpnrouter_passkeys), to its
|
||||
clients, the service accounts with redirect URIs (vpnrouter_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 client with allowed
|
||||
groups admits only their members; a service account never signs in as a user.
|
||||
clients, the service accounts with redirect URIs or grants (vpnrouter_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 are signed with
|
||||
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 or a refresh token for tokens
|
||||
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
|
||||
|
||||
ID tokens are RS256 JWTs signed with KEY, an RSA key the web service makes on its first run on the router, named by
|
||||
the RFC 7638 thumbprint of its public key. 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; profile, preferred_username and the names; email; groups,
|
||||
the names of the user's groups; their claims are in the ID token and the userinfo answer. A code is valid
|
||||
CODE_SECONDS, an access token and an ID token ACCESS_SECONDS, a refresh token REFRESH_SECONDS, used once. A session,
|
||||
the cookie COOKIE of the issuer's /oidc/ path, lasts SESSION_SECONDS. Codes, tokens and sessions are kept in the
|
||||
database of vpnrouter_auth as their SHA-256 (vpnrouter_auth.OIDC_SQL); vpnrouter_auth.revoke removes a user's. A
|
||||
client is registered by an administrator, so a user is not asked for consent.
|
||||
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 router, 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 (vpnrouter_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 vpnrouter_auth as their SHA-256
|
||||
(vpnrouter_auth.OIDC_SQL); vpnrouter_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 router's page.
|
||||
"""
|
||||
|
||||
import base64
|
||||
@@ -45,8 +62,13 @@ import jwt
|
||||
import ldap
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric import rsa
|
||||
from oauthlib.common import add_params_to_uri
|
||||
from oauthlib.oauth2 import AccessDeniedError, FatalClientError, InvalidRequestError, OAuth2Error
|
||||
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
|
||||
|
||||
@@ -63,6 +85,14 @@ 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 = 'vpn_router_oidc'
|
||||
|
||||
@@ -75,10 +105,11 @@ SCOPE_CLAIMS = {
|
||||
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.
|
||||
#: 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'
|
||||
|
||||
@@ -96,6 +127,26 @@ _pages = jinja2.Environment(loader=jinja2.FileSystemLoader(str(vpnrouter.TEMPLAT
|
||||
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:
|
||||
@@ -122,30 +173,33 @@ def public_jwk(key):
|
||||
return {**jwk, 'kid': vpnrouter_auth.b64encode(thumbprint), 'use': 'sig', 'alg': 'RS256'}
|
||||
|
||||
|
||||
def sign(claims):
|
||||
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']})
|
||||
return jwt.encode(claims, key, algorithm='RS256', headers={'kid': public_jwk(key)['kid'], **(headers or {})})
|
||||
|
||||
|
||||
def discovery(issuer):
|
||||
"""The discovery document of OpenID Connect Discovery 1.0."""
|
||||
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': list(SCOPES),
|
||||
'scopes_supported': [*SCOPES, *resource_scopes],
|
||||
'response_types_supported': ['code'],
|
||||
'response_modes_supported': ['query'],
|
||||
'grant_types_supported': ['authorization_code', 'refresh_token'],
|
||||
'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'],
|
||||
'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',
|
||||
*(claim for claims in SCOPE_CLAIMS.values() for claim in claims)],
|
||||
'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)],
|
||||
}
|
||||
|
||||
|
||||
@@ -159,19 +213,52 @@ def directory():
|
||||
connection.unbind_s()
|
||||
|
||||
|
||||
def client_of(client_id):
|
||||
"""The client of the ID, a namespace of its vpnrouter_users.summary with client_id, when it is an enabled service
|
||||
account with redirect URIs; else None."""
|
||||
if not isinstance(client_id, str):
|
||||
def account_of(name):
|
||||
"""A namespace of the vpnrouter_users.summary of the service account of the name, else None."""
|
||||
if not isinstance(name, str):
|
||||
return None
|
||||
with directory() as connection:
|
||||
try:
|
||||
user = vpnrouter_users.summary(vpnrouter_users.entry(connection, client_id))
|
||||
user = vpnrouter_users.summary(vpnrouter_users.entry(connection, name))
|
||||
except vpnrouter_users.Failure:
|
||||
return None
|
||||
if not user['service'] or not user['enabled'] or not user['redirect_uris']:
|
||||
return types.SimpleNamespace(**user) if user['service'] else None
|
||||
|
||||
|
||||
def client_of(client_id):
|
||||
"""The client of the ID, a namespace of its vpnrouter_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
|
||||
return types.SimpleNamespace(client_id=client_id, **user)
|
||||
account.client_id = client_id
|
||||
return account
|
||||
|
||||
|
||||
def resource_of(name):
|
||||
"""The resource of the name, a namespace of its vpnrouter_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 = vpnrouter_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 = vpnrouter_users.summary(vpnrouter_users.entry(connection, name))
|
||||
groups = sorted(vpnrouter_users.groups_of(connection, name))
|
||||
uuid = connection.search_s(vpnrouter_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):
|
||||
@@ -179,20 +266,26 @@ def subject(name, client):
|
||||
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:
|
||||
attributes = vpnrouter_users.entry(connection, name)
|
||||
user, claims = account_claims(connection, name)
|
||||
except vpnrouter_users.Failure:
|
||||
return None
|
||||
user = vpnrouter_users.summary(attributes)
|
||||
groups = sorted(vpnrouter_users.groups_of(connection, name))
|
||||
uuid = connection.search_s(vpnrouter_users.dn_of(name), ldap.SCOPE_BASE, attrlist=['entryUUID'])[0][1]['entryUUID']
|
||||
if user['service'] or not user['enabled'] or user['locked']:
|
||||
return None
|
||||
if client.allowed_groups and not set(client.allowed_groups) & set(groups):
|
||||
if client.allowed_groups and not set(client.allowed_groups) & set(claims['groups']):
|
||||
return None
|
||||
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 {claim: value for claim, value in claims.items() if value is not 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 vpnrouter_users.roles_held(connection, resource, name)
|
||||
|
||||
|
||||
def claims_of(person, scopes):
|
||||
@@ -201,6 +294,46 @@ def claims_of(person, scopes):
|
||||
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 vpnrouter_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:
|
||||
@@ -220,11 +353,31 @@ def session_of(cfg, cookies):
|
||||
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': vpnrouter.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 router's clients, users and database.
|
||||
|
||||
Only the authorization code grant with PKCE S256 and the refresh token grant are allowed. The values of a code, a
|
||||
token or a session found are kept on the request as oidc_code, oidc_scopes and oidc_person.
|
||||
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):
|
||||
@@ -243,6 +396,14 @@ class Validator(RequestValidator):
|
||||
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(vpnrouter.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):
|
||||
@@ -250,7 +411,7 @@ class Validator(RequestValidator):
|
||||
return request.client is not None
|
||||
|
||||
def validate_redirect_uri(self, client_id, redirect_uri, request, *args, **kwargs):
|
||||
return redirect_uri in request.client.redirect_uris
|
||||
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
|
||||
@@ -259,17 +420,29 @@ class Validator(RequestValidator):
|
||||
return response_type == 'code'
|
||||
|
||||
def validate_scopes(self, client_id, scopes, client, request, *args, **kwargs):
|
||||
return 'openid' in scopes and set(scopes) <= set(SCOPES)
|
||||
"""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(vpnrouter.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 ['openid']
|
||||
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."""
|
||||
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 ':
|
||||
@@ -279,7 +452,7 @@ class Validator(RequestValidator):
|
||||
return False
|
||||
name, secret = urllib.parse.unquote_plus(name), urllib.parse.unquote_plus(secret)
|
||||
client = client_of(name)
|
||||
if client is None:
|
||||
if client is None or client.public_client:
|
||||
return False
|
||||
try:
|
||||
vpnrouter_users.login(name, secret, None)
|
||||
@@ -289,10 +462,24 @@ class Validator(RequestValidator):
|
||||
return True
|
||||
|
||||
def authenticate_client_id(self, client_id, request, *args, **kwargs):
|
||||
return False
|
||||
"""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):
|
||||
return grant_type in ('authorization_code', 'refresh_token')
|
||||
"""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
|
||||
@@ -300,15 +487,15 @@ class Validator(RequestValidator):
|
||||
# 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)',
|
||||
self.call(('CALL oidc_code_save(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
|
||||
(vpnrouter_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,
|
||||
CODE_SECONDS)))
|
||||
getattr(request, 'oidc_target', None), CODE_SECONDS)))
|
||||
|
||||
def code(self, code):
|
||||
row = self.fetch('SELECT * FROM oidc_code_get(%s)', (vpnrouter_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'), row)) if row else None
|
||||
'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)
|
||||
@@ -321,6 +508,7 @@ class Validator(RequestValidator):
|
||||
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
|
||||
@@ -340,20 +528,53 @@ class Validator(RequestValidator):
|
||||
def invalidate_authorization_code(self, client_id, code, request, *args, **kwargs):
|
||||
self.call(('CALL oidc_code_delete(%s)', (vpnrouter_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)', (vpnrouter_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)', (vpnrouter_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)', (vpnrouter_auth.digest(code),)))
|
||||
|
||||
# Tokens.
|
||||
|
||||
def token(self, token, kind):
|
||||
row = self.fetch('SELECT * FROM oidc_token_get(%s, %s)', (vpnrouter_auth.digest(token), kind)) \
|
||||
if isinstance(token, str) and token else None
|
||||
return dict(zip(('client_id', 'name', 'scopes', 'auth_time', 'amr'), row)) if row 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."""
|
||||
values = (request.client.client_id, request.user, request.scopes, request.auth_time, request.amr)
|
||||
statements = [('CALL oidc_token_save(%s, %s, %s, %s, %s, %s, %s, %s)',
|
||||
"""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)',
|
||||
(vpnrouter_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)',
|
||||
statements.append(('CALL oidc_token_save(%s, %s, %s, %s, %s, %s, %s, %s, %s)',
|
||||
(vpnrouter_auth.digest(token['refresh_token']), 'refresh', *values, REFRESH_SECONDS)))
|
||||
if request.grant_type == 'refresh_token':
|
||||
statements.append(('CALL oidc_token_delete(%s)', (vpnrouter_auth.digest(request.refresh_token),)))
|
||||
@@ -366,6 +587,7 @@ class Validator(RequestValidator):
|
||||
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
|
||||
@@ -385,7 +607,9 @@ class Validator(RequestValidator):
|
||||
return True
|
||||
|
||||
def get_userinfo_claims(self, request):
|
||||
return claims_of(request.oidc_person, request.oidc_scopes)
|
||||
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.
|
||||
|
||||
@@ -394,6 +618,9 @@ class Validator(RequestValidator):
|
||||
id_token.update(claims_of(request.oidc_person, request.scopes))
|
||||
id_token.update({'iss': vpnrouter.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):
|
||||
@@ -417,10 +644,100 @@ class Validator(RequestValidator):
|
||||
return person is not None and hint.get('sub') == person['sub']
|
||||
|
||||
|
||||
def page(status, cfg, title, message='', error='', form=False, request='', name='', headers=()):
|
||||
"""An HTML page of TEMPLATE: a message, an error, and with form the sign-in form for the authorization request."""
|
||||
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 = vpnrouter.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 vpnrouter_auth.database(cfg) as connection:
|
||||
connection.execute('CALL oidc_device_save(%s, %s, %s, %s, %s, %s, %s)',
|
||||
(vpnrouter_auth.digest(device_code), vpnrouter_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 vpnrouter_auth.database(cfg) as connection:
|
||||
row = connection.execute('SELECT * FROM oidc_device_find(%s)', (vpnrouter_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=vpnrouter.oidc_issuer(cfg))
|
||||
name=name, issuer=vpnrouter.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]
|
||||
|
||||
|
||||
@@ -443,6 +760,30 @@ 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 vpnrouter_users.session() as connection:
|
||||
name = vpnrouter_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()
|
||||
vpnrouter_users.login(name, form.get('password', ''), code or None)
|
||||
with directory() as connection:
|
||||
if vpnrouter_users.service(vpnrouter_users.entry(connection, name)):
|
||||
raise vpnrouter_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 vpnrouter_auth.database(cfg) as connection:
|
||||
connection.execute('CALL oidc_session_save(%s, %s, %s, %s)', (vpnrouter_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.
|
||||
@@ -491,27 +832,72 @@ def login(server, cfg, form, headers):
|
||||
params = form.get('request', '')
|
||||
name = form.get('name', '').strip()
|
||||
try:
|
||||
if form.get('passkey_id'):
|
||||
with vpnrouter_users.session() as connection:
|
||||
name = vpnrouter_passkeys.login_complete(connection, form['passkey_id'], json.loads(form.get('credential', '')))
|
||||
amr = PASSKEY_AMR
|
||||
else:
|
||||
code = form.get('code', '').strip()
|
||||
vpnrouter_users.login(name, form.get('password', ''), code or None)
|
||||
with directory() as connection:
|
||||
if vpnrouter_users.service(vpnrouter_users.entry(connection, name)):
|
||||
raise vpnrouter_users.Failure('the name, the password or the code is wrong', 5)
|
||||
amr = OTP_AMR if code else PASSWORD_AMR
|
||||
name, amr = sign_in(form)
|
||||
except vpnrouter_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')
|
||||
value = secrets.token_urlsafe(32)
|
||||
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 vpnrouter_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 vpnrouter_auth.database(cfg) as connection:
|
||||
connection.execute('CALL oidc_session_save(%s, %s, %s, %s)', (vpnrouter_auth.digest(value), name, amr, SESSION_SECONDS))
|
||||
fresh = types.SimpleNamespace(session=Session(name, datetime.datetime.now(datetime.timezone.utc), amr),
|
||||
cookie=cookie(value, SESSION_SECONDS))
|
||||
return authorize(server, cfg, params, headers, fresh=fresh)
|
||||
decided = connection.execute('SELECT oidc_device_decide(%s, %s, %s, %s, %s)',
|
||||
(vpnrouter_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):
|
||||
@@ -552,9 +938,12 @@ def answer(method, target, headers, body):
|
||||
issuer = vpnrouter.oidc_issuer(cfg)
|
||||
headers = dict(headers.items())
|
||||
text = body.decode('utf-8', 'replace') if body else ''
|
||||
server = Server(Validator(cfg), token_expires_in=ACCESS_SECONDS)
|
||||
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))
|
||||
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'):
|
||||
@@ -565,6 +954,15 @@ def answer(method, target, headers, body):
|
||||
return document(200, vpnrouter_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'):
|
||||
|
||||
@@ -15,10 +15,18 @@ internal service accounts are those the router creates and manages for its own s
|
||||
included (internal_accounts); vpn-router-setup keeps the metrics service's.
|
||||
Users exist whether or not a P2S system is enabled.
|
||||
|
||||
A service account with redirect URIs is a client of the OpenID Provider (vpnrouter_oidc), its name the client ID and
|
||||
its password the client secret (client_settings): redirect_uris, where the provider sends a user back after a sign-in,
|
||||
post_logout_redirect_uris, after a sign-out, and allowed_groups, the groups whose members may sign in to it, every
|
||||
user who is not a service account when there are none.
|
||||
A service account with redirect URIs or grants is a client of the OpenID Provider (vpnrouter_oidc), its name the
|
||||
client ID and its password the client secret (client_settings): redirect_uris, where the provider sends a user back
|
||||
after a sign-in, post_logout_redirect_uris, after a sign-out, allowed_groups, the groups whose members may sign in to it,
|
||||
every user who is not a service account when there are none, grants, those of GRANTS it may use besides the
|
||||
authorization code, public_client, whether it signs no request with its secret, which a client with client_credentials
|
||||
must, and client_scopes, the scopes of resources it may ask for, as <resource>:<scope>.
|
||||
|
||||
A service account is also a resource of the OpenID Provider, the audience of the tokens issued for it: resource_scopes
|
||||
are the scopes it defines, and its roles (roles_of_resource) are entries cn=<resource>:<role> of vpnrouter_ldap.ROLES
|
||||
whose members are the groups and accounts the role is assigned to. A scope a client may ask for cannot be removed, nor
|
||||
the resource while a client may ask for its scopes; removing an account removes its roles and takes it out of the
|
||||
others, and removing or renaming a group does the same in the roles.
|
||||
|
||||
A group is a groupOfNames in ou=groups with a name, which follows the rules of user names, an
|
||||
optional description and at least one member; a group cannot be empty, so the last member
|
||||
@@ -105,9 +113,20 @@ LABELS = (('display_name', 'displayName'), ('description', 'description'))
|
||||
ATTRIBUTES = ['uid', 'objectClass', 'pwdAccountLockedTime', 'givenName', 'sn', 'mail', 'oathTOTPToken', 'vpnRouterScope',
|
||||
'displayName', 'description', 'userCertificate;binary', 'vpnRouterConsoleLogin', 'vpnRouterConsoleAccount',
|
||||
'uidNumber', 'vpnRouterWireGuardPeer', 'vpnRouterPasskey', 'vpnRouterRedirectUri',
|
||||
'vpnRouterPostLogoutRedirectUri', 'vpnRouterAllowedGroup']
|
||||
'vpnRouterPostLogoutRedirectUri', 'vpnRouterAllowedGroup', 'vpnRouterGrantType', 'vpnRouterPublicClient',
|
||||
'vpnRouterClientScope', 'vpnRouterResourceScope']
|
||||
#: The grants an OpenID Provider client may have besides the authorization code, which its redirect URIs give it.
|
||||
GRANTS = ('client_credentials', 'device_code')
|
||||
#: The name of a role of a resource, and of a scope a resource defines.
|
||||
ROLE_NAME = re.compile(r'^[A-Za-z][A-Za-z0-9._-]{0,63}$')
|
||||
SCOPE_NAME = re.compile(r'^[a-z][a-z0-9._-]{0,63}$')
|
||||
#: The attributes read for a role.
|
||||
ROLE_ATTRIBUTES = ['cn', 'description', 'member']
|
||||
#: The keys of the URIs of an OpenID Provider client and their LDAP attributes.
|
||||
CLIENT_URIS = (('redirect_uris', 'vpnRouterRedirectUri'), ('post_logout_redirect_uris', 'vpnRouterPostLogoutRedirectUri'))
|
||||
#: The keys of the OpenID Provider settings of a service account (client_settings, and roles of set_roles).
|
||||
CLIENT_KEYS = ('redirect_uris', 'post_logout_redirect_uris', 'allowed_groups', 'grants', 'public_client', 'client_scopes',
|
||||
'resource_scopes', 'roles')
|
||||
#: The most URIs of each kind and allowed groups of one client, and the longest URI.
|
||||
CLIENT_VALUES_MAX = 16
|
||||
URI_MAX = 1024
|
||||
@@ -218,11 +237,13 @@ def labels(values):
|
||||
|
||||
|
||||
def client_settings(connection, values):
|
||||
"""The OpenID Provider client settings of a service account in values ({redirect_uris, post_logout_redirect_uris,
|
||||
allowed_groups}), checked, as {LDAP attribute: [value, ...]}; a key whose value is None is not given, [] means none.
|
||||
"""The OpenID Provider settings of a service account in values ({redirect_uris, post_logout_redirect_uris,
|
||||
allowed_groups, grants, public_client, client_scopes, resource_scopes}), checked, as {LDAP attribute: [value, ...]};
|
||||
a key whose value is None is not given, [] or false means none.
|
||||
|
||||
A URI is absolute, has no fragment and uses https, or http for a host of LOOPBACK_HOSTS; an allowed group exists. Each
|
||||
list has at most CLIENT_VALUES_MAX values.
|
||||
A URI is absolute, has no fragment and uses https, or http for a host of LOOPBACK_HOSTS; an allowed group exists; a
|
||||
grant is one of GRANTS; a client scope is a scope of a resource, <resource>:<scope>; a resource scope is a
|
||||
SCOPE_NAME. Each list has at most CLIENT_VALUES_MAX values.
|
||||
"""
|
||||
found = {}
|
||||
for key, attribute in CLIENT_URIS:
|
||||
@@ -249,13 +270,68 @@ def client_settings(connection, values):
|
||||
for group in allowed:
|
||||
group_entry(connection, group)
|
||||
found['vpnRouterAllowedGroup'] = [group_dn(group).encode() for group in sorted(set(allowed))]
|
||||
grants = values.get('grants')
|
||||
if grants is not None:
|
||||
if not isinstance(grants, list) or not all(isinstance(grant, str) and grant in GRANTS for grant in grants):
|
||||
raise Failure(f'grants must be a list of {", ".join(GRANTS)}', 2)
|
||||
found['vpnRouterGrantType'] = [grant.encode() for grant in GRANTS if grant in grants]
|
||||
public = values.get('public_client')
|
||||
if public is not None:
|
||||
if not isinstance(public, bool):
|
||||
raise Failure('public_client must be true or false', 2)
|
||||
found['vpnRouterPublicClient'] = [b'TRUE'] if public else []
|
||||
scopes = values.get('client_scopes')
|
||||
if scopes is not None:
|
||||
if not isinstance(scopes, list) or len(scopes) > CLIENT_VALUES_MAX or not all(isinstance(scope, str) for scope in scopes):
|
||||
raise Failure(f'client_scopes must be a list of at most {CLIENT_VALUES_MAX} scopes', 2)
|
||||
for scope in scopes:
|
||||
resource, _, name = scope.partition(':')
|
||||
if name not in resource_scopes(connection, resource):
|
||||
raise Failure(f'{scope!r} is not a scope of a resource, <resource>:<scope>', 2)
|
||||
found['vpnRouterClientScope'] = [scope.encode() for scope in sorted(set(scopes))]
|
||||
defined = values.get('resource_scopes')
|
||||
if defined is not None:
|
||||
if not isinstance(defined, list) or len(defined) > CLIENT_VALUES_MAX or \
|
||||
not all(isinstance(scope, str) and SCOPE_NAME.match(scope) for scope in defined):
|
||||
raise Failure(f'resource_scopes must be a list of at most {CLIENT_VALUES_MAX} scope names: lowercase letters, '
|
||||
'digits, dots, underscores and hyphens, starting with a letter, at most 64', 2)
|
||||
found['vpnRouterResourceScope'] = [scope.encode() for scope in sorted(set(defined))]
|
||||
return found
|
||||
|
||||
|
||||
def refuse_client_settings(name, values):
|
||||
"""Refuse OpenID Provider client settings for a user who is not a service account."""
|
||||
if any(values.get(key) is not None for key in ('redirect_uris', 'post_logout_redirect_uris', 'allowed_groups')):
|
||||
raise Failure(f'{name} is not a service account; only a service account is a client of the OpenID Provider', 2)
|
||||
"""Refuse OpenID Provider settings for a user who is not a service account."""
|
||||
if any(values.get(key) is not None for key in CLIENT_KEYS):
|
||||
raise Failure(f'{name} is not a service account; only a service account is a client or a resource of the OpenID '
|
||||
'Provider', 2)
|
||||
|
||||
|
||||
def check_client(name, current, changes):
|
||||
"""Refuse the client settings an entry's attributes would have with changes ({LDAP attribute: [value, ...]}) when the
|
||||
client is public and has client_credentials, which needs its secret."""
|
||||
merged = {**current, **changes}
|
||||
if merged.get('vpnRouterPublicClient') == [b'TRUE'] and b'client_credentials' in merged.get('vpnRouterGrantType', []):
|
||||
raise Failure(f'{name}: a public client has no secret, so it cannot use client_credentials', 2)
|
||||
|
||||
|
||||
def resource_scopes(connection, name):
|
||||
"""The scopes the service account defines as a resource, [] when the name is not that of a service account."""
|
||||
if not isinstance(name, str) or not (NAME.match(name) or GUID.match(name)):
|
||||
return []
|
||||
try:
|
||||
attributes = entry(connection, name)
|
||||
except Failure:
|
||||
return []
|
||||
return [value.decode() for value in attributes.get('vpnRouterResourceScope', [])] if service(attributes) else []
|
||||
|
||||
|
||||
def asking(connection, scopes):
|
||||
"""The names of the clients whose client scopes have any of the scopes, <resource>:<scope>, sorted."""
|
||||
if not scopes:
|
||||
return []
|
||||
condition = ''.join(f'(vpnRouterClientScope={ldap.filter.escape_filter_chars(scope)})' for scope in scopes)
|
||||
found = connection.search_s(vpnrouter_ldap.USERS, ldap.SCOPE_ONELEVEL, f'(|{condition})', ['uid'])
|
||||
return sorted(attributes['uid'][0].decode() for _, attributes in found)
|
||||
|
||||
|
||||
def dn_of(name):
|
||||
@@ -310,7 +386,7 @@ def summary(attributes):
|
||||
"""A user as the answers show it; a person attribute or a label the entry does not have is None.
|
||||
|
||||
internal is whether it is an internal service account (internal_accounts). A service account also has its OpenID
|
||||
Provider client settings (client_settings), allowed_groups as group names.
|
||||
Provider settings (client_settings), allowed_groups as group names; with_roles adds its roles.
|
||||
"""
|
||||
name = attributes['uid'][0].decode()
|
||||
lock = attributes.get('pwdAccountLockedTime', [None])[0]
|
||||
@@ -336,9 +412,18 @@ def summary(attributes):
|
||||
suffix = f',{vpnrouter_ldap.GROUPS}'
|
||||
user['allowed_groups'] = sorted(value.decode()[3:-len(suffix)] for value in attributes.get('vpnRouterAllowedGroup', [])
|
||||
if value.decode().startswith('cn=') and value.decode().endswith(suffix))
|
||||
user['grants'] = [value.decode() for value in attributes.get('vpnRouterGrantType', [])]
|
||||
user['public_client'] = attributes.get('vpnRouterPublicClient') == [b'TRUE']
|
||||
user['client_scopes'] = [value.decode() for value in attributes.get('vpnRouterClientScope', [])]
|
||||
user['resource_scopes'] = [value.decode() for value in attributes.get('vpnRouterResourceScope', [])]
|
||||
return user
|
||||
|
||||
|
||||
def with_roles(connection, user):
|
||||
"""The summary of a service account with roles, its roles as a resource (roles_of_resource)."""
|
||||
return {**user, 'roles': roles_of_resource(connection, user['name'])}
|
||||
|
||||
|
||||
def console_of(attributes):
|
||||
"""The console login of an entry as the answers show it: None when it was never set, else {enabled, account, local,
|
||||
uid}: account the system account the console runs as, the local one of vpnRouterConsoleAccount (local true) or the
|
||||
@@ -536,8 +621,8 @@ def list_users(connection):
|
||||
def add(connection, name, password, values, service=False):
|
||||
"""Add a user: a VPN user with its certificate when values gives all three person attributes, a Manager-only account
|
||||
with at most the e-mail address when it gives neither name, and, with service, a service account, with at most the
|
||||
e-mail address, its labels (labels) and its OpenID Provider client settings (client_settings); only a service
|
||||
account may be named by a GUID."""
|
||||
e-mail address, its labels (labels), its OpenID Provider settings (client_settings) and its roles (set_roles); only
|
||||
a service account may be named by a GUID."""
|
||||
check_name(name, service)
|
||||
details = person(values, required=False)
|
||||
vpn_user = 'givenName' in details or 'sn' in details
|
||||
@@ -547,6 +632,9 @@ def add(connection, name, password, values, service=False):
|
||||
if service:
|
||||
details.update({attribute: value for attribute, value in labels(values).items() if value})
|
||||
client = {attribute: found for attribute, found in client_settings(connection, values).items() if found}
|
||||
check_client(name, {}, client)
|
||||
if values.get('roles') is not None:
|
||||
checked_roles(connection, values['roles'])
|
||||
else:
|
||||
refuse_client_settings(name, values)
|
||||
if vpn_user and len(details) != len(PERSON):
|
||||
@@ -574,6 +662,10 @@ def add(connection, name, password, values, service=False):
|
||||
vpnrouter_pki.issue_user(vpnrouter.load_config(), name, details['mail'])
|
||||
except vpnrouter_pki.Failure as failure:
|
||||
raise Failure(f'the certificate cannot be issued: {failure}', failure.status)
|
||||
if service:
|
||||
if values.get('roles') is not None:
|
||||
set_roles(connection, name, values['roles'])
|
||||
return with_roles(connection, summary(entry(connection, name)))
|
||||
return summary(entry(connection, name))
|
||||
|
||||
|
||||
@@ -628,20 +720,37 @@ def apply_wireguard():
|
||||
|
||||
|
||||
def update_service(connection, name, values):
|
||||
"""Change any of the e-mail address, the labels (labels) and the OpenID Provider client settings (client_settings) of
|
||||
a service account that values gives; '' removes the e-mail address or a label, [] the values of a client setting."""
|
||||
if not service(entry(connection, name)):
|
||||
"""Change any of the e-mail address, the labels (labels), the OpenID Provider settings (client_settings) and the
|
||||
roles (set_roles) of a service account that values gives; '' removes the e-mail address or a label, [] the values
|
||||
of a setting. A resource scope a client may ask for is not removed."""
|
||||
current = entry(connection, name)
|
||||
if not service(current):
|
||||
raise Failure(f'{name} is not a service account', 3)
|
||||
settings = client_settings(connection, values)
|
||||
check_client(name, current, settings)
|
||||
if 'vpnRouterResourceScope' in settings:
|
||||
removed = {value.decode() for value in current.get('vpnRouterResourceScope', [])} - \
|
||||
{value.decode() for value in settings['vpnRouterResourceScope']}
|
||||
clients = asking(connection, [f'{name}:{scope}' for scope in sorted(removed)])
|
||||
if clients:
|
||||
raise Failure(f'the clients {", ".join(clients)} may ask for the scopes of {name} being removed; take them out '
|
||||
'of their client scopes first', 2)
|
||||
roles = values.get('roles')
|
||||
if roles is not None:
|
||||
checked_roles(connection, roles)
|
||||
changes = [(ldap.MOD_REPLACE, attribute, [value.encode()] if value else []) for attribute, value in labels(values).items()]
|
||||
changes += [(ldap.MOD_REPLACE, attribute, found) for attribute, found in client_settings(connection, values).items()]
|
||||
changes += [(ldap.MOD_REPLACE, attribute, found) for attribute, found in settings.items()]
|
||||
email = values.get('email')
|
||||
if email is not None:
|
||||
address = '' if isinstance(email, str) and email.strip() == '' else person({'email': email}, required=False)['mail']
|
||||
changes.append((ldap.MOD_REPLACE, 'mail', [address.encode()] if address else []))
|
||||
if not changes:
|
||||
raise Failure('give email, display_name, description, redirect_uris, post_logout_redirect_uris or allowed_groups', 2)
|
||||
connection.modify_s(dn_of(name), changes)
|
||||
return summary(entry(connection, name))
|
||||
if not changes and roles is None:
|
||||
raise Failure(f'give email, display_name, description or {", ".join(CLIENT_KEYS)}', 2)
|
||||
if changes:
|
||||
connection.modify_s(dn_of(name), changes)
|
||||
if roles is not None:
|
||||
set_roles(connection, name, roles)
|
||||
return with_roles(connection, summary(entry(connection, name)))
|
||||
|
||||
|
||||
def passwd(connection, name, password):
|
||||
@@ -761,15 +870,24 @@ def remove(connection, name):
|
||||
"""Remove the user from its groups and the directory, revoke the certificate and end the sessions of its own
|
||||
posixAccount.
|
||||
|
||||
A user who is the last member of a group is not removed.
|
||||
A user who is the last member of a group is not removed, nor a resource whose scopes a client may ask for. The roles
|
||||
of a removed service account are removed, and the account is taken out of the other roles.
|
||||
"""
|
||||
current = entry(connection, name)
|
||||
groups = groups_of(connection, name)
|
||||
alone = sorted(group for group, members in groups.items() if members == [name])
|
||||
if alone:
|
||||
raise Failure(f'user {name} is the last member of {", ".join(alone)}; remove the group first', 2)
|
||||
clients = sorted(set(asking(connection, [f'{name}:{scope.decode()}' for scope in current.get('vpnRouterResourceScope', [])]))
|
||||
- {name})
|
||||
if clients:
|
||||
raise Failure(f'the clients {", ".join(clients)} may ask for the scopes of {name}; take them out of their client '
|
||||
'scopes first', 2)
|
||||
for group in groups:
|
||||
connection.modify_s(group_dn(group), [(ldap.MOD_DELETE, 'member', [dn_of(name).encode()])])
|
||||
for role in roles_of_resource(connection, name):
|
||||
connection.delete_s(role_dn(name, role['name']))
|
||||
leave_roles(connection, dn_of(name))
|
||||
try:
|
||||
vpnrouter_pki.revoke_user(vpnrouter.load_config(), name)
|
||||
except vpnrouter_pki.Failure as failure:
|
||||
@@ -977,7 +1095,7 @@ def group_add(connection, name, description, members):
|
||||
def group_update(connection, name, new_name=None, description=None):
|
||||
"""Rename the group or change its description ('' removes it); at least one must be given. Renaming ADMIN_GROUP
|
||||
switches the console login of its members off; renaming a group a client of the OpenID Provider allows renames it
|
||||
there, and renaming the editors group of web sites renames it in the sites."""
|
||||
there, as in the roles it is assigned, and renaming the editors group of web sites renames it in the sites."""
|
||||
import vpnrouter_sites
|
||||
if new_name is None and description is None:
|
||||
raise Failure('give a new name or a description', 2)
|
||||
@@ -996,6 +1114,9 @@ def group_update(connection, name, new_name=None, description=None):
|
||||
for client in allowing(connection, name):
|
||||
connection.modify_s(dn_of(client), [(ldap.MOD_DELETE, 'vpnRouterAllowedGroup', [group_dn(name).encode()]),
|
||||
(ldap.MOD_ADD, 'vpnRouterAllowedGroup', [group_dn(new_name).encode()])])
|
||||
for dn in assigned(connection, group_dn(name)):
|
||||
connection.modify_s(dn, [(ldap.MOD_DELETE, 'member', [group_dn(name).encode()]),
|
||||
(ldap.MOD_ADD, 'member', [group_dn(new_name).encode()])])
|
||||
try:
|
||||
vpnrouter_sites.rename_group(name, new_name)
|
||||
except vpnrouter_sites.DatabaseError as exc:
|
||||
@@ -1007,8 +1128,8 @@ def group_update(connection, name, new_name=None, description=None):
|
||||
|
||||
|
||||
def group_remove(connection, name):
|
||||
"""Remove the group, unless a client of the OpenID Provider allows it or it is the editors group of web sites;
|
||||
removing ADMIN_GROUP switches the console login of its members off."""
|
||||
"""Remove the group, unless a client of the OpenID Provider allows it or it is the editors group of web sites, and
|
||||
take it out of the roles it is assigned; removing ADMIN_GROUP switches the console login of its members off."""
|
||||
import vpnrouter_sites
|
||||
members = member_names(group_entry(connection, name))
|
||||
clients = allowing(connection, name)
|
||||
@@ -1021,6 +1142,7 @@ def group_remove(connection, name):
|
||||
if sites:
|
||||
raise Failure(f'group {name} is the editors group of the web sites {", ".join(sites)}; change them first', 2)
|
||||
connection.delete_s(group_dn(name))
|
||||
leave_roles(connection, group_dn(name))
|
||||
if name == ADMIN_GROUP:
|
||||
console_off(connection, members)
|
||||
return {'name': name, 'removed': True}
|
||||
@@ -1049,6 +1171,186 @@ def group_member_remove(connection, name, user):
|
||||
return group_summary(group_entry(connection, name))
|
||||
|
||||
|
||||
def role_dn(resource, role):
|
||||
return f'cn={resource}:{role},{vpnrouter_ldap.ROLES}'
|
||||
|
||||
|
||||
def check_resource(connection, resource):
|
||||
"""Refuse a name that is not that of a service account."""
|
||||
if not service(entry(connection, resource)):
|
||||
raise Failure(f'{resource} is not a service account; only a service account is a resource of the OpenID Provider', 2)
|
||||
|
||||
|
||||
def check_role_name(role):
|
||||
if not isinstance(role, str) or not ROLE_NAME.match(role):
|
||||
raise Failure('a role name is 1 to 64 letters, digits, dots, underscores and hyphens, starting with a letter', 2)
|
||||
|
||||
|
||||
def role_summary(attributes):
|
||||
"""A role as the answers show it: {name, description, groups, accounts}, the groups and accounts it is assigned to."""
|
||||
groups, accounts = [], []
|
||||
for value in attributes.get('member', []):
|
||||
dn = value.decode()
|
||||
if dn.startswith('cn=') and dn.endswith(f',{vpnrouter_ldap.GROUPS}'):
|
||||
groups.append(dn[3:-len(f',{vpnrouter_ldap.GROUPS}')])
|
||||
elif dn.startswith('uid=') and dn.endswith(f',{vpnrouter_ldap.USERS}'):
|
||||
accounts.append(dn[4:-len(f',{vpnrouter_ldap.USERS}')])
|
||||
values = attributes.get('description')
|
||||
return {'name': attributes['cn'][0].decode().partition(':')[2], 'description': values[0].decode() if values else '',
|
||||
'groups': sorted(groups), 'accounts': sorted(accounts)}
|
||||
|
||||
|
||||
def role_search(connection, resource, condition=''):
|
||||
"""The entries of the resource's roles that also match the LDAP filter condition, as [(DN, attributes)]."""
|
||||
prefix = ldap.filter.escape_filter_chars(f'{resource}:')
|
||||
found = connection.search_s(vpnrouter_ldap.ROLES, ldap.SCOPE_ONELEVEL,
|
||||
f'(&(objectClass=vpnRouterRole)(cn={prefix}*){condition})', ROLE_ATTRIBUTES)
|
||||
return [(dn, attributes) for dn, attributes in found if attributes['cn'][0].decode().startswith(f'{resource}:')]
|
||||
|
||||
|
||||
def roles_of_resource(connection, resource):
|
||||
"""The roles of the resource, sorted by name."""
|
||||
return sorted((role_summary(attributes) for _, attributes in role_search(connection, resource)),
|
||||
key=lambda role: role['name'])
|
||||
|
||||
|
||||
def role_entry(connection, resource, role):
|
||||
"""The attributes of the role's entry; Failure with status 3 when there is none."""
|
||||
check_role_name(role)
|
||||
try:
|
||||
return connection.search_s(role_dn(resource, role), ldap.SCOPE_BASE, attrlist=ROLE_ATTRIBUTES)[0][1]
|
||||
except ldap.NO_SUCH_OBJECT:
|
||||
raise Failure(f'{resource} has no role {role}', 3)
|
||||
|
||||
|
||||
def role_add(connection, resource, role, description=''):
|
||||
"""Add a role to the resource, with a description ('' for none) and no members."""
|
||||
check_resource(connection, resource)
|
||||
check_role_name(role)
|
||||
description = check_description(description if description is not None else '')
|
||||
record = {'objectClass': [b'vpnRouterRole'], 'cn': [f'{resource}:{role}'.encode()]}
|
||||
if description:
|
||||
record['description'] = [description.encode()]
|
||||
try:
|
||||
connection.add_s(role_dn(resource, role), ldap.modlist.addModlist(record))
|
||||
except ldap.ALREADY_EXISTS:
|
||||
raise Failure(f'{resource} has a role {role}', 4)
|
||||
return role_summary(role_entry(connection, resource, role))
|
||||
|
||||
|
||||
def role_remove(connection, resource, role):
|
||||
role_entry(connection, resource, role)
|
||||
connection.delete_s(role_dn(resource, role))
|
||||
return {'resource': resource, 'name': role, 'removed': True}
|
||||
|
||||
|
||||
def member_dn(connection, group=None, account=None):
|
||||
"""The DN of the existing group or account a role is assigned to; exactly one is given."""
|
||||
if (group is None) == (account is None):
|
||||
raise Failure('give a group or an account', 2)
|
||||
if group is not None:
|
||||
group_entry(connection, group)
|
||||
return group_dn(group)
|
||||
entry(connection, account)
|
||||
return dn_of(account)
|
||||
|
||||
|
||||
def role_member_add(connection, resource, role, group=None, account=None):
|
||||
"""Assign the role to the group or the account."""
|
||||
attributes = role_entry(connection, resource, role)
|
||||
dn = member_dn(connection, group, account)
|
||||
if dn.encode() not in attributes.get('member', []):
|
||||
connection.modify_s(role_dn(resource, role), [(ldap.MOD_ADD, 'member', [dn.encode()])])
|
||||
return role_summary(role_entry(connection, resource, role))
|
||||
|
||||
|
||||
def role_member_remove(connection, resource, role, group=None, account=None):
|
||||
"""Take the role from the group or the account."""
|
||||
attributes = role_entry(connection, resource, role)
|
||||
if (group is None) == (account is None):
|
||||
raise Failure('give a group or an account', 2)
|
||||
dn = group_dn(group) if group is not None else dn_of(account)
|
||||
if dn.encode() not in attributes.get('member', []):
|
||||
raise Failure(f'role {role} of {resource} is not assigned to {group or account}', 3)
|
||||
connection.modify_s(role_dn(resource, role), [(ldap.MOD_DELETE, 'member', [dn.encode()])])
|
||||
return role_summary(role_entry(connection, resource, role))
|
||||
|
||||
|
||||
def checked_roles(connection, roles):
|
||||
"""The roles of set_roles, checked: [{name, description, groups, accounts}], names unique, every group and account
|
||||
existing; description, groups and accounts may be left out."""
|
||||
if not isinstance(roles, list) or not all(isinstance(role, dict) for role in roles):
|
||||
raise Failure('roles must be a list of {"name", "description", "groups", "accounts"}', 2)
|
||||
checked = []
|
||||
for role in roles:
|
||||
check_role_name(role.get('name'))
|
||||
groups, accounts = role.get('groups') or [], role.get('accounts') or []
|
||||
if not isinstance(groups, list) or not isinstance(accounts, list):
|
||||
raise Failure(f'the groups and the accounts of role {role["name"]} must be lists of names', 2)
|
||||
for group in groups:
|
||||
group_entry(connection, group)
|
||||
for account in accounts:
|
||||
entry(connection, account)
|
||||
checked.append({'name': role['name'], 'description': check_description(role.get('description') or ''),
|
||||
'members': sorted({*(group_dn(group) for group in groups), *(dn_of(account) for account in accounts)})})
|
||||
if len({role['name'] for role in checked}) != len(checked):
|
||||
raise Failure('each role name may appear once', 2)
|
||||
return checked
|
||||
|
||||
|
||||
def set_roles(connection, resource, roles):
|
||||
"""Make the resource's roles those of roles (checked_roles): roles left out are removed, new ones added, and the
|
||||
others get the description and the members given."""
|
||||
check_resource(connection, resource)
|
||||
wanted = {role['name']: role for role in checked_roles(connection, roles)}
|
||||
for role in roles_of_resource(connection, resource):
|
||||
if role['name'] not in wanted:
|
||||
connection.delete_s(role_dn(resource, role['name']))
|
||||
present = {role['name'] for role in roles_of_resource(connection, resource)}
|
||||
for name, role in wanted.items():
|
||||
members = [dn.encode() for dn in role['members']]
|
||||
description = [role['description'].encode()] if role['description'] else []
|
||||
if name in present:
|
||||
connection.modify_s(role_dn(resource, name), [(ldap.MOD_REPLACE, 'description', description),
|
||||
(ldap.MOD_REPLACE, 'member', members)])
|
||||
continue
|
||||
record = {'objectClass': [b'vpnRouterRole'], 'cn': [f'{resource}:{name}'.encode()]}
|
||||
if description:
|
||||
record['description'] = description
|
||||
if members:
|
||||
record['member'] = members
|
||||
connection.add_s(role_dn(resource, name), ldap.modlist.addModlist(record))
|
||||
return roles_of_resource(connection, resource)
|
||||
|
||||
|
||||
def assigned(connection, dn):
|
||||
"""The DNs of the roles assigned to the group or account of the DN."""
|
||||
found = connection.search_s(vpnrouter_ldap.ROLES, ldap.SCOPE_ONELEVEL,
|
||||
f'(&(objectClass=vpnRouterRole)(member={ldap.filter.escape_filter_chars(dn)}))', ['1.1'])
|
||||
return [role for role, _ in found]
|
||||
|
||||
|
||||
def leave_roles(connection, dn):
|
||||
"""Take the group or account of the DN out of every role."""
|
||||
for role in assigned(connection, dn):
|
||||
connection.modify_s(role, [(ldap.MOD_DELETE, 'member', [dn.encode()])])
|
||||
|
||||
|
||||
def list_roles(connection, resource=None):
|
||||
"""The roles of every resource, or of one, as {"roles": [{resource, name, description, groups, accounts}]}."""
|
||||
found = connection.search_s(vpnrouter_ldap.ROLES, ldap.SCOPE_ONELEVEL, '(objectClass=vpnRouterRole)', ROLE_ATTRIBUTES)
|
||||
roles = [{'resource': attributes['cn'][0].decode().partition(':')[0], **role_summary(attributes)} for _, attributes in found]
|
||||
return {'roles': sorted((role for role in roles if resource is None or role['resource'] == resource),
|
||||
key=lambda role: (role['resource'], role['name']))}
|
||||
|
||||
|
||||
def roles_held(connection, resource, name):
|
||||
"""The names of the resource's roles assigned to the account or to a group it is a member of, sorted."""
|
||||
members = [dn_of(name), *(group_dn(group) for group in groups_of(connection, name))]
|
||||
condition = '(|' + ''.join(f'(member={ldap.filter.escape_filter_chars(dn)})' for dn in members) + ')'
|
||||
return sorted(role_summary(attributes)['name'] for _, attributes in role_search(connection, resource, condition))
|
||||
|
||||
|
||||
def extract_pem(text):
|
||||
"""The PEM blocks of the certificates in a file that also holds their text form."""
|
||||
begin, end = '-----BEGIN CERTIFICATE-----', '-----END CERTIFICATE-----'
|
||||
|
||||
@@ -162,7 +162,8 @@ class Handler(BaseHTTPRequestHandler):
|
||||
code, document = (users if directory == 'users' else groups)(state, self.command, path, payload)
|
||||
body, kind = json.dumps(document, indent=2).encode() + b'\n', 'application/json'
|
||||
elif oidc:
|
||||
wait = auth_wait(self.client()) if (self.command, path) == ('POST', '/oidc/login') else 0
|
||||
wait = auth_wait(self.client()) if self.command == 'POST' and path in (
|
||||
'/oidc/login', '/oidc/device', '/oidc/device_authorization') else 0
|
||||
if wait:
|
||||
code, kind = 429, 'application/json'
|
||||
body = json.dumps({'error': f'too many sign-in calls; retry in {wait} seconds'}).encode() + b'\n'
|
||||
|
||||
@@ -99,22 +99,29 @@ def oidc_settings():
|
||||
def service_accounts(method, path, body):
|
||||
"""Answer a /service-accounts request with vpnrouter_users: the HTTP status and the JSON document.
|
||||
|
||||
GET /service-accounts the service accounts: {"service_accounts": [...], "oidc": {"enabled",
|
||||
"issuer"}}, issuer that of the OpenID Provider, null while it is disabled
|
||||
GET /service-accounts the service accounts, each with its roles: {"service_accounts": [...],
|
||||
"oidc": {"enabled", "issuer"}}, issuer that of the OpenID Provider, null
|
||||
while it is disabled
|
||||
POST /service-accounts add one: {"name", "password", "display_name"?, "description"?, "email"?,
|
||||
"redirect_uris"?, "post_logout_redirect_uris"?, "allowed_groups"?}
|
||||
"redirect_uris"?, "post_logout_redirect_uris"?, "allowed_groups"?,
|
||||
"grants"?, "public_client"?, "client_scopes"?, "resource_scopes"?,
|
||||
"roles"?}
|
||||
PUT /service-accounts/<name> change any of {"display_name", "description", "email", "redirect_uris",
|
||||
"post_logout_redirect_uris", "allowed_groups"}; "" removes one of the
|
||||
first three, [] the values of the others
|
||||
"post_logout_redirect_uris", "allowed_groups", "grants",
|
||||
"public_client", "client_scopes", "resource_scopes", "roles"}; ""
|
||||
removes one of the first three, [] the values of the lists
|
||||
PUT /service-accounts/<name>/password set the password: {"password": ...}
|
||||
POST /service-accounts/<name>/disable lock it out
|
||||
POST /service-accounts/<name>/enable let it in again
|
||||
POST /service-accounts/<name>/unlock end a lockout after failed logins
|
||||
DELETE /service-accounts/<name> remove it
|
||||
|
||||
A service account with redirect URIs is a client of the OpenID Provider (vpnrouter_users.client_settings). A name
|
||||
that is not a service account is 404. The internal service accounts (vpnrouter_users.internal_accounts), which
|
||||
the router manages, are only listed: every other request on one is refused with 403.
|
||||
A service account with redirect URIs or grants is a client of the OpenID Provider, and every service account a
|
||||
resource (vpnrouter_users.client_settings); roles, [{"name", "description", "groups", "accounts"}], replaces its
|
||||
roles (vpnrouter_users.set_roles). A name that is not a service account is 404. The internal service accounts
|
||||
(vpnrouter_users.internal_accounts), which the router manages, are only listed: every other request on one, and a
|
||||
role assigned to one, is refused with 403. A password change, disabling, unlocking and removing revoke the tokens
|
||||
the account was issued.
|
||||
"""
|
||||
if body == 'invalid' or (body is not None and not isinstance(body, dict)):
|
||||
return 400, {'error': 'the body must be a JSON object'}
|
||||
@@ -122,11 +129,11 @@ def service_accounts(method, path, body):
|
||||
parts = path.strip('/').split('/')
|
||||
route = (method, len(parts), parts[2] if len(parts) == 3 else None)
|
||||
name = parts[1] if len(parts) > 1 else None
|
||||
settings = {key: body.get(key) for key in ('email', 'display_name', 'description', 'redirect_uris',
|
||||
'post_logout_redirect_uris', 'allowed_groups')}
|
||||
settings = {key: body.get(key) for key in ('email', 'display_name', 'description', *vpnrouter_users.CLIENT_KEYS)}
|
||||
actions = {
|
||||
('GET', 1, None): lambda connection: {
|
||||
'service_accounts': [user for user in vpnrouter_users.list_users(connection)['users'] if user['service']],
|
||||
'service_accounts': [vpnrouter_users.with_roles(connection, user)
|
||||
for user in vpnrouter_users.list_users(connection)['users'] if user['service']],
|
||||
'oidc': oidc_settings()},
|
||||
('POST', 1, None): lambda connection: vpnrouter_users.add(connection, body.get('name'), body.get('password'), settings,
|
||||
service=True),
|
||||
@@ -137,19 +144,34 @@ def service_accounts(method, path, body):
|
||||
('POST', 3, 'unlock'): lambda connection: vpnrouter_users.unlock(connection, name),
|
||||
('DELETE', 2, None): lambda connection: vpnrouter_users.remove(connection, name),
|
||||
}
|
||||
# The vpnrouter_users operation of each route that may revoke tokens.
|
||||
operations = {('PUT', 3, 'password'): 'passwd', ('POST', 3, 'disable'): 'disable', ('POST', 3, 'unlock'): 'unlock',
|
||||
('DELETE', 2, None): 'remove'}
|
||||
if route not in actions:
|
||||
return 404, {'error': f'no route {method} {path}'}
|
||||
if name is not None and name in vpnrouter_users.internal_accounts():
|
||||
internal = vpnrouter_users.internal_accounts()
|
||||
if name is not None and name in internal:
|
||||
return 403, {'error': f'{name} is an internal service account, which the router manages'}
|
||||
roles = settings['roles'] if isinstance(settings['roles'], list) else []
|
||||
assigned = sorted(set(internal).intersection(account for role in roles if isinstance(role, dict)
|
||||
for account in (role.get('accounts') or [])
|
||||
if isinstance(account, str)))
|
||||
if assigned:
|
||||
return 403, {'error': f'{", ".join(assigned)}: internal service accounts, which the router manages, are not '
|
||||
'assigned roles'}
|
||||
try:
|
||||
with vpnrouter_users.session() as connection:
|
||||
if name is not None and not vpnrouter_users.service(vpnrouter_users.entry(connection, name)):
|
||||
raise vpnrouter_users.Failure(f'{name} is not a service account', 3)
|
||||
document = actions[route](connection)
|
||||
if operations.get(route) in vpnrouter_auth.REVOKING:
|
||||
vpnrouter_auth.revoke(vpnrouter.load_config(), name)
|
||||
except vpnrouter_users.Failure as failure:
|
||||
return USER_STATUS.get(failure.status, 500), {'error': str(failure)}
|
||||
except (ldap.LDAPError, OSError) as exc:
|
||||
return 500, {'error': f'the user directory failed: {exc}'}
|
||||
except vpnrouter_auth.DatabaseError as exc:
|
||||
return 500, {'error': str(exc)}
|
||||
except SystemExit as exc:
|
||||
return 500, {'error': str(exc.code)}
|
||||
return (201 if route == ('POST', 1, None) else 200), document
|
||||
|
||||
Reference in new issue
Block a user