I den moderna webbåldern är lösenord inte längre tillräckliga. de är den främsta orsaken till över 80% av dataintrång, som är föremål för phishing, återanvändning och fruktansvärda komplexitetsregler. Passkeys are the future. Passskeys, byggd på webbautentisering ( ) och ersätta traditionella lösenord med kryptografiska nyckelpar. Din enhet (iPhone, Android, Windows Hello, YubiKey) lagrar en privat nyckel, medan servern bara någonsin ser den offentliga nyckeln. WebAuthn FIDO2 I denna omfattande guide, vi med hjälp av Symfony och den officiella Vi kommer att eliminera konceptet med ett lösenord helt från vår applikation. ingen fallback, inga "återställ lösenord" länkar. bara rena, säkra, biometriskt backade passskeys. will build a 100% passwordless authentication system web-auth/webauthn-symfony-bundle Kärnarkitektur och krav Den privata nyckeln lämnar aldrig användarens Apple-enhet (iPhone, Mac, iPad), och den offentliga nyckeln lagras på din Symfony-server. Teknisk Stack 
 
 
 
 
 PHP: 8.2 eller högre (Krav för de senaste WebAuthn libs) Symfoni: 7,4 LTS Databas: PostgreSQL, MySQL eller SQLite för dev (för att lagra Credential Sources) Huvudbibliotek: web-auth/webauthn-symfony-bundle Viktiga paket Kör följande kommando för att installera nödvändiga beroenden: composer require web-auth/webauthn-symfony-bundle:^5.2 \
                 web-auth/webauthn-stimulus:^5.2 \
                 symfony/uid:^7.4
 Vi använder via AssetMapper (som ger utmärkta wrapper-funktioner för den inbyggda webbläsarens WebAuthn-API) eftersom Apple Passkeys kräver en frontend-interaktion som bäst hanteras via en i en modern Symfony-miljö, eller du kan använda React/Vue-moduler. @Självföräldrar/Browser Stimulus controller @Självföräldrar/Browser Databas Schema: Credential källa Det är här vår applikation avviker dramatiskt från en traditionell Symfony-app. Standard Symfony User entiteter är inte utrustade för att lagra Passkey metadata (som AAGUIDs eller public key Cose algoritmer). Användarens entitet Vår Företaget genomför Den märkbart frånvarande är den . 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();
    }

    ...
}
 Enheten PublicKeyCredentialSource En enskild användare kan ha flera passskeys (t.ex. Face ID på sin telefon, Touch ID på sin Mac, en YubiKey på sin nyckelkedja). Skapa Denna enhet måste kunna översätta till och från bundlets infödda och objekt. src/Entity/PublicKeyCredentialSource.php Webauthn\PublicKeyCredentialSource Det är viktigt att vi bevarar den Att inte göra det förstör de attesteringsdata som behövs om du någonsin behöver högsäkerhetsföretagshardvarunycklar. 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 måste också genomföra en Dessa implementerar . 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-paketet förlitar sig på abstrakta gränssnitt för att hitta och behålla användare och legitimationsuppgifter. AnvändareRepository UserRepository implementerar PublicKeyCredentialUserEntityRepositoryInterface. Eftersom vi vill att paketet ska hantera användarskapande automatiskt under en passkey-registrering, implementerar vi också och . 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 och Apple Apple kräver särskilda Detta identifierar din applikation till användarens iCloud Keychain. “Relying Party” (RP) WebAuthn konfiguration Skapa eller uppdatera 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 är otroligt strikt om domäner. En passkey skapad för Kan inte användas på För att säkerställa att vår applikation är bärbar över miljöer definierar vi våra Reliing Party (RP) inställningar i och filen. example.com phishing-example.com .env Öppna och lägga till: .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 av, måste vara din exakta rotdomän (t.ex. ) och och . . RELYING_PARTY_ID example.com WebAuthn requires a secure HTTPS context Browsers only exempt localhost for development Det registreringsflödet (skapande) Passkey registrering är en tvåstegs handskakning: 
 
 
 Utmaning: Servern genererar en unik utmaning och ”Skapa alternativ”. Attestation: Webbläsaren (Safari/Chrome) frågar användaren om FaceID/TouchID, undertecknar utmaningen och skickar ”Attestation Object” tillbaka till servern. The Frontend: Stimulus och CSRF Säkerheten är viktig, även om är i sig phishing-resistent, dina slutpunkter är fortfarande sårbara för traditionella Vi kommer att passera Symfony: s inbyggda CSRF-tokens via rubriker i vår . WebAuthn Cross-Site Request Forgery (CSRF) fetch() calls Förutsatt att du har en standard Hjälpmedel (som som extraherar token från en meta tagg eller dold inmatning), vi injicerar den i vår Passkey-kontroller. 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);
        }
    }
}
 Rutinering Du måste säkerställa att routingtypen för Finns - Skapa : webauthn config/routes/webauthn_routes.yaml webauthn_routes:
    resource: .
    type: webauthn
 Integration av säkerhetsbundel För att tillåta användare att logga in med sina Vi måste konfigurera den . Passkey Symfony Guard (now the Authenticator system) I config/packages/security.yaml finns följande: 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 }
 Autentiseringsfelhanteraren Eftersom Ceremonierna involverar Förfrågningar från frontend, en standard Symfony omdirigera på misslyckande (t.ex. försöker registrera ett e-postmeddelande som redan finns) kommer tyst sväljas av webbläsaren, vilket resulterar i en frustrerande användarupplevelse. WebAuthn AJAX fetch() Vi genomför en sedvänja Det ger tillbaka en ren svar när begäran är AJAX. AuthenticationFailureHandler 401 Unauthorized JSON Skapa : 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'));
    }
}
 Autentisering Success Handler Eftersom Passkeys ofta kringgår det traditionella inloggningsformuläret måste du definiera var användaren 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 och Apple-specifika Gotchas 
 
 
 
 HTTPS är obligatoriskt: Webbläsare kommer inte att exponera navigator.credentials på osäkra ursprung (förutom localhost). RP ID Match: Se till att id i webauthn.yaml matchar exakt din domän. Om du är på dev.example.com, bör ditt RP ID vara example.com. Apple AAGUID: Apple-enheter returnerar ofta en ”Zero AAGUID” (alla nollor). Om ditt bibliotek är konfigurerat för att strikt validera autentiserare via metadata kan du behöva tillåta ”okända autentiserare” i din konfiguration. Slutsats Att byta till Apple Passkeys med Symfony 7.4 är inte bara en säkerhetsuppgradering, det är en betydande förbättring av din användarupplevelse. och och komplexa teckenkrav, ökar du konvertering och användarbevarande. password managers “forgot password” emails, Som ledande utvecklare eller ledare är din prioritet att säkerställa att denna implementering förblir underhållbar. och PHP 8.x attribut, du se till att din kodbas förblir idiomatisk och redo för framtida Symfony LTS-utgåvor. WebAuthn-Symfony-Bundle Sammanfattande checklista för utplacering 
 
 
 
 
 SSL/TLS: Se till att din produktionsmiljö använder ett giltigt certifikat (Passkeys kommer att misslyckas på vanlig HTTP). RP ID-strategi: Bestäm om du vill stödja underdomäner genom att ställa in ditt Relaying Party ID till toppdomänen. Säkerhetskopieringsmetoder: Ge alltid en sekundär inloggningsmetod (som Magic Links eller ett traditionellt lösenord) för användare på äldre enheter som inte stöder FIDO2. Metadata Validation: För högsäkerhetsprogram, överväga att aktivera web-auth/webauthn-metadata-tjänsten för att verifiera att Passkey faktiskt kommer från en Apple-enhet och inte en obehörig emulator. Du kan hitta den fullständiga implementeringen och följa projektets framsteg på GitHub: [ ] Source Code: https://github.com/mattleads/PasskeysAuth https://github.com/mattleads/PasskeysAuth Låt oss ansluta! Om du hittade det här användbart eller har frågor om implementeringen, skulle jag gärna höra från dig. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] X (Twitter): [https://x.com/MattLeads] Hemsida för [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

Det här ljudet är producerat på berättelsens originalspråk!

Passkeys i Symfony 7.4: Hur man bygger en helt lösenordsfri framtid

About Author

KOMMENTARER

HÄNG TAGGAR

DENNA ARTIKEL PRESENTERAS I

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps