Skip to content

Beautiful Open-Source Form Builder

10.1 KB
Raw Blame
<?php

namespace App\Enterprise\Oidc;

use App\Enterprise\Oidc\Exceptions\OidcAccountLinkRequiredException;
use App\Enterprise\Oidc\Models\IdentityConnection;
use App\Enterprise\Oidc\Models\UserIdentity;
use App\Models\User;
use App\Models\Workspace;
use App\Service\License\SelfHostedSeatLimitService;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Laravel\Socialite\Contracts\User as SocialiteUser;

class ProvisioningService
{
    public function __construct(
        private RoleMapper $roleMapper,
        private DomainJoiner $domainJoiner,
        private ExternalUserFactory $userFactory,
    ) {
    }

    /**
     * Provision or authenticate a user from OIDC claims.
     *
     * @throws \Exception
     */
    public function provisionUser(
        IdentityConnection $connection,
        SocialiteUser $socialiteUser,
        array $idTokenClaims
    ): User {
        return DB::transaction(function () use ($connection, $socialiteUser, $idTokenClaims) {
            // Validate ID token claims
            $this->validateIdToken($connection, $idTokenClaims);

            $subject = $idTokenClaims['sub'];

            // Extract email and name from claims
            $email = $this->extractEmail($socialiteUser, $idTokenClaims, $connection);
            $name = $this->extractName($socialiteUser, $idTokenClaims, $connection);

            if (!$email) {
                throw new \Exception('Email is required for OIDC authentication. Check your field mappings configuration.');
            }

            // Check for existing UserIdentity
            $userIdentity = UserIdentity::where('connection_id', $connection->id)
                ->where('subject', $subject)
                ->first();

            if ($userIdentity) {
                // Update claims and email if changed
                $userIdentity->update([
                    'email' => $email,
                    'claims' => $idTokenClaims,
                ]);

                $user = $userIdentity->user;

                Log::info('OIDC user authenticated', [
                    'connection_id' => $connection->id,
                    'user_id' => $user->id,
                    'subject' => $subject,
                    'email' => $email,
                ]);
            } else {
                // Check if user with same email exists
                $existingUser = User::where('email', strtolower($email))->first();

                if ($existingUser) {
                    // Account linking - require explicit action for security
                    Log::warning('OIDC account linking required', [
                        'connection_id' => $connection->id,
                        'existing_user_id' => $existingUser->id,
                        'subject' => $subject,
                        'email' => $email,
                    ]);

                    throw new OidcAccountLinkRequiredException(
                        email: $email,
                        subject: $subject,
                        connectionId: $connection->id,
                        claims: $idTokenClaims,
                    );
                }

                app(SelfHostedSeatLimitService::class)->assertCanCreateUser($email);

                // Create new user
                $userName = $name ?? $socialiteUser->getName() ?? explode('@', $email)[0];
                $user = $this->userFactory->createVerifiedExternalUser(
                    name: $userName,
                    email: $email,
                    provider: 'oidc',
                    providerUserId: $subject,
                    utmData: null,
                    extraMeta: [],
                    setRandomPassword: true,
                );

                // Create UserIdentity
                UserIdentity::create([
                    'user_id' => $user->id,
                    'connection_id' => $connection->id,
                    'subject' => $subject,
                    'email' => $email,
                    'claims' => $idTokenClaims,
                ]);

                Log::info('OIDC user provisioned', [
                    'connection_id' => $connection->id,
                    'user_id' => $user->id,
                    'subject' => $subject,
                    'email' => $email,
                ]);
            }

            // Handle workspace membership
            $this->handleWorkspaceMembership($connection, $user, $idTokenClaims);

            return $user;
        });
    }

    /**
     * Validate ID token claims.
     *
     * @throws \Exception
     */
    protected function validateIdToken(IdentityConnection $connection, array $claims): void
    {
        // Validate issuer
        if (!isset($claims['iss']) || $claims['iss'] !== $connection->issuer) {
            throw new \Exception('Invalid issuer in ID token');
        }

        // Validate audience (client_id)
        $aud = $claims['aud'] ?? null;
        if (!$aud) {
            throw new \Exception('Missing audience in ID token');
        }

        $audArray = is_array($aud) ? $aud : [$aud];
        if (!in_array($connection->client_id, $audArray, true)) {
            throw new \Exception('Invalid audience in ID token');
        }

        if ((count($audArray) > 1 || isset($claims['azp'])) && ($claims['azp'] ?? null) !== $connection->client_id) {
            throw new \Exception('Invalid authorized party in ID token');
        }

        // Validate expiration
        if (!isset($claims['exp']) || !is_numeric($claims['exp']) || $claims['exp'] <= time()) {
            throw new \Exception('ID token has expired');
        }

        // Validate subject
        if (empty($claims['sub'])) {
            throw new \Exception('Missing subject in ID token');
        }
    }

    /**
     * Handle workspace membership based on connection and claims.
     */
    protected function handleWorkspaceMembership(
        IdentityConnection $connection,
        User $user,
        array $claims
    ): void {
        // Get role from group mapping or default to member
        $groups = $claims['groups'] ?? $claims['group'] ?? [];
        $groupsArray = is_array($groups) ? $groups : [$groups];
        $role = $this->roleMapper->mapGroupsToRole($connection, $groupsArray) ?? 'member';

        // If connection has a workspace_id, ensure membership
        if ($connection->workspace_id) {
            $workspace = Workspace::find($connection->workspace_id);
            if (!$workspace) {
                return;
            }

            $wasMember = $user->workspaces()->where('workspaces.id', $workspace->id)->exists();
            $this->domainJoiner->ensureWorkspaceMembership($user, $workspace, $role);

            Log::info('OIDC workspace membership ensured', [
                'connection_id' => $connection->id,
                'user_id' => $user->id,
                'workspace_id' => $workspace->id,
                'role' => $role,
                'was_member' => $wasMember,
                'groups' => $groupsArray,
            ]);

            return;
        }

        // No workspace_id - use domain-based auto-join for global connections
        $email = $user->email;
        $workspace = $this->domainJoiner->findWorkspaceForDomain($email);

        if (!$workspace) {
            return;
        }

        $wasMember = $user->workspaces()->where('workspaces.id', $workspace->id)->exists();
        $this->domainJoiner->ensureWorkspaceMembership($user, $workspace, $role);

        Log::info('OIDC workspace membership ensured via domain', [
            'connection_id' => $connection->id,
            'user_id' => $user->id,
            'workspace_id' => $workspace->id,
            'role' => $role,
            'was_member' => $wasMember,
            'email_domain' => $this->extractDomain($email),
            'groups' => $groupsArray,
        ]);
    }

    /**
     * Extract email from socialite user or ID token claims.
     */
    protected function extractEmail(SocialiteUser $socialiteUser, array $idTokenClaims, IdentityConnection $connection): ?string
    {
        // Try socialite user first
        $email = $socialiteUser->getEmail();
        if ($email) {
            return $email;
        }

        // Get field mappings from connection options
        $fieldMappings = $connection->options['field_mappings'] ?? [];
        $emailField = !empty($fieldMappings['email']) ? $fieldMappings['email'] : null;

        // Try mapped field first (if configured)
        if ($emailField && isset($idTokenClaims[$emailField])) {
            return $idTokenClaims[$emailField];
        }

        // Fallback to standard fields
        return $idTokenClaims['email']
            ?? $idTokenClaims['email_address']
            ?? $idTokenClaims['mail']
            ?? $idTokenClaims['preferred_username'] // Common Keycloak field
            ?? null;
    }

    /**
     * Extract name from socialite user or ID token claims.
     */
    protected function extractName(SocialiteUser $socialiteUser, array $idTokenClaims, IdentityConnection $connection): ?string
    {
        // Try socialite user first
        $name = $socialiteUser->getName();
        if (!empty($name)) {
            return $name;
        }

        // Get field mappings from connection options
        $fieldMappings = $connection->options['field_mappings'] ?? [];
        $nameField = !empty($fieldMappings['name']) ? $fieldMappings['name'] : null;

        // Try mapped field first (if configured)
        if ($nameField && isset($idTokenClaims[$nameField]) && !empty($idTokenClaims[$nameField])) {
            return $idTokenClaims[$nameField];
        }

        // Fallback to standard fields
        $trimmedName = trim(($idTokenClaims['given_name'] ?? '') . ' ' . ($idTokenClaims['family_name'] ?? ''));

        return $idTokenClaims['name']
            ?? $idTokenClaims['display_name']
            ?? (!empty($trimmedName) ? $trimmedName : null)
            ?? $idTokenClaims['preferred_username']
            ?? null;
    }

    /**
     * Extract domain from email address.
     */
    protected function extractDomain(string $email): ?string
    {
        $parts = explode('@', strtolower(trim($email)));
        return count($parts) === 2 ? $parts[1] : null;
    }
}