Nell'era moderna del web, le password non sono più sufficienti.Sono la causa principale di oltre l'80% delle violazioni dei dati, soggette a phishing, riutilizzo e terribili regole di complessità.L'industria ha parlato: Passkeys are the future. L'applicazione del codice è basata sull'autenticazione web ( ) e Il tuo dispositivo (iPhone, Android, Windows Hello, YubiKey) memorizza una chiave privata, mentre il server vede solo la chiave pubblica. WebAuthn FIDO2 In questa panoramica, noi utilizzando Symfony e l'ufficiale Elimineremo completamente il concetto di password dalla nostra applicazione. nessun fallback, nessun link “reset password”. will build a 100% passwordless authentication system web-auth/webauthn-symfony-bundle Architettura e requisiti di base Passkeys funziona sostituendo un segreto condiviso (password) con una coppia chiave pubblica/privata. La chiave privata non lascia mai il dispositivo Apple dell'utente (iPhone, Mac, iPad), e la chiave pubblica viene memorizzata sul tuo server Symfony. Stack tecnico 
 
 
 
 
 PHP: 8.2 o superiore (Requisito per le libs WebAuthn più recenti) Simfonia: 7.4 LTS Database: PostgreSQL, MySQL o SQLite per dev (per memorizzare le fonti di credenziali) Biblioteca principale: web-auth/webauthn-symfony-bundle Pacchetti essenziali Eseguire il seguente comando per installare le dipendenze necessarie: composer require web-auth/webauthn-symfony-bundle:^5.2 \
                 web-auth/webauthn-stimulus:^5.2 \
                 symfony/uid:^7.4
 Noi usiamo tramite AssetMapper (che fornisce ottime funzioni di avvolgimento per le API WebAuthn del browser nativo) perché Apple Passkeys richiede un'interazione frontend che è meglio gestita tramite un in un moderno ambiente Symfony, oppure è possibile utilizzare i moduli React/Vue. @sindicazione/browser Stimulus controller @sindicazione/browser Schema di database: la fonte credenziale È qui che la nostra applicazione si differenzia drasticamente da una tradizionale app Symfony. Le entità utente standard di Symfony non sono attrezzate per memorizzare i metadati di Passkey (come gli AAGUID o gli algoritmi Cose a chiave pubblica). Entità utente Il nostro Entità Implementazione L’assenza nota è la . 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();
    }

    ...
}
 L'entità di PublicKeyCredentialSource Un singolo utente può avere più passskeys (ad esempio, Face ID sul suo telefono, Touch ID sul suo Mac, un YubiKey sulla sua chiave). creazione Questa entità deve essere in grado di tradurre da e verso il nativo del bundle di oggetto. src/Entity/PublicKeyCredentialSource.php Webauthn\PublicKeyCredentialSource È fondamentale preservare il Non farlo distrugge i dati di attestazione necessari se avete mai bisogno di chiavi hardware aziendali ad alta sicurezza. 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;
    }
}
 Il CredentialSourceRepository È inoltre necessario attuare un Queste attuazioni . 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();
    }
}
 Il bundle WebAuthn si basa su interfacce astratte per trovare e persistere utenti e credenziali. L’UtenteRepositorio Il UserRepository implementa PublicKeyCredentialUserEntityRepositoryInterface. Poiché vogliamo che il pacchetto gestisca automaticamente la creazione di utenti durante una registrazione passkey, implementamo anche e . 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 ?? ''
        );
    }

    ...
 Configurazione: Bridging Symfony e Apple Apple ha bisogno di Questo identifica l'applicazione all'iCloud Keychain dell'utente. “Relying Party” (RP) Configurazione WebAuthn Creare o aggiornare 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 è incredibilmente rigoroso sui domini. un passkey creato per Non può essere utilizzato in Per garantire la portabilità della nostra applicazione in tutti gli ambienti, definiamo le impostazioni di Reliance Party (RP) nel Il file. example.com phishing-example.com .env aperto e aggiungiamo: .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 ###
 nella produzione, deve essere il tuo dominio radicale esatto (ad es. ), e di . . RELYING_PARTY_ID example.com WebAuthn requires a secure HTTPS context Browsers only exempt localhost for development Il flusso di registrazione (creazione) La registrazione di Passkey è una manovra in due passi: 
 
 
 Sfida: il server genera una sfida unica e “opzioni di creazione”. Attestazione: il browser (Safari/Chrome) chiede all’utente FaceID/TouchID, firma la sfida e invia il “Attestazione Object” indietro al server. Il Frontend: Stimulus e CSRF La sicurezza è fondamentale, anche se è inerentemente resistente al phishing, i tuoi endpoint sono ancora vulnerabili ai tradizionali se lasciato non protetto. passeremo i token CSRF integrati di Symfony attraverso gli intestazioni nel nostro . WebAuthn Cross-Site Request Forgery (CSRF) fetch() calls Supponiamo di avere uno standard aiutante (come che estrae il token da un meta tag o input nascosto), lo iniettiamo nel nostro controller Passkey. 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);
        }
    }
}
 Rottura È necessario garantire che il tipo di routing per Esistono e creano : webauthn config/routes/webauthn_routes.yaml webauthn_routes:
    resource: .
    type: webauthn
 Integrazione con il Security Bundle Per consentire agli utenti di accedere con i loro Bisogna configurare il . Passkey Symfony Guard (now the Authenticator system) In config/packages/security.yaml: 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 }
 Gestione dei fallimenti di autenticazione perché Le cerimonie coinvolgono In caso di richieste dal frontend, un reindirizzamento standard di Symfony in caso di fallimento (ad esempio, tentativo di registrare un'e-mail già esistente) sarà tacitamente inghiottito dal browser, con conseguente frustrazione dell'esperienza utente. WebAuthn AJAX fetch() Implementare un costume che restituisce una pulizia La risposta alla richiesta è Ajax. AuthenticationFailureHandler 401 Unauthorized JSON creazione : 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'));
    }
}
 Il gestore di successo dell'autenticazione Poiché Passkeys spesso elimina il tradizionale modulo di accesso, è necessario definire dove l'utente va dopo un 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'));
    }
}
 Verificazione e Gotchas specifici per Apple 
 
 
 
 HTTPS è obbligatorio: i browser non esporranno le credenziali navigator.credentials su origini insicure (tranne localhost). RP ID Match: Assicurati che l'id in webauthn.yaml corrisponda esattamente al tuo dominio. Se sei su dev.example.com, il tuo ID RP dovrebbe essere example.com. Apple AAGUID: i dispositivi Apple restituiscono spesso un "Zero AAGUID" (tutti i zero). Se la libreria è configurata per convalidare rigorosamente gli autenticatori tramite metadati, potrebbe essere necessario abilitare "Autenticatori sconosciuti" nella configurazione. Conclusione La transizione a Apple Passkeys con Symfony 7.4 non è solo un aggiornamento di sicurezza; è un miglioramento significativo per la tua esperienza utente. di e complessi requisiti di carattere, si aumenta la conversione e la ritenzione utente. password managers “forgot password” emails, Come sviluppatore senior o leader, la vostra priorità è garantire che questa implementazione rimanga sostenibile. e attributi PHP 8.x, si assicura che la vostra base di codice rimane idiomatica e pronta per future rilasci Symfony LTS. WebAuthn-Symfony-Bundle Elenco di controllo per la distribuzione 
 
 
 
 
 SSL/TLS: Assicurati che il tuo ambiente di produzione utilizzi un certificato valido (Passkeys fallirà su HTTP semplice). Strategia RP ID: decidi se vuoi supportare i sottodomini impostando il tuo Relaying Party ID sul dominio di livello superiore. Metodi di backup: fornire sempre un metodo di accesso secondario (come Magic Links o una password tradizionale) per gli utenti su dispositivi più vecchi che non supportano FIDO2. Validazione dei metadati: per le applicazioni ad alta sicurezza, considerare di abilitare il servizio web-auth/webauthn-metadata per verificare che il Passkey provenga effettivamente da un dispositivo Apple e non da un emulatore non autorizzato. Puoi trovare l'implementazione completa e seguire il progresso del progetto su GitHub: [ ] Source Code: https://github.com/mattleads/PasskeysAuth https://github.com/mattleads/PasskeysAuth Veniamo a connetterci! Se hai trovato questo utile o hai domande sull'implementazione, mi piacerebbe sentire da te. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Sito web: [https://x.com/MattLeads] Sito ufficiale: [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

Questo audio è prodotto nella lingua originale della storia!

Passkeys in Symfony 7.4: come costruire un futuro completamente senza password

About Author

COMMENTI

CARTELLINI

QUESTO ARTICOLO È STATO PRESENTATO IN

Related Stories

New Year, New Exciting Features: Mint Your Name, Watch Web 2.5 and Meet The Top Startups of The Year

How to Mint Your Name.HackerNoon Web3 Identity Namespace

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

The Ultimate FAQ Guide to HackerNoon's Business Blogging

New Year, New Exciting Features: Mint Your Name, Watch Web 2.5 and Meet The Top Startups of The Year

How to Mint Your Name.HackerNoon Web3 Identity Namespace

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

The Ultimate FAQ Guide to HackerNoon's Business Blogging

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps