e220b50543
We move all the auth handling, serialization and deserialization into a new AuthContext interface, and then standardize a registration model for handling of specific auth context types (user, robot, token, etc).
192 lines
7.1 KiB
Python
192 lines
7.1 KiB
Python
import logging
|
|
import re
|
|
|
|
from cachetools import lru_cache
|
|
from flask import request, jsonify
|
|
|
|
import features
|
|
from app import app, userevents, instance_keys
|
|
from auth.auth_context import get_authenticated_context, get_authenticated_user
|
|
from auth.decorators import process_basic_auth
|
|
from auth.permissions import (ModifyRepositoryPermission, ReadRepositoryPermission,
|
|
CreateRepositoryPermission, AdministerRepositoryPermission)
|
|
from endpoints.decorators import anon_protect
|
|
from endpoints.v2 import v2_bp
|
|
from endpoints.v2.errors import InvalidLogin, NameInvalid, InvalidRequest, Unsupported, Unauthorized
|
|
from endpoints.v2.models_pre_oci import data_model as model
|
|
from util.cache import no_cache
|
|
from util.names import parse_namespace_repository, REPOSITORY_NAME_REGEX
|
|
from util.security.registry_jwt import (generate_bearer_token, build_context_and_subject,
|
|
QUAY_TUF_ROOT, SIGNER_TUF_ROOT, DISABLED_TUF_ROOT)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
TOKEN_VALIDITY_LIFETIME_S = 60 * 60 # 1 hour
|
|
SCOPE_REGEX_TEMPLATE = r'^repository:((?:{}\/)?((?:[\.a-zA-Z0-9_\-]+\/)*[\.a-zA-Z0-9_\-]+)):((?:push|pull|\*)(?:,(?:push|pull|\*))*)$'
|
|
|
|
|
|
@lru_cache(maxsize=1)
|
|
def get_scope_regex():
|
|
hostname = re.escape(app.config['SERVER_HOSTNAME'])
|
|
scope_regex_string = SCOPE_REGEX_TEMPLATE.format(hostname)
|
|
return re.compile(scope_regex_string)
|
|
|
|
|
|
@v2_bp.route('/auth')
|
|
@process_basic_auth
|
|
@no_cache
|
|
@anon_protect
|
|
def generate_registry_jwt(auth_result):
|
|
"""
|
|
This endpoint will generate a JWT conforming to the Docker Registry v2 Auth Spec:
|
|
https://docs.docker.com/registry/spec/auth/token/
|
|
"""
|
|
audience_param = request.args.get('service')
|
|
logger.debug('Request audience: %s', audience_param)
|
|
|
|
scope_param = request.args.get('scope') or ''
|
|
logger.debug('Scope request: %s', scope_param)
|
|
|
|
auth_header = request.headers.get('authorization', '')
|
|
auth_credentials_sent = bool(auth_header)
|
|
|
|
has_valid_auth_context = False
|
|
if get_authenticated_context():
|
|
has_valid_auth_context = not get_authenticated_context().is_anonymous
|
|
|
|
if auth_credentials_sent and not has_valid_auth_context:
|
|
# The auth credentials sent for the user are invalid.
|
|
raise InvalidLogin(auth_result.error_message)
|
|
|
|
access = []
|
|
user_event_data = {
|
|
'action': 'login',
|
|
}
|
|
tuf_root = DISABLED_TUF_ROOT
|
|
|
|
if len(scope_param) > 0:
|
|
match = get_scope_regex().match(scope_param)
|
|
if match is None:
|
|
logger.debug('Match: %s', match)
|
|
logger.debug('len: %s', len(scope_param))
|
|
logger.warning('Unable to decode repository and actions: %s', scope_param)
|
|
raise InvalidRequest('Unable to decode repository and actions: %s' % scope_param)
|
|
|
|
logger.debug('Match: %s', match.groups())
|
|
|
|
registry_and_repo = match.group(1)
|
|
namespace_and_repo = match.group(2)
|
|
actions = match.group(3).split(',')
|
|
|
|
lib_namespace = app.config['LIBRARY_NAMESPACE']
|
|
namespace, reponame = parse_namespace_repository(namespace_and_repo, lib_namespace)
|
|
|
|
# Ensure that we are never creating an invalid repository.
|
|
if not REPOSITORY_NAME_REGEX.match(reponame):
|
|
logger.debug('Found invalid repository name in auth flow: %s', reponame)
|
|
if len(namespace_and_repo.split('/')) > 1:
|
|
msg = 'Nested repositories are not supported. Found: %s' % namespace_and_repo
|
|
raise NameInvalid(message=msg)
|
|
|
|
raise NameInvalid(message='Invalid repository name: %s' % namespace_and_repo)
|
|
|
|
final_actions = []
|
|
|
|
repo = model.get_repository(namespace, reponame)
|
|
|
|
repo_is_public = repo is not None and repo.is_public
|
|
invalid_repo_message = ''
|
|
if repo is not None and repo.kind != 'image':
|
|
invalid_repo_message = ((
|
|
'This repository is for managing %s resources ' + 'and not container images.') % repo.kind)
|
|
|
|
if 'push' in actions:
|
|
# Check if there is a valid user or token, as otherwise the repository cannot be
|
|
# accessed.
|
|
if has_valid_auth_context:
|
|
# Lookup the repository. If it exists, make sure the entity has modify
|
|
# permission. Otherwise, make sure the entity has create permission.
|
|
if repo:
|
|
if ModifyRepositoryPermission(namespace, reponame).can():
|
|
if repo.kind != 'image':
|
|
raise Unsupported(message=invalid_repo_message)
|
|
|
|
final_actions.append('push')
|
|
else:
|
|
logger.debug('No permission to modify repository %s/%s', namespace, reponame)
|
|
else:
|
|
user = get_authenticated_user()
|
|
if CreateRepositoryPermission(namespace).can() and user is not None:
|
|
logger.debug('Creating repository: %s/%s', namespace, reponame)
|
|
model.create_repository(namespace, reponame, user)
|
|
final_actions.append('push')
|
|
else:
|
|
logger.debug('No permission to create repository %s/%s', namespace, reponame)
|
|
|
|
if 'pull' in actions:
|
|
# Grant pull if the user can read the repo or it is public.
|
|
if ReadRepositoryPermission(namespace, reponame).can() or repo_is_public:
|
|
if repo is not None and repo.kind != 'image':
|
|
raise Unsupported(message=invalid_repo_message)
|
|
|
|
final_actions.append('pull')
|
|
else:
|
|
logger.debug('No permission to pull repository %s/%s', namespace, reponame)
|
|
|
|
if '*' in actions:
|
|
# Grant * user is admin
|
|
if AdministerRepositoryPermission(namespace, reponame).can():
|
|
if repo is not None and repo.kind != 'image':
|
|
raise Unsupported(message=invalid_repo_message)
|
|
|
|
final_actions.append('*')
|
|
else:
|
|
logger.debug("No permission to administer repository %s/%s", namespace, reponame)
|
|
|
|
# Add the access for the JWT.
|
|
access.append({
|
|
'type': 'repository',
|
|
'name': registry_and_repo,
|
|
'actions': final_actions,
|
|
})
|
|
|
|
# Set the user event data for the auth.
|
|
if 'push' in final_actions:
|
|
user_action = 'push_start'
|
|
elif 'pull' in final_actions:
|
|
user_action = 'pull_start'
|
|
else:
|
|
user_action = 'login'
|
|
|
|
user_event_data = {
|
|
'action': user_action,
|
|
'repository': reponame,
|
|
'namespace': namespace,
|
|
}
|
|
tuf_root = get_tuf_root(repo, namespace, reponame)
|
|
|
|
elif not has_valid_auth_context:
|
|
# In this case, we are doing an auth flow, and it's not an anonymous pull
|
|
logger.debug('No user and no token sent for empty scope list')
|
|
raise Unauthorized()
|
|
|
|
# Send the user event.
|
|
if get_authenticated_user() is not None:
|
|
event = userevents.get_event(get_authenticated_user().username)
|
|
event.publish_event_data('docker-cli', user_event_data)
|
|
|
|
# Build the signed JWT.
|
|
context, subject = build_context_and_subject(get_authenticated_context(), tuf_root=tuf_root)
|
|
token = generate_bearer_token(audience_param, subject, context, access,
|
|
TOKEN_VALIDITY_LIFETIME_S, instance_keys)
|
|
return jsonify({'token': token})
|
|
|
|
|
|
def get_tuf_root(repo, namespace, reponame):
|
|
if not features.SIGNING or repo is None or not repo.trust_enabled:
|
|
return DISABLED_TUF_ROOT
|
|
|
|
# Users with write access to a repo will see signer-rooted TUF metadata
|
|
if ModifyRepositoryPermission(namespace, reponame).can():
|
|
return SIGNER_TUF_ROOT
|
|
return QUAY_TUF_ROOT
|