W nowoczesnej erze sieci, hasła nie są już wystarczające. są one przyczyną ponad 80% naruszeń danych, podlegających phishingowi, ponownemu użyciu i straszliwym zasadom złożoności. Passkeys are the future. Podstawowe zasady korzystania z Internetu (WEB ) oraz Twoje urządzenie (iPhone, Android, Windows Hello, YubiKey) przechowuje prywatny klucz, podczas gdy serwer widzi tylko klucz publiczny. WebAuthn FIDO2 W tym kompleksowym przewodniku, my Korzystając z Symfony i oficjalnego Z naszej aplikacji całkowicie wyeliminujemy pojęcie hasła. bez zwrotów, bez linków „resetowania hasła”. will build a 100% passwordless authentication system web-auth/webauthn-symfony-bundle Podstawowa architektura i wymagania Klucz prywatny nigdy nie opuszcza urządzenia Apple użytkownika (iPhone, Mac, iPad), a klucz publiczny jest przechowywany na serwerze Symfony. Stack techniczny 
 
 
 
 
 PHP: 8.2 lub nowszy (wymagany dla najnowszych libów WebAuthn) Symfonia: 7,4 LTS Baza danych: PostgreSQL, MySQL lub SQLite for dev (do przechowywania źródeł zaufania) Główna biblioteka: web-auth/webauthn-symfony-bundle Podstawowe pakiety Wykonaj następujące polecenie, aby zainstalować niezbędne zależności: composer require web-auth/webauthn-symfony-bundle:^5.2 \
                 web-auth/webauthn-stimulus:^5.2 \
                 symfony/uid:^7.4
 Używamy za pośrednictwem programu AssetMapper (który zapewnia doskonałe funkcje wklejania dla native browser WebAuthn API), ponieważ aplikacja Apple Passkeys wymaga interakcji frontend, która jest najlepiej obsługiwana za pośrednictwem w nowoczesnym środowisku Symfony lub można korzystać z modułów React/Vue. @simplewebauthn/browser Stimulus controller @simplewebauthn/browser Schemat bazy danych: źródło wiarygodności To tutaj nasza aplikacja dramatycznie odbiega od tradycyjnej aplikacji Symfony. Standardowe jednostki użytkowników Symfony nie są wyposażone do przechowywania metadanych Passkey (takich jak AAGUID lub algorytmy publicznego klucza Cose). Użytkownik Entity Nasza Jednostki wdrażające Zdecydowanie nieobecny jest . 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();
    }

    ...
}
 Podmiot PublicKeyCredentialSource Jeden użytkownik może mieć wiele passkeys (np. Face ID na swoim telefonie, Touch ID na swoim komputerze Mac, YubiKey na swoim kluczu). Stwórz Ta jednostka musi być w stanie przetłumaczyć do i z pakietu native przedmiotów . src/Entity/PublicKeyCredentialSource.php Webauthn\PublicKeyCredentialSource Co najważniejsze, musimy zachować Jeśli tego nie zrobisz, zniszczysz dane potwierdzające, które są potrzebne, jeśli kiedykolwiek będziesz potrzebował kluczy sprzętowych firmy o wysokim poziomie bezpieczeństwa. 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;
    }
}
 o CredentialSourceRepository Należy również zastosować a Takie wdrożenia . 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();
    }
}
 Pakiet WebAuthn opiera się na abstrakcyjnych interfejsach w celu znalezienia i utrzymania użytkowników i zaświadczeń. UżytkownikRepository UserRepository wdraża PublicKeyCredentialUserEntityRepositoryInterface. Ponieważ chcemy, aby pakiet obsługiwał tworzenie użytkowników automatycznie podczas rejestracji passkey, wdrażamy również i . 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 ?? ''
        );
    }

    ...
 Konfiguracja: Bridging Symfony i Apple Apple chce konkretów To identyfikuje aplikację z kluczem iCloud użytkownika. “Relying Party” (RP) Konfiguracja WebAuthn Utwórz lub zaktualizuj 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 jest niesamowicie rygorystyczny co do domen. Nie można stosować na Aby zapewnić, że nasza aplikacja jest przenośna w różnych środowiskach, definiujemy ustawienia naszej strony zależnej (RP) w Z archiwum . example.com phishing-example.com .env otwarty i dodać : .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 ###
 w procesie produkcji, musi być Twoja dokładna domeną korzeniową (np. ) oraz ... . RELYING_PARTY_ID example.com WebAuthn requires a secure HTTPS context Browsers only exempt localhost for development Przepływ rejestracji (tworzenie) Rejestracja Passkey to dwuetapowy krok: 
 
 
 Wyzwanie: Serwer generuje unikalne wyzwanie i „Opcje tworzenia”. Potwierdzenie: przeglądarka (Safari/Chrome) prosi użytkownika o FaceID/TouchID, podpisuje wyzwanie i wysyła „Obiekt potwierdzenia” z powrotem do serwera. Frontend: Stymulacja i CSRF Bezpieczeństwo jest najważniejsze, choć jest odporny na phishing, twoje punkty końcowe są nadal podatne na tradycyjne Jeśli pozostanie bez zabezpieczenia, prześlemy wbudowane tokeny CSRF Symfony za pośrednictwem nagłówków w naszym systemie. . WebAuthn Cross-Site Request Forgery (CSRF) fetch() calls Załóżmy, że masz standard pomocnik (tak jak który wyodrębnia token z meta tagu lub ukrytego wpisu), wstrzykujemy go do naszego kontrolera 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);
        }
    }
}
 Routingiem Musisz upewnić się, że typ istnieje. tworzyć : webauthn config/routes/webauthn_routes.yaml webauthn_routes:
    resource: .
    type: webauthn
 Integracja z Security Bundle Aby umożliwić użytkownikom logowanie się z ich Dlatego musimy skonfigurować . Passkey Symfony Guard (now the Authenticator system) W wersji 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 }
 Sprzęt do zarządzania awarią uwierzytelniania ponieważ Ceremonie zaangażowane W przypadku żądań z frontu, standardowe przekierowanie Symfony w przypadku niepowodzenia (np. próba zarejestrowania już istniejącego e-maila) zostanie cicho połknięte przez przeglądarkę, co spowoduje frustrujące doświadczenie użytkownika. WebAuthn AJAX fetch() Wdrażamy zwyczaj Przywraca czystość Odpowiedź, gdy żądanie jest AJAX. AuthenticationFailureHandler 401 Unauthorized JSON Stwórz : 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'));
    }
}
 Autentication Success Handler – zarządzanie sukcesem Ponieważ Passkeys często omija tradycyjny formularz logowania, musisz zdefiniować, gdzie użytkownik idzie po 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'));
    }
}
 Weryfikacja i Gotcha specyficzne dla Apple 
 
 
 
 HTTPS jest obowiązkowy: przeglądarki nie będą narażać navigator.credentials na niebezpieczne źródła (z wyjątkiem lokalhost). RP ID Match: Upewnij się, że id w webauthn.yaml dokładnie pasuje do Twojej domeny. Jeśli jesteś na dev.example.com, Twój RP ID powinien być example.com. Apple AAGUID: Urządzenia Apple często zwracają „Zero AAGUID” (wszystkie zera). Jeśli Twoja biblioteka jest skonfigurowana do ścisłego zatwierdzania uwierzytelniaczy za pomocą metadanych, może być konieczne zezwolenie na „Nieznane uwierzytelniacze” w konfiguracji. konkluzji Przejście na Apple Passkeys z Symfony 7.4 to nie tylko aktualizacja zabezpieczeń, to znacząca poprawa Twojej obsługi. , i złożone wymagania dotyczące znaków, zwiększasz konwersję i zatrzymanie użytkowników. password managers “forgot password” emails, Jako starszy deweloper lub lider, Twoim priorytetem jest zapewnienie, że ta implementacja pozostanie zrównoważona. i atrybutów PHP 8.x, upewniasz się, że Twoja baza kodowa pozostaje idiomatyczna i gotowa do przyszłych wydaniach Symfony LTS. WebAuthn-Symfony-Bundle Podsumowanie listy kontrolnej do wdrożenia 
 
 
 
 
 SSL/TLS: Upewnij się, że Twoje środowisko produkcyjne używa ważnego certyfikatu (Passkeys zawiedzie w prostym HTTP). Strategia RP ID: Decyduj, czy chcesz obsługiwać poddomeny, ustawiając identyfikator relaying party na domenę najwyższego poziomu. Metody tworzenia kopii zapasowych: Zawsze podawaj drugorzędną metodę logowania (taką jak Magic Links lub tradycyjne hasło) dla użytkowników na starszych urządzeniach, które nie obsługują FIDO2. Walidacja metadanych: W przypadku aplikacji o wysokim poziomie bezpieczeństwa należy rozważyć włączenie usługi web-auth/webauthn-metadata w celu sprawdzenia, czy Passkey pochodzi z urządzenia Apple, a nie z nieautoryzowanego emulatora. Możesz znaleźć pełną implementację i śledzić postęp projektu na GitHub: [ ] Source Code: https://github.com/mattleads/PasskeysAuth https://github.com/mattleads/PasskeysAuth Skontaktuj się z nami! Jeśli znalazłeś to przydatne lub masz pytania dotyczące wdrożenia, chciałbym usłyszeć od ciebie. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Na stronie internetowej: [https://x.com/MattLeads] Wiadomości: [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

Ten dźwięk jest produkowany w oryginalnym języku historii!

Passkeys w Symfonii 7.4: Jak zbudować przyszłość bez hasła

About Author

UWAGI

ZAWIEŚĆ TAGI

ARTYKUŁ TEN ZOSTAŁ PREZENTOWANY W

Related Stories

Meet Klink Finance: HackerNoon Company of the Week

Meet Confluent: HackerNoon Company of the Week

The Noonies 2022 Award Goes to Madalin Muraretiu - Contributor of The Year - Cryptocurrency Edition

Meet Beldex: HackerNoon Company of the Week

Meet Klink Finance: HackerNoon Company of the Week

Meet Confluent: HackerNoon Company of the Week

The Noonies 2022 Award Goes to Madalin Muraretiu - Contributor of The Year - Cryptocurrency Edition

Meet Beldex: HackerNoon Company of the Week

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps