I den moderne web-æra er adgangskoder ikke længere tilstrækkelige. de er den grundlæggende årsag til over 80% af databrud, der er underlagt phishing, genbrug og forfærdelige kompleksitetsregler. Passkeys are the future. Sikkerhedsudstyr, der er opbygget på Web Authentication ( ) og Din enhed (iPhone, Android, Windows Hello, YubiKey) gemmer en privat nøgle, mens serveren kun nogensinde ser den offentlige nøgle. WebAuthn FIDO2 I denne omfattende vejledning har vi ved hjælp af Symfony og den officielle Vi vil fjerne begrebet adgangskode helt fra vores ansøgning. ingen tilbagevenden, ingen "reset password" links. Kun rene, sikre, biometrisk-backed passkeys. will build a 100% passwordless authentication system web-auth/webauthn-symfony-bundle Core arkitektur og krav Passkeys fungerer ved at erstatte en delt hemmelighed (adgangskode) med et offentligt / privat nøglepar. Den private nøgle forlader aldrig brugerens Apple-enhed (iPhone, Mac, iPad), og den offentlige nøgle gemmes på din Symfony-server. Teknisk Stack 
 
 
 
 
 PHP: 8.2 eller højere (kræves for de nyeste WebAuthn libs) Symfoni: 7,4 LTS Database: PostgreSQL, MySQL eller SQLite for dev (for at gemme Credential Sources) Det primære bibliotek: web-auth/webauthn-symfony-bundle Vigtige pakker Kør følgende kommando for at installere de nødvendige afhængigheder: composer require web-auth/webauthn-symfony-bundle:^5.2 \
                 web-auth/webauthn-stimulus:^5.2 \
                 symfony/uid:^7.4
 Vi bruger via AssetMapper (som giver fremragende wrapper-funktioner til den native browser WebAuthn API'er), fordi Apple Passkeys kræver en frontend-interaktion, der bedst håndteres via en i et moderne Symfony-miljø, eller du kan bruge React/Vue-moduler. @simplewebauthn/browser Stimulus controller @læsning/browser Database Schema: Den kreative kilde Det er her vores applikation adskiller sig dramatisk fra en traditionel Symfony-app. Standard Symfony-brugerentiteter er ikke udstyret til at gemme Passkey-metadata (såsom AAGUID'er eller public key Cose-algoritmer). Den brugerentitet Vores Virksomheder implementerer Det bemærkelsesværdige fravær er . User Symfony\Component\Security\Core\User\UserInterface PasswordAuthenticatedUserInterface namespace App\Entity;

use App\Repository\UserRepository;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Uid\Uuid;
use Symfony\Component\Validator\Constraints as Assert;

#[ORM\Entity(repositoryClass: UserRepository::class)]
#[ORM\Table(name: '`user`')]
class User implements UserInterface
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255, unique: true)]
    private ?string $userHandle = null;

    #[ORM\Column(length: 180, unique: true)]
    #[Assert\NotBlank]
    #[Assert\Email]
    private ?string $email = null;

    public function __construct()
    {
        $this->userHandle = Uuid::v4()->toRfc4122();
    }

    ...
}
 Enheden PublicKeyCredentialSource En enkelt bruger kan have flere passkeys (f.eks. Face ID på deres telefon, Touch ID på deres Mac, en YubiKey på deres keychain). skaber Denne enhed skal være i stand til at oversætte til og fra bundlets indfødte Et objekt . src/Entity/PublicKeyCredentialSource.php Webauthn\PublicKeyCredentialSource Det er afgørende, at vi bevarer Hvis du ikke gør det, ødelægges de attesteringsdata, der er nødvendige, hvis du nogensinde har brug for højsikkerheds enterprise hardware-nøgler. TrustPath namespace App\Entity;

use App\Repository\PublicKeyCredentialSourceRepository;
use Doctrine\ORM\Mapping as ORM;
use Webauthn\PublicKeyCredentialSource as WebauthnSource;

#[ORM\Entity(repositoryClass: PublicKeyCredentialSourceRepository::class)]
#[ORM\Table(name: 'webauthn_credentials')]
class PublicKeyCredentialSource extends WebauthnSource
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    public function getId(): ?int
    {
        return $this->id;
    }
}
 Den CredentialSourceRepository Du skal også gennemføre en Disse implementerer . CredentialSourceRepository Webauthn\Bundle\Repository\PublicKeyCredentialSourceRepository 
namespace App\Repository;

use App\Entity\PublicKeyCredentialSource;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Symfony\Component\ObjectMapper\ObjectMapperInterface;
use Webauthn\Bundle\Repository\PublicKeyCredentialSourceRepositoryInterface;
use Webauthn\Bundle\Repository\CanSaveCredentialSource;
use Webauthn\PublicKeyCredentialSource as WebauthnSource;
use Webauthn\PublicKeyCredentialUserEntity;

class PublicKeyCredentialSourceRepository extends ServiceEntityRepository implements PublicKeyCredentialSourceRepositoryInterface, CanSaveCredentialSource
{
    public function __construct(ManagerRegistry $registry, private readonly ObjectMapperInterface $objectMapper)
    {
        parent::__construct($registry, PublicKeyCredentialSource::class);
    }

    public function findOneByCredentialId(string $publicKeyCredentialId): ?WebauthnSource
    {
        return $this->findOneBy(['publicKeyCredentialId' => $publicKeyCredentialId]);
    }

    public function findAllForUserEntity(PublicKeyCredentialUserEntity $publicKeyCredentialUserEntity): array
    {
        return $this->findBy(['userHandle' => $publicKeyCredentialUserEntity->id]);
    }

    public function saveCredentialSource(WebauthnSource $publicKeyCredentialSource): void
    {
        $entity = $this->findOneBy(['publicKeyCredentialId' => base64_encode($publicKeyCredentialSource->publicKeyCredentialId)])
            ?? $this->objectMapper->map($publicKeyCredentialSource, PublicKeyCredentialSource::class);

        $this->getEntityManager()->persist($entity);
        $this->getEntityManager()->flush();
    }
}
 WebAuthn-pakken er afhængig af abstrakte grænseflader for at finde og vedligeholde brugere og legitimationsoplysninger. BrugereRepository UserRepository implementerer PublicKeyCredentialUserEntityRepositoryInterface. Fordi vi ønsker at pakken skal håndtere brugeroprettelse automatisk under en passkey registrering, implementerer vi også og . CanRegisterUserEntity CanGenerateUserEntity 
namespace App\Repository;

use App\Entity\User;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Symfony\Component\Uid\Uuid;
use Webauthn\Bundle\Repository\CanGenerateUserEntity;
use Webauthn\Bundle\Repository\CanRegisterUserEntity;
use Webauthn\Bundle\Repository\PublicKeyCredentialUserEntityRepositoryInterface;
use Webauthn\Exception\InvalidDataException;
use Webauthn\PublicKeyCredentialUserEntity;

class UserRepository extends ServiceEntityRepository implements PublicKeyCredentialUserEntityRepositoryInterface, CanRegisterUserEntity, CanGenerateUserEntity
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, User::class);
    }

    public function saveUserEntity(PublicKeyCredentialUserEntity $userEntity): void
    {
        $user = new User();
        $user->setEmail($userEntity->name);
        $user->setUserHandle($userEntity->id);

        $this->getEntityManager()->persist($user);
        $this->getEntityManager()->flush();
    }

    public function generateUserEntity(?string $username, ?string $displayName): PublicKeyCredentialUserEntity
    {
        return new PublicKeyCredentialUserEntity(
            $username ?? '',
            Uuid::v4()->toRfc4122(),
            $displayName ?? $username ?? ''
        );
    }

    ...
 Konfiguration: Bridging Symfony og Apple Apple kræver særlige Dette identificerer din ansøgning til brugerens iCloud Keychain. “Relying Party” (RP) WebAuthn konfiguration Opret eller opdater config/packages/webauthn.yaml: webauthn:
    allowed_origins: ['%env(WEBAUTHN_ALLOWED_ORIGINS)%']
    credential_repository: 'App\Repository\PublicKeyCredentialSourceRepository'
    user_repository: 'App\Repository\UserRepository'
    creation_profiles:
        default:
            rp:
                name: '%env(RELYING_PARTY_NAME)%'
                id: '%env(RELYING_PARTY_ID)%'
    request_profiles:
        default:
            rp_id: '%env(RELYING_PARTY_ID)%'
 WebAuthn er utroligt strengt om domæner. En passkey skabt til Kan ikke anvendes på For at sikre, at vores applikation er bærbar på tværs af miljøer, definerer vi vores Reliance Party (RP) indstillinger i af filen. example.com phishing-example.com .env Åbent og tilføje: .env or .env.local ###> web-auth/webauthn-symfony-bundle ###
RELYING_PARTY_ID=localhost
RELYING_PARTY_NAME="My Application"
WEBAUTHN_ALLOWED_ORIGINS=localhost
###< web-auth/webauthn-symfony-bundle ###
 i produktionen af, skal være dit nøjagtige roddomæne (f.eks. ) og af . . RELYING_PARTY_ID example.com WebAuthn requires a secure HTTPS context Browsers only exempt localhost for development Den registreringsstrøm (oprettelse) Passkey registrering er en to-trins handshake: 
 
 
 Udfordring: Serveren genererer en unik udfordring og "Optioner til oprettelse". Attestation: Browseren (Safari/Chrome) beder brugeren om FaceID/TouchID, underskriver udfordringen og sender "Attestation Object" tilbage til serveren. Frontend: Stimulus og CSRF Sikkerhed er vigtigst, selv om er iboende phishing-resistent, dine slutpunkter er stadig sårbare over for traditionelle Vi vil videregive Symfony's indbyggede CSRF-tokens via overskrifter i vores . WebAuthn Cross-Site Request Forgery (CSRF) fetch() calls Hvis du har en standard Hjælper (Like at udtrække token fra en meta tag eller skjult input), vi injicerer det i vores Passkey controller. CSRF csrf_protection_controller.js import { Controller } from '@hotwired/stimulus';
import { startRegistration, startAuthentication } from '@simplewebauthn/browser';
import { generateCsrfHeaders } from './csrf_protection_controller.js';

export default class extends Controller {
    static values = {
        optionsUrl: String,
        resultUrl: String,
        isLogin: Boolean
    }

    connect() {
        console.log('Passkey controller connected! 🔑');
    }

    async submit(event) {
        event.preventDefault();
        
        const username = this.element.querySelector('[name="username"]')?.value;

        if (!this.isLoginValue && !username) {
            alert('Please provide a username/email');
            return;
        }

        const csrfHeaders = generateCsrfHeaders(this.element);

        try {
            // 1. Fetch options
            const response = await fetch(this.optionsUrlValue, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json', ...csrfHeaders },
                body: username ? JSON.stringify({ username: username, displayName: username }) : '{}'
            });
            
            if (!response.ok) {
                const errorData = await response.json().catch(() => ({}));
                throw new Error(errorData.errorMessage || 'Failed to fetch WebAuthn options from server');
            }
            
            const options = await response.json();

            // 2. Trigger Apple's Passkey UI (Create or Get)
            let credential;
            if (this.isLoginValue) {
                credential = await startAuthentication({ optionsJSON: options });
            } else {
                credential = await startRegistration({ optionsJSON: options });
            }

            // 3. Send result back to verify
            const result = await fetch(this.resultUrlValue, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json', ...csrfHeaders },
                body: JSON.stringify(credential)
            });

            if (result.ok) {
                window.location.reload();
            } else {
                const errorText = await result.text();
                alert('Authentication failed: ' + errorText);
            }
        } catch (e) {
            console.error(e);
            alert('WebAuthn process failed: ' + e.message);
        }
    }
}
 Rutering Du skal sørge for, at router-typen Det eksisterer. skab : webauthn config/routes/webauthn_routes.yaml webauthn_routes:
    resource: .
    type: webauthn
 Integration af sikkerhedspakke For at give brugerne mulighed for at logge ind med deres Det er nødvendigt at konfigurere . Passkey Symfony Guard (now the Authenticator system) I config/packages/security.yaml kan du læse: security:
    providers:
        app_user_provider:
            entity:
                class: App\Entity\User
                property: email
    firewalls:
        dev:
            pattern: ^/(_(profiler|wdt)|css|images|js)/
            security: false
        main:
            lazy: true
            provider: app_user_provider

            webauthn:
                authentication:
                    routes:
                        options_path: /login/passkey/options
                        result_path: /login/passkey/result
                registration:
                    enabled: true
                    routes:
                        options_path: /register/passkey/options
                        result_path: /register/passkey/result
                success_handler: App\Security\AuthenticationSuccessHandler
                failure_handler: App\Security\AuthenticationFailureHandler

            logout:
                path: app_logout
    access_control:
        - { path: ^/dashboard, roles: ROLE_USER }
 Autentiseringsfejl håndtering Fordi Ceremonier involverer Forespørgsler fra frontend, en standard Symfony redirect på fiasko (f.eks. forsøger at registrere en e-mail, der allerede eksisterer) vil blive tavs slugt af browseren, hvilket resulterer i en frustrerende brugeroplevelse. WebAuthn AJAX fetch() Vi indfører en sædvan Det giver et rent Svar, når anmodningen er AJAX. AuthenticationFailureHandler 401 Unauthorized JSON skaber : src/Security/AuthenticationFailureHandler.php 
namespace App\Security;

use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Http\Authentication\AuthenticationFailureHandlerInterface;
use Symfony\Component\Security\Http\SecurityRequestAttributes;

readonly class AuthenticationFailureHandler implements AuthenticationFailureHandlerInterface
{
    public function __construct(private UrlGeneratorInterface $urlGenerator) {}

    public function onAuthenticationFailure(Request $request, AuthenticationException $exception): RedirectResponse|JsonResponse
    {
        if ($request->getContentTypeFormat() === 'json' || $request->isXmlHttpRequest()) {
            return new JsonResponse([
                'status' => 'error',
                'errorMessage' => $exception->getMessageKey(),
            ], Response::HTTP_UNAUTHORIZED);
        }

        // Store the error in the session
        $request->getSession()->set(SecurityRequestAttributes::AUTHENTICATION_ERROR, $exception);

        return new RedirectResponse($this->urlGenerator->generate('app_login'));
    }
}
 Succesfuld autentiseringshåndtering Da Passkeys ofte omgår den traditionelle login-formular, skal du definere, hvor brugeren går efter en successful “Handshake.” 
namespace App\Security;

use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Http\Authentication\AuthenticationSuccessHandlerInterface;

readonly class AuthenticationSuccessHandler implements AuthenticationSuccessHandlerInterface
{
    public function __construct(private UrlGeneratorInterface $urlGenerator) {}

    public function onAuthenticationSuccess(Request $request, TokenInterface $token): RedirectResponse
    {
        return new RedirectResponse($this->urlGenerator->generate('app_dashboard'));
    }
}
 Verifikation og Apple-specifikke Gotchas 
 
 
 
 HTTPS er obligatorisk: Browsere vil ikke udsætte navigator.credentials på usikre oprindelser (undtagen localhost). RP ID Match: Sørg for, at id'et i webauthn.yaml nøjagtigt matcher dit domæne. Hvis du er på dev.example.com, skal dit RP ID være example.com. Apple AAGUID: Apple-enheder returnerer ofte en "Zero AAGUID" (alle nuller).Hvis dit bibliotek er konfigureret til strengt at validere godkendere via metadata, skal du muligvis tillade "Ukendte godkendere" i din konfiguration. Konklusionen Overgangen til Apple Passkeys med Symfony 7.4 er ikke kun en sikkerhedsopgradering; det er en betydelig forbedring af din brugeroplevelse. , der og komplekse karakterkrav, øger du konvertering og brugeropbevaring. password managers “forgot password” emails, Som senior udvikler eller leder er din prioritet at sikre, at denne implementering forbliver vedligeholdelig. og PHP 8.x attributter, sikrer du, at din codebase forbliver idiomatisk og klar til fremtidige Symfony LTS-udgivelser. WebAuthn-Symfony-Bundle Oversigt over checklister for udplacering 
 
 
 
 
 SSL/TLS: Sørg for, at dit produktionsmiljø bruger et gyldigt certifikat (Passkeys vil mislykkes på simpel HTTP). RP ID-strategi: Beslut, om du vil understøtte underdomæner ved at indstille dit Relaying Party ID til topniveau-domænet. Backupmetoder: Giv altid en sekundær loginmetode (såsom Magic Links eller en traditionel adgangskode) til brugere på ældre enheder, der ikke understøtter FIDO2. Metadata Validation: For apps med høj sikkerhed kan du overveje at aktivere web-auth/webauthn-metadata-tjenesten for at bekræfte, at Passkey faktisk kommer fra en Apple-enhed og ikke en uautoriseret emulator. Du kan finde den fulde implementering og følge projektets fremskridt på GitHub: ] Source Code: https://github.com/mattleads/PasskeysAuth https://github.com/mattleads/PasskeysAuth Lad os forbinde! Hvis du fandt dette nyttigt eller har spørgsmål om implementeringen, vil jeg gerne høre fra dig. Lad os holde kontakten og holde samtalen på tværs af disse platforme: 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Du er her: [https://x.com/MattLeads] Tilgængelig på: [https://t.me/MattLeads] GitHub: [https://github.com/mattleads] https://www.linkedin.com/in/matthew-mochalkin/ https://x.com/MattLeads https://t.me/MattLeads https://github.com/mattleads

Read My Stories

Denne lyd er produceret på historiens originalsprog!

Passkeys i Symfony 7.4: Hvordan man opbygger en helt adgangskodefri fremtid

About Author

KOMMENTARER

HÆNG TAGS

DENNE ARTIKEL BLEV PRÆsenterET I

Related Stories

Meet ZexPRWire: HackerNoon’s Certified Business Blogging Partner

Meet Timescale: HackerNoon Company of the Week

Meet Google Cloud: HackerNoon Company of the Week

Meet HubSpot: HackerNoon Company of the Week

Meet ZexPRWire: HackerNoon’s Certified Business Blogging Partner

Meet Timescale: HackerNoon Company of the Week

Meet Google Cloud: HackerNoon Company of the Week

Meet HubSpot: HackerNoon Company of the Week

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps