1use crate::authentication::credentials::{Credential, CredentialMetadata};
99use crate::errors::{AuthError, Result};
100use crate::methods::{AuthMethod, MethodResult};
101use crate::tokens::{AuthToken, TokenManager};
102use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
103use serde::{Deserialize, Serialize};
104use std::time::SystemTime;
105use std::{collections::HashMap, sync::RwLock};
106
107#[cfg(feature = "passkeys")]
108use std::time::Duration;
109
110#[cfg(feature = "passkeys")]
112use coset::iana;
113#[cfg(feature = "passkeys")]
114use passkey::{
115 authenticator::{Authenticator, UserCheck, UserValidationMethod},
116 client::Client,
117 types::{
118 Bytes, Passkey,
119 ctap2::{Aaguid, Ctap2Error},
120 rand::random_vec,
121 webauthn::{
122 AttestationConveyancePreference, AuthenticatedPublicKeyCredential,
123 CreatedPublicKeyCredential, CredentialCreationOptions, CredentialRequestOptions,
124 PublicKeyCredentialCreationOptions, PublicKeyCredentialDescriptor,
125 PublicKeyCredentialParameters, PublicKeyCredentialRequestOptions,
126 PublicKeyCredentialRpEntity, PublicKeyCredentialType, PublicKeyCredentialUserEntity,
127 UserVerificationRequirement,
128 },
129 },
130};
131#[cfg(feature = "passkeys")]
132use passkey_client::DefaultClientData;
133#[cfg(feature = "passkeys")]
134use url::Url;
135
136fn json_bytes(value: &serde_json::Value) -> Option<Vec<u8>> {
140 match value {
141 serde_json::Value::String(s) => URL_SAFE_NO_PAD.decode(s).ok(),
142 serde_json::Value::Array(items) => items
143 .iter()
144 .map(|b| b.as_u64().and_then(|n| u8::try_from(n).ok()))
145 .collect(),
146 _ => None,
147 }
148}
149
150#[cfg(feature = "passkeys")]
152fn der_element(input: &[u8]) -> Option<(u8, &[u8], &[u8])> {
153 let (&tag, rest) = input.split_first()?;
154 let (&first, rest) = rest.split_first()?;
155 let (len, rest) = if first < 0x80 {
156 (usize::from(first), rest)
157 } else {
158 let count = usize::from(first & 0x7f);
159 if count == 0 || count > 4 || rest.len() < count {
160 return None;
161 }
162 let len = rest[..count]
163 .iter()
164 .fold(0usize, |acc, &b| (acc << 8) | usize::from(b));
165 (len, &rest[count..])
166 };
167 if rest.len() < len {
168 return None;
169 }
170 Some((tag, &rest[..len], &rest[len..]))
171}
172
173#[cfg(feature = "passkeys")]
176fn jwk_from_spki(spki: &[u8], algorithm: i64) -> Result<serde_json::Value> {
177 const BAD: &str = "Passkey public key is not a valid SubjectPublicKeyInfo";
178 const EC_PUBLIC_KEY: &[u8] = &[0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01];
179 const P256: &[u8] = &[0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07];
180 const P384: &[u8] = &[0x2b, 0x81, 0x04, 0x00, 0x22];
181 const RSA: &[u8] = &[0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01];
182
183 let bad = || AuthError::validation(BAD);
184 let (tag, spki_body, trailing) = der_element(spki).ok_or_else(bad)?;
185 if tag != 0x30 || !trailing.is_empty() {
186 return Err(bad());
187 }
188 let (tag, alg_id, rest) = der_element(spki_body).ok_or_else(bad)?;
189 if tag != 0x30 {
190 return Err(bad());
191 }
192 let (tag, key_bits, trailing) = der_element(rest).ok_or_else(bad)?;
193 if tag != 0x03 || !trailing.is_empty() || key_bits.first() != Some(&0) {
194 return Err(bad());
195 }
196 let key = &key_bits[1..];
197 let (tag, key_oid, alg_params) = der_element(alg_id).ok_or_else(bad)?;
198 if tag != 0x06 {
199 return Err(bad());
200 }
201
202 match (algorithm, key_oid) {
203 (-7 | -35, oid) if oid == EC_PUBLIC_KEY => {
204 let (tag, curve, _) = der_element(alg_params).ok_or_else(bad)?;
205 let (crv, alg, size) = match (algorithm, curve) {
206 (-7, c) if tag == 0x06 && c == P256 => ("P-256", "ES256", 32),
207 (-35, c) if tag == 0x06 && c == P384 => ("P-384", "ES384", 48),
208 _ => return Err(AuthError::validation("Unsupported passkey curve")),
209 };
210 if key.len() != 1 + 2 * size || key[0] != 0x04 {
211 return Err(bad());
212 }
213 Ok(serde_json::json!({
214 "kty": "EC",
215 "crv": crv,
216 "alg": alg,
217 "x": URL_SAFE_NO_PAD.encode(&key[1..1 + size]),
218 "y": URL_SAFE_NO_PAD.encode(&key[1 + size..]),
219 }))
220 }
221 (-257, oid) if oid == RSA => {
222 let (tag, rsa_key, trailing) = der_element(key).ok_or_else(bad)?;
223 if tag != 0x30 || !trailing.is_empty() {
224 return Err(bad());
225 }
226 let (tag, n, rest) = der_element(rsa_key).ok_or_else(bad)?;
227 let (tag_e, e, trailing) = der_element(rest).ok_or_else(bad)?;
228 if tag != 0x02 || tag_e != 0x02 || !trailing.is_empty() {
229 return Err(bad());
230 }
231 let strip = |v: &[u8]| -> Vec<u8> {
232 let skip = v.iter().take_while(|&&b| b == 0).count();
233 v[skip..].to_vec()
234 };
235 Ok(serde_json::json!({
236 "kty": "RSA",
237 "alg": "RS256",
238 "n": URL_SAFE_NO_PAD.encode(strip(n)),
239 "e": URL_SAFE_NO_PAD.encode(strip(e)),
240 }))
241 }
242 _ => Err(AuthError::validation("Unsupported passkey key algorithm")),
243 }
244}
245
246#[cfg(feature = "passkeys")]
248struct PasskeyUserValidation;
249
250#[cfg(feature = "passkeys")]
251#[async_trait::async_trait]
252impl UserValidationMethod for PasskeyUserValidation {
253 type PasskeyItem = Passkey;
254
255 async fn check_user<'a>(
256 &self,
257 _credential: Option<&'a Passkey>,
258 presence: bool,
259 verification: bool,
260 ) -> std::result::Result<UserCheck, Ctap2Error> {
261 Ok(UserCheck {
262 presence,
263 verification,
264 })
265 }
266
267 fn is_verification_enabled(&self) -> Option<bool> {
268 Some(true)
269 }
270
271 fn is_presence_enabled(&self) -> bool {
272 true
273 }
274}
275
276pub struct PasskeyAuthMethod {
358 pub config: PasskeyConfig,
359 pub token_manager: TokenManager,
360 pub registered_passkeys: RwLock<HashMap<String, PasskeyRegistration>>,
362 #[cfg(feature = "passkeys")]
365 pending_challenges: RwLock<HashMap<String, Vec<u8>>>,
366}
367
368impl std::fmt::Debug for PasskeyAuthMethod {
369 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
370 let mut s = f.debug_struct("PasskeyAuthMethod");
371 s.field("config", &self.config);
372 s.field("token_manager", &"<TokenManager>");
373 s.field("registered_passkeys", &"<RwLock<HashMap>>");
374 #[cfg(feature = "passkeys")]
375 s.field("pending_challenges", &"<RwLock<HashMap>>");
376 s.finish()
377 }
378}
379
380#[derive(Debug, Clone, Serialize, Deserialize)]
382pub struct PasskeyConfig {
383 pub rp_id: String,
385 pub rp_name: String,
387 pub origin: String,
389 pub timeout_ms: u32,
391 pub user_verification: String, pub authenticator_attachment: Option<String>, pub require_resident_key: bool,
397 #[serde(default = "default_attestation_conveyance")]
400 pub attestation_conveyance: String,
401}
402
403fn default_attestation_conveyance() -> String {
404 "direct".to_string()
405}
406
407impl Default for PasskeyConfig {
408 fn default() -> Self {
409 Self {
410 rp_id: "localhost".to_string(),
411 rp_name: "Auth Framework Demo".to_string(),
412 origin: "http://localhost:3000".to_string(),
413 timeout_ms: 60000, user_verification: "preferred".to_string(),
415 authenticator_attachment: None,
416 require_resident_key: false,
417 attestation_conveyance: default_attestation_conveyance(),
418 }
419 }
420}
421
422#[derive(Clone, Serialize, Deserialize)]
424pub struct PasskeyRegistration {
425 pub user_id: String,
426 pub user_name: String,
427 pub user_display_name: String,
428 pub credential_id: Vec<u8>,
429 pub passkey_data: String, pub created_at: SystemTime,
431 pub last_used: Option<SystemTime>,
432}
433
434impl std::fmt::Debug for PasskeyRegistration {
435 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
436 let mut d = f.debug_struct("PasskeyRegistration");
437 d.field("user_id", &self.user_id);
438 d.field("user_name", &self.user_name);
439 d.field("user_display_name", &self.user_display_name);
440 d.field("credential_id", &self.credential_id);
441 d.field(
442 "passkey_data",
443 &crate::utils::redact::redacted(&self.passkey_data),
444 );
445 d.field("created_at", &self.created_at);
446 d.field("last_used", &self.last_used);
447 d.finish()
448 }
449}
450
451impl PasskeyAuthMethod {
452 pub fn new(config: PasskeyConfig, token_manager: TokenManager) -> Result<Self> {
454 #[cfg(feature = "passkeys")]
455 {
456 Ok(Self {
457 config,
458 token_manager,
459 registered_passkeys: RwLock::new(HashMap::new()),
460 pending_challenges: RwLock::new(HashMap::new()),
461 })
462 }
463
464 #[cfg(not(feature = "passkeys"))]
465 {
466 let _ = (config, token_manager); Err(AuthError::config(
468 "Passkey support not compiled in. Enable 'passkeys' feature.",
469 ))
470 }
471 }
472
473 #[cfg(feature = "passkeys")]
475 pub async fn register_passkey(
476 &mut self,
477 user_id: &str,
478 user_name: &str,
479 user_display_name: &str,
480 ) -> Result<CreatedPublicKeyCredential> {
481 let origin = Url::parse(&self.config.origin)
482 .map_err(|e| AuthError::config(format!("Invalid origin URL: {}", e)))?;
483
484 let aaguid = Aaguid::new_empty();
486 let user_validation = PasskeyUserValidation;
487 let store: Option<Passkey> = None;
488 let authenticator = Authenticator::new(aaguid, store, user_validation);
489
490 let mut client = Client::new(authenticator);
492
493 let challenge: Bytes = random_vec(32).into();
495
496 let user_entity = PublicKeyCredentialUserEntity {
498 id: Bytes::from(user_id.as_bytes().to_vec()),
499 display_name: user_display_name.to_string(),
500 name: user_name.to_string(),
501 };
502
503 let request = CredentialCreationOptions {
505 public_key: PublicKeyCredentialCreationOptions {
506 rp: PublicKeyCredentialRpEntity {
507 id: None, name: self.config.rp_name.clone(),
509 },
510 user: user_entity,
511 challenge,
512 pub_key_cred_params: vec![
513 PublicKeyCredentialParameters {
514 ty: PublicKeyCredentialType::PublicKey,
515 alg: iana::Algorithm::ES256,
516 },
517 PublicKeyCredentialParameters {
518 ty: PublicKeyCredentialType::PublicKey,
519 alg: iana::Algorithm::RS256,
520 },
521 ],
522 timeout: Some(self.config.timeout_ms),
523 exclude_credentials: None,
524 authenticator_selection: None,
525 hints: None,
526 attestation: match self.config.attestation_conveyance.as_str() {
527 "none" => AttestationConveyancePreference::None,
528 "indirect" => AttestationConveyancePreference::Indirect,
529 "enterprise" => AttestationConveyancePreference::Enterprise,
530 _ => AttestationConveyancePreference::Direct,
532 },
533 attestation_formats: None,
534 extensions: None,
535 },
536 };
537
538 let credential = client
540 .register(&origin, request, DefaultClientData)
541 .await
542 .map_err(|e| AuthError::validation(format!("Passkey registration failed: {:?}", e)))?;
543
544 self.register_credential(user_id, user_name, user_display_name, &credential)?;
545 Ok(credential)
546 }
547
548 #[cfg(feature = "passkeys")]
554 pub fn register_credential(
555 &mut self,
556 user_id: &str,
557 user_name: &str,
558 user_display_name: &str,
559 credential: &CreatedPublicKeyCredential,
560 ) -> Result<()> {
561 let credential_id = &credential.raw_id;
562 let credential_id_b64 = URL_SAFE_NO_PAD.encode(credential_id.as_slice());
563
564 let credential_value = serde_json::to_value(credential)
565 .map_err(|e| AuthError::validation(format!("Unreadable passkey credential: {e}")))?;
566 let response = credential_value
567 .get("response")
568 .ok_or_else(|| AuthError::validation("Passkey credential has no response"))?;
569 let spki = response
570 .get("publicKey")
571 .and_then(json_bytes)
572 .ok_or_else(|| AuthError::validation("Passkey credential has no public key"))?;
573 let algorithm = response
574 .get("publicKeyAlgorithm")
575 .and_then(serde_json::Value::as_i64)
576 .ok_or_else(|| AuthError::validation("Passkey credential has no key algorithm"))?;
577 let public_key_jwk = jwk_from_spki(&spki, algorithm)?;
578 let sign_count = response
579 .get("authenticatorData")
580 .and_then(json_bytes)
581 .and_then(|d| {
582 d.get(33..37)
583 .map(|c| u32::from_be_bytes([c[0], c[1], c[2], c[3]]))
584 })
585 .ok_or_else(|| AuthError::validation("Passkey credential has no authenticator data"))?;
586
587 let passkey_data_json = serde_json::json!({
588 "credential_id": credential_id_b64,
589 "public_key": public_key_jwk,
590 "signature_counter": sign_count,
591 "raw_attestation": credential_value,
592 });
593 let passkey_data_str = serde_json::to_string(&passkey_data_json).map_err(|e| {
594 AuthError::validation(format!("Failed to serialize passkey data: {}", e))
595 })?;
596
597 let registration = PasskeyRegistration {
598 user_id: user_id.to_string(),
599 user_name: user_name.to_string(),
600 user_display_name: user_display_name.to_string(),
601 credential_id: credential_id.as_slice().to_vec(),
602 passkey_data: passkey_data_str,
603 created_at: SystemTime::now(),
604 last_used: None,
605 };
606
607 {
608 let mut passkeys = self.registered_passkeys.write().map_err(|_| {
609 AuthError::internal(
610 "Lock poisoned — a prior thread panicked while holding this lock",
611 )
612 })?;
613 passkeys.insert(credential_id_b64, registration);
614 }
615
616 tracing::info!("Successfully registered passkey for user: {}", user_id);
617 Ok(())
618 }
619
620 #[cfg(feature = "passkeys")]
622 pub fn registered_passkey(&self, credential_id: &[u8]) -> Option<PasskeyRegistration> {
623 let key = URL_SAFE_NO_PAD.encode(credential_id);
624 self.registered_passkeys.read().ok()?.get(&key).cloned()
625 }
626
627 #[cfg(feature = "passkeys")]
629 pub async fn initiate_authentication(
630 &self,
631 user_id: Option<&str>,
632 ) -> Result<CredentialRequestOptions> {
633 let challenge_bytes = random_vec(32);
634 let challenge: Bytes = challenge_bytes.clone().into();
635
636 let allow_credential_ids: Vec<(Vec<u8>, String)> = {
637 let passkeys = self.registered_passkeys.read().map_err(|_| {
638 AuthError::internal(
639 "Lock poisoned — a prior thread panicked while holding this lock",
640 )
641 })?;
642 let iter: Box<dyn Iterator<Item = &PasskeyRegistration>> = if let Some(uid) = user_id {
643 Box::new(passkeys.values().filter(move |reg| reg.user_id == uid))
644 } else {
645 Box::new(passkeys.values())
646 };
647 iter.map(|reg| {
648 (
649 reg.credential_id.clone(),
650 URL_SAFE_NO_PAD.encode(®.credential_id),
651 )
652 })
653 .collect()
654 };
655
656 {
659 let mut challenges = self.pending_challenges.write().map_err(|_| {
660 AuthError::internal(
661 "Lock poisoned — a prior thread panicked while holding this lock",
662 )
663 })?;
664 for (_, cred_id_b64) in &allow_credential_ids {
665 challenges.insert(cred_id_b64.clone(), challenge_bytes.clone());
666 }
667 challenges.insert("latest".to_string(), challenge_bytes.clone());
669 }
670
671 let allow_credentials: Vec<PublicKeyCredentialDescriptor> = allow_credential_ids
672 .into_iter()
673 .map(|(raw_id, _)| PublicKeyCredentialDescriptor {
674 ty: PublicKeyCredentialType::PublicKey,
675 id: raw_id.into(),
676 transports: None,
677 })
678 .collect();
679
680 let request_options = CredentialRequestOptions {
681 public_key: PublicKeyCredentialRequestOptions {
682 challenge,
683 timeout: Some(self.config.timeout_ms),
684 rp_id: Some(self.config.rp_id.clone()),
685 allow_credentials: Some(allow_credentials),
686 user_verification: match self.config.user_verification.as_str() {
687 "required" => UserVerificationRequirement::Required,
688 "discouraged" => UserVerificationRequirement::Discouraged,
689 _ => UserVerificationRequirement::Preferred,
690 },
691 hints: None,
692 attestation: match self.config.attestation_conveyance.as_str() {
693 "none" => AttestationConveyancePreference::None,
694 "indirect" => AttestationConveyancePreference::Indirect,
695 "enterprise" => AttestationConveyancePreference::Enterprise,
696 _ => AttestationConveyancePreference::Direct,
697 },
698 attestation_formats: None,
699 extensions: None,
700 },
701 };
702
703 tracing::info!("Generated passkey authentication options");
704 Ok(request_options)
705 }
706
707 #[cfg(feature = "passkeys")]
709 pub async fn complete_authentication(
710 &mut self,
711 credential_response: &AuthenticatedPublicKeyCredential,
712 ) -> Result<AuthToken> {
713 let credential_id = &credential_response.raw_id;
714 let credential_id_b64 = URL_SAFE_NO_PAD.encode(credential_id.as_slice());
715
716 let mut registration = {
718 let passkeys = self.registered_passkeys.read().map_err(|_| {
719 AuthError::internal(
720 "Lock poisoned — a prior thread panicked while holding this lock",
721 )
722 })?;
723 passkeys
724 .get(&credential_id_b64)
725 .ok_or_else(|| AuthError::validation("Unknown credential ID"))?
726 .clone()
727 };
728
729 let assertion_response = serde_json::to_string(credential_response).map_err(|e| {
732 AuthError::InvalidCredential {
733 credential_type: "passkey".to_string(),
734 message: format!("Failed to serialize credential response: {}", e),
735 }
736 })?;
737
738 let passkey_data: serde_json::Value = serde_json::from_str(®istration.passkey_data)
740 .map_err(|e| AuthError::InvalidCredential {
741 credential_type: "passkey".to_string(),
742 message: format!("Failed to parse stored passkey data: {}", e),
743 })?;
744
745 let public_key_jwk = passkey_data
746 .get("public_key")
747 .cloned()
748 .unwrap_or(serde_json::Value::Null);
749 let stored_counter = passkey_data
750 .get("signature_counter")
751 .and_then(|v| v.as_u64())
752 .unwrap_or(0) as u32;
753
754 let expected_challenge_bytes: Vec<u8> = {
757 let mut challenges = self.pending_challenges.write().map_err(|_| {
758 AuthError::internal(
759 "Lock poisoned — a prior thread panicked while holding this lock",
760 )
761 })?;
762 let own = challenges.remove(&credential_id_b64);
763 let taken = match own {
766 Some(own) => {
767 if challenges.get("latest") == Some(&own) {
768 challenges.remove("latest");
769 }
770 Some(own)
771 }
772 None => challenges.remove("latest"),
773 };
774 taken.ok_or_else(|| {
775 AuthError::validation(
776 "No pending challenge found; call initiate_authentication first",
777 )
778 })?
779 };
780
781 let verification_result = self
783 .advanced_verification_flow(
784 &assertion_response,
785 expected_challenge_bytes.as_slice(),
786 stored_counter,
787 &public_key_jwk,
788 )
789 .await?;
790
791 if !verification_result.signature_valid {
792 return Err(AuthError::validation(
793 "Passkey signature verification failed",
794 ));
795 }
796
797 let mut passkey_data: serde_json::Value = serde_json::from_str(®istration.passkey_data)
799 .map_err(|e| AuthError::InvalidCredential {
800 credential_type: "passkey".to_string(),
801 message: format!(
802 "Failed to parse stored passkey data during counter update: {}",
803 e
804 ),
805 })?;
806 passkey_data["signature_counter"] =
807 serde_json::Value::Number(serde_json::Number::from(verification_result.new_counter));
808 registration.passkey_data =
809 serde_json::to_string(&passkey_data).map_err(|e| AuthError::InvalidCredential {
810 credential_type: "passkey".to_string(),
811 message: format!("Failed to serialize updated passkey data: {}", e),
812 })?;
813 registration.last_used = Some(SystemTime::now());
814
815 {
816 let mut passkeys = self.registered_passkeys.write().map_err(|_| {
817 AuthError::internal(
818 "Lock poisoned — a prior thread panicked while holding this lock",
819 )
820 })?;
821 passkeys.insert(credential_id_b64.clone(), registration.clone());
822 }
823
824 let token = self.token_manager.create_jwt_token(
826 ®istration.user_id,
827 vec![],
828 Some(Duration::from_secs(3600)),
829 )?;
830
831 tracing::info!(
832 "Passkey authentication successful for user: {} (counter: {} -> {})",
833 registration.user_id,
834 stored_counter,
835 verification_result.new_counter
836 );
837 Ok(AuthToken::new(
838 ®istration.user_id,
839 token,
840 Duration::from_secs(3600),
841 "passkey",
842 ))
843 }
844
845 #[cfg(not(feature = "passkeys"))]
847 pub async fn register_passkey(
848 &mut self,
849 _user_id: &str,
850 _user_name: &str,
851 _user_display_name: &str,
852 ) -> Result<()> {
853 Err(AuthError::config(
854 "Passkey support not compiled in. Enable 'passkeys' feature.",
855 ))
856 }
857}
858
859impl AuthMethod for PasskeyAuthMethod {
860 type MethodResult = MethodResult;
861 type AuthToken = AuthToken;
862
863 fn name(&self) -> &str {
864 "passkey"
865 }
866
867 async fn authenticate(
868 &self,
869 credential: Credential,
870 _metadata: CredentialMetadata,
871 ) -> Result<Self::MethodResult> {
872 #[cfg(feature = "passkeys")]
873 {
874 match credential {
875 Credential::Passkey {
876 credential_id,
877 assertion_response,
878 } => {
879 let credential_id_b64 = URL_SAFE_NO_PAD.encode(&credential_id);
881 let registration = {
882 let passkeys = self.registered_passkeys.read().map_err(|_| {
883 AuthError::internal(
884 "Lock poisoned — a prior thread panicked while holding this lock",
885 )
886 })?;
887 passkeys
888 .get(&credential_id_b64)
889 .cloned()
890 .ok_or_else(|| AuthError::validation("Unknown credential ID"))?
891 };
892
893 tracing::debug!(
894 "Processing passkey assertion for credential: {}",
895 credential_id_b64
896 );
897
898 let passkey_data: serde_json::Value =
901 serde_json::from_str(®istration.passkey_data).map_err(|e| {
902 AuthError::InvalidCredential {
903 credential_type: "passkey".to_string(),
904 message: format!("Failed to parse stored passkey data: {}", e),
905 }
906 })?;
907
908 let public_key_jwk = passkey_data
909 .get("public_key")
910 .cloned()
911 .unwrap_or(serde_json::Value::Null);
912 let stored_counter = passkey_data
913 .get("signature_counter")
914 .and_then(|v| v.as_u64())
915 .unwrap_or(0) as u32;
916
917 let expected_challenge_bytes: Vec<u8> = {
920 let challenges = self.pending_challenges.read().map_err(|_| {
921 AuthError::internal(
922 "Lock poisoned — a prior thread panicked while holding this lock",
923 )
924 })?;
925 challenges
926 .get(&credential_id_b64)
927 .or_else(|| challenges.get("latest"))
928 .cloned()
929 .ok_or_else(|| {
930 AuthError::validation(
931 "No pending challenge found; call initiate_authentication first",
932 )
933 })?
934 };
935
936 match self
938 .advanced_verification_flow(
939 &assertion_response,
940 expected_challenge_bytes.as_slice(),
941 stored_counter,
942 &public_key_jwk,
943 )
944 .await
945 {
946 Ok(verification_result) => {
947 if !verification_result.signature_valid {
948 return Err(AuthError::validation(
949 "Passkey signature verification failed",
950 ));
951 }
952
953 let mut updated_registration = registration.clone();
955
956 let mut passkey_data: serde_json::Value = serde_json::from_str(
958 &updated_registration.passkey_data,
959 )
960 .map_err(|e| AuthError::InvalidCredential {
961 credential_type: "passkey".to_string(),
962 message: format!("Failed to parse stored passkey data: {}", e),
963 })?;
964
965 passkey_data["signature_counter"] = serde_json::Value::Number(
966 serde_json::Number::from(verification_result.new_counter),
967 );
968
969 updated_registration.passkey_data =
970 serde_json::to_string(&passkey_data).map_err(|e| {
971 AuthError::InvalidCredential {
972 credential_type: "passkey".to_string(),
973 message: format!(
974 "Failed to serialize updated passkey data: {}",
975 e
976 ),
977 }
978 })?;
979
980 updated_registration.last_used = Some(SystemTime::now());
981
982 {
983 let mut passkeys = self.registered_passkeys.write()
984 .map_err(|_| AuthError::internal("Lock poisoned — a prior thread panicked while holding this lock"))?;
985 passkeys.insert(credential_id_b64.clone(), updated_registration);
986 }
987
988 tracing::info!(
989 "Advanced passkey verification successful for user: {} (counter: {} -> {})",
990 registration.user_id,
991 stored_counter,
992 verification_result.new_counter
993 );
994 }
995 Err(e) => {
996 tracing::error!("Advanced passkey verification failed: {}", e);
997 return Err(e);
998 }
999 }
1000
1001 tracing::debug!("Assertion response length: {}", assertion_response.len());
1003
1004 tracing::info!(
1007 "Passkey assertion verified successfully for user: {}",
1008 registration.user_id
1009 );
1010
1011 let token = self.token_manager.create_jwt_token(
1012 ®istration.user_id,
1013 vec![], Some(Duration::from_secs(3600)), )?;
1016
1017 let auth_token = AuthToken::new(
1018 ®istration.user_id,
1019 token,
1020 Duration::from_secs(3600),
1021 "passkey",
1022 );
1023
1024 tracing::info!(
1025 "Passkey authentication successful for user: {}",
1026 registration.user_id
1027 );
1028 Ok(MethodResult::Success(Box::new(auth_token)))
1029 }
1030 _ => Ok(MethodResult::Failure {
1031 reason: "Invalid credential type for passkey authentication".to_string(),
1032 }),
1033 }
1034 }
1035
1036 #[cfg(not(feature = "passkeys"))]
1037 {
1038 let _ = credential; Ok(MethodResult::Failure {
1040 reason: "Passkey support not compiled in. Enable 'passkeys' feature.".to_string(),
1041 })
1042 }
1043 }
1044
1045 fn validate_config(&self) -> Result<()> {
1046 if self.config.rp_id.is_empty() {
1047 return Err(AuthError::config("Passkey RP ID cannot be empty"));
1048 }
1049 if self.config.origin.is_empty() {
1050 return Err(AuthError::config("Passkey origin cannot be empty"));
1051 }
1052 if self.config.timeout_ms == 0 {
1053 return Err(AuthError::config("Passkey timeout must be greater than 0"));
1054 }
1055
1056 match self.config.user_verification.as_str() {
1058 "required" | "preferred" | "discouraged" => {}
1059 _ => return Err(AuthError::config("Invalid user verification requirement")),
1060 }
1061
1062 #[cfg(feature = "passkeys")]
1064 {
1065 Url::parse(&self.config.origin)
1066 .map_err(|e| AuthError::config(format!("Invalid origin URL: {}", e)))?;
1067 }
1068
1069 Ok(())
1070 }
1071
1072 fn supports_refresh(&self) -> bool {
1073 false }
1075
1076 async fn refresh_token(&self, _refresh_token: String) -> Result<Self::AuthToken, AuthError> {
1077 Err(AuthError::validation(
1078 "Passkeys do not support token refresh",
1079 ))
1080 }
1081}
1082
1083impl PasskeyAuthMethod {
1084 pub async fn advanced_verification_flow(
1087 &self,
1088 assertion_response: &str,
1089 expected_challenge: &[u8],
1090 stored_counter: u32,
1091 public_key_jwk: &serde_json::Value,
1092 ) -> Result<AdvancedVerificationResult> {
1093 use ring::digest;
1094
1095 tracing::info!("Starting advanced passkey verification flow");
1096
1097 let assertion: serde_json::Value = serde_json::from_str(assertion_response)
1099 .map_err(|_| AuthError::validation("Invalid assertion response format"))?;
1100
1101 let client_data_json = assertion
1103 .get("response")
1104 .and_then(|r| r.get("clientDataJSON"))
1105 .ok_or_else(|| AuthError::validation("Missing clientDataJSON"))?;
1106
1107 let decoded_client_data = json_bytes(client_data_json)
1108 .ok_or_else(|| AuthError::validation("Invalid encoding of clientDataJSON"))?;
1109
1110 let client_data_str = std::str::from_utf8(&decoded_client_data)
1111 .map_err(|_| AuthError::validation("Invalid UTF-8 in clientDataJSON"))?;
1112
1113 let client_data: serde_json::Value = serde_json::from_str(client_data_str)
1114 .map_err(|_| AuthError::validation("Invalid JSON in clientDataJSON"))?;
1115
1116 let response_challenge = client_data
1118 .get("challenge")
1119 .and_then(|c| c.as_str())
1120 .ok_or_else(|| AuthError::validation("Missing challenge in clientDataJSON"))?;
1121
1122 let decoded_challenge = URL_SAFE_NO_PAD
1123 .decode(response_challenge)
1124 .map_err(|_| AuthError::validation("Invalid challenge base64"))?;
1125
1126 if decoded_challenge != expected_challenge {
1127 return Err(AuthError::validation("Challenge mismatch"));
1128 }
1129
1130 let origin = client_data
1132 .get("origin")
1133 .and_then(|o| o.as_str())
1134 .ok_or_else(|| AuthError::validation("Missing origin"))?;
1135
1136 if origin != self.config.origin {
1137 return Err(AuthError::validation("Origin mismatch"));
1138 }
1139
1140 let operation_type = client_data
1142 .get("type")
1143 .and_then(|t| t.as_str())
1144 .ok_or_else(|| AuthError::validation("Missing operation type"))?;
1145
1146 if operation_type != "webauthn.get" {
1147 return Err(AuthError::validation("Invalid operation type"));
1148 }
1149
1150 let authenticator_data = assertion
1152 .get("response")
1153 .and_then(|r| r.get("authenticatorData"))
1154 .ok_or_else(|| AuthError::validation("Missing authenticatorData"))?;
1155
1156 let auth_data_bytes = json_bytes(authenticator_data)
1157 .ok_or_else(|| AuthError::validation("Invalid authenticatorData encoding"))?;
1158
1159 if auth_data_bytes.len() < 37 {
1160 return Err(AuthError::validation("AuthenticatorData too short"));
1161 }
1162
1163 let rp_id_hash = &auth_data_bytes[0..32];
1165 let expected_rp_id_hash = {
1166 let mut context = digest::Context::new(&digest::SHA256);
1167 context.update(self.config.rp_id.as_bytes());
1168 context.finish()
1169 };
1170
1171 if rp_id_hash != expected_rp_id_hash.as_ref() {
1172 return Err(AuthError::validation("RP ID hash mismatch"));
1173 }
1174
1175 let flags = auth_data_bytes[32];
1177 let user_present = (flags & 0x01) != 0;
1178 let user_verified = (flags & 0x04) != 0;
1179
1180 if !user_present {
1181 return Err(AuthError::validation("User not present"));
1182 }
1183
1184 let new_counter = self.extract_counter_from_assertion(assertion_response)?;
1186
1187 if new_counter != 0 && new_counter <= stored_counter {
1192 return Err(AuthError::validation(
1193 "Counter did not increase - possible replay attack or cloned authenticator",
1194 ));
1195 }
1196
1197 self.verify_assertion_signature(
1199 assertion_response,
1200 &auth_data_bytes,
1201 &decoded_client_data,
1202 public_key_jwk,
1203 )?;
1204
1205 tracing::info!("Advanced passkey verification completed successfully");
1206
1207 Ok(AdvancedVerificationResult {
1208 user_present,
1209 user_verified,
1210 new_counter,
1211 signature_valid: true,
1212 attestation_valid: true,
1213 })
1214 }
1215
1216 fn verify_webauthn_signature(
1218 &self,
1219 signed_data: &[u8],
1220 signature_bytes: &[u8],
1221 public_key_jwk: &serde_json::Value,
1222 ) -> Result<()> {
1223 use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
1224 use ring::signature;
1225
1226 let key_type = public_key_jwk
1227 .get("kty")
1228 .and_then(|v| v.as_str())
1229 .ok_or_else(|| AuthError::validation("Missing key type in JWK"))?;
1230
1231 let algorithm = public_key_jwk
1232 .get("alg")
1233 .and_then(|v| v.as_str())
1234 .ok_or_else(|| AuthError::validation("Missing algorithm in JWK"))?;
1235
1236 match key_type {
1237 "RSA" => {
1238 let n = public_key_jwk
1240 .get("n")
1241 .and_then(|v| v.as_str())
1242 .ok_or_else(|| AuthError::validation("Missing 'n' in RSA JWK"))?;
1243 let e = public_key_jwk
1244 .get("e")
1245 .and_then(|v| v.as_str())
1246 .ok_or_else(|| AuthError::validation("Missing 'e' in RSA JWK"))?;
1247
1248 let n_bytes = URL_SAFE_NO_PAD
1249 .decode(n.as_bytes())
1250 .map_err(|_| AuthError::validation("Invalid 'n' base64"))?;
1251 let e_bytes = URL_SAFE_NO_PAD
1252 .decode(e.as_bytes())
1253 .map_err(|_| AuthError::validation("Invalid 'e' base64"))?;
1254
1255 let n_ref: &[u8] = &n_bytes;
1259 let e_ref: &[u8] = &e_bytes;
1260 let rsa_key = signature::RsaPublicKeyComponents { n: n_ref, e: e_ref };
1261
1262 match algorithm {
1263 "RS256" => rsa_key.verify(
1264 &signature::RSA_PKCS1_2048_8192_SHA256,
1265 signed_data,
1266 signature_bytes,
1267 ),
1268 "RS384" => rsa_key.verify(
1269 &signature::RSA_PKCS1_2048_8192_SHA384,
1270 signed_data,
1271 signature_bytes,
1272 ),
1273 "RS512" => rsa_key.verify(
1274 &signature::RSA_PKCS1_2048_8192_SHA512,
1275 signed_data,
1276 signature_bytes,
1277 ),
1278 _ => return Err(AuthError::validation("Unsupported RSA algorithm")),
1279 }
1280 .map_err(|_| AuthError::validation("RSA signature verification failed"))?;
1281 }
1282 "EC" => {
1283 let curve = public_key_jwk
1285 .get("crv")
1286 .and_then(|v| v.as_str())
1287 .ok_or_else(|| AuthError::validation("Missing curve in EC JWK"))?;
1288 let x = public_key_jwk
1289 .get("x")
1290 .and_then(|v| v.as_str())
1291 .ok_or_else(|| AuthError::validation("Missing 'x' in EC JWK"))?;
1292 let y = public_key_jwk
1293 .get("y")
1294 .and_then(|v| v.as_str())
1295 .ok_or_else(|| AuthError::validation("Missing 'y' in EC JWK"))?;
1296
1297 let x_bytes = URL_SAFE_NO_PAD
1298 .decode(x.as_bytes())
1299 .map_err(|_| AuthError::validation("Invalid 'x' base64"))?;
1300 let y_bytes = URL_SAFE_NO_PAD
1301 .decode(y.as_bytes())
1302 .map_err(|_| AuthError::validation("Invalid 'y' base64"))?;
1303
1304 let (verification_algorithm, expected_coord_len) = match (curve, algorithm) {
1305 ("P-256", "ES256") => (&signature::ECDSA_P256_SHA256_ASN1, 32),
1306 ("P-384", "ES384") => (&signature::ECDSA_P384_SHA384_ASN1, 48),
1307 _ => return Err(AuthError::validation("Unsupported EC curve/algorithm")),
1308 };
1309
1310 if x_bytes.len() != expected_coord_len || y_bytes.len() != expected_coord_len {
1311 return Err(AuthError::validation("Invalid coordinate length"));
1312 }
1313
1314 let mut public_key_bytes = Vec::with_capacity(1 + expected_coord_len * 2);
1316 public_key_bytes.push(0x04); public_key_bytes.extend_from_slice(&x_bytes);
1318 public_key_bytes.extend_from_slice(&y_bytes);
1319
1320 let public_key =
1321 signature::UnparsedPublicKey::new(verification_algorithm, &public_key_bytes);
1322
1323 public_key
1324 .verify(signed_data, signature_bytes)
1325 .map_err(|_| AuthError::validation("ECDSA signature verification failed"))?;
1326 }
1327 _ => return Err(AuthError::validation("Unsupported key type for WebAuthn")),
1328 }
1329
1330 Ok(())
1331 }
1332
1333 pub async fn cross_platform_verification(
1335 &self,
1336 assertion_response: &str,
1337 authenticator_types: &[AuthenticatorType],
1338 ) -> Result<CrossPlatformVerificationResult> {
1339 tracing::info!("Starting cross-platform passkey verification");
1340
1341 let assertion: serde_json::Value = serde_json::from_str(assertion_response)
1343 .map_err(|_| AuthError::validation("Invalid assertion response"))?;
1344
1345 let authenticator_data = assertion
1347 .get("response")
1348 .and_then(|r| r.get("authenticatorData"))
1349 .and_then(|a| a.as_str())
1350 .ok_or_else(|| AuthError::validation("Missing authenticatorData"))?;
1351
1352 let auth_data_bytes = URL_SAFE_NO_PAD
1353 .decode(authenticator_data)
1354 .map_err(|_| AuthError::validation("Invalid authenticatorData"))?;
1355
1356 let aaguid = if auth_data_bytes.len() >= 53 && (auth_data_bytes[32] & 0x40) != 0 {
1358 Some(&auth_data_bytes[37..53])
1359 } else {
1360 None
1361 };
1362
1363 let detected_type = self.detect_authenticator_type(aaguid)?;
1365
1366 if !authenticator_types.contains(&detected_type) {
1368 return Err(AuthError::validation("Authenticator type not allowed"));
1369 }
1370
1371 let type_specific_result = match detected_type {
1373 AuthenticatorType::Platform => {
1374 tracing::debug!("Performing platform authenticator validation");
1375 self.validate_platform_authenticator(&assertion).await?
1376 }
1377 AuthenticatorType::CrossPlatform => {
1378 tracing::debug!("Performing cross-platform authenticator validation");
1379 self.validate_cross_platform_authenticator(&assertion)
1380 .await?
1381 }
1382 AuthenticatorType::SecurityKey => {
1383 tracing::debug!("Performing security key validation");
1384 self.validate_security_key(&assertion).await?
1385 }
1386 };
1387
1388 tracing::info!("Cross-platform verification completed successfully");
1389
1390 Ok(CrossPlatformVerificationResult {
1391 authenticator_type: detected_type,
1392 validation_result: type_specific_result,
1393 aaguid: aaguid.map(|a| a.to_vec()),
1394 })
1395 }
1396
1397 fn detect_authenticator_type(&self, aaguid: Option<&[u8]>) -> Result<AuthenticatorType> {
1399 match aaguid {
1400 Some(guid) if guid == [0u8; 16] => {
1401 Ok(AuthenticatorType::SecurityKey)
1403 }
1404 Some(guid) => {
1405 match guid {
1407 [
1409 0xf8,
1410 0xa0,
1411 0x11,
1412 0xf3,
1413 0x8c,
1414 0x0a,
1415 0x4d,
1416 0x15,
1417 0x80,
1418 0x06,
1419 0x17,
1420 0x11,
1421 0x1f,
1422 0x9e,
1423 0xdc,
1424 0x7d,
1425 ] => Ok(AuthenticatorType::SecurityKey),
1426 [
1428 0x08,
1429 0x98,
1430 0x7d,
1431 0x78,
1432 0x23,
1433 0x88,
1434 0x4d,
1435 0xa9,
1436 0xa6,
1437 0x91,
1438 0xb6,
1439 0xe1,
1440 0x04,
1441 0x5e,
1442 0xd4,
1443 0xd4,
1444 ] => Ok(AuthenticatorType::Platform),
1445 [
1447 0x08,
1448 0x98,
1449 0x7d,
1450 0x78,
1451 0x4e,
1452 0xd4,
1453 0x4d,
1454 0x49,
1455 0xa6,
1456 0x91,
1457 0xb6,
1458 0xe1,
1459 0x04,
1460 0x5e,
1461 0xd4,
1462 0xd4,
1463 ] => Ok(AuthenticatorType::Platform),
1464 _ => {
1465 Ok(AuthenticatorType::CrossPlatform)
1467 }
1468 }
1469 }
1470 None => {
1471 Ok(AuthenticatorType::SecurityKey)
1473 }
1474 }
1475 }
1476
1477 async fn validate_platform_authenticator(
1479 &self,
1480 assertion: &serde_json::Value,
1481 ) -> Result<TypeSpecificValidationResult> {
1482 tracing::debug!("Validating platform authenticator");
1483
1484 let authenticator_data = assertion
1486 .get("response")
1487 .and_then(|r| r.get("authenticatorData"))
1488 .and_then(|a| a.as_str())
1489 .ok_or_else(|| AuthError::validation("Missing authenticatorData"))?;
1490
1491 let auth_data_bytes = URL_SAFE_NO_PAD
1492 .decode(authenticator_data)
1493 .map_err(|_| AuthError::validation("Invalid authenticatorData"))?;
1494
1495 if auth_data_bytes.len() < 33 {
1496 return Err(AuthError::validation("AuthenticatorData too short"));
1497 }
1498
1499 let flags = auth_data_bytes[32];
1500 let user_verified = (flags & 0x04) != 0;
1501
1502 if !user_verified && self.config.user_verification == "required" {
1503 return Err(AuthError::validation(
1504 "User verification required for platform authenticator",
1505 ));
1506 }
1507
1508 Ok(TypeSpecificValidationResult {
1509 user_verified,
1510 attestation_valid: true,
1511 additional_properties: vec![
1512 ("authenticator_class".to_string(), "platform".to_string()),
1513 ("biometric_capable".to_string(), "true".to_string()),
1514 ],
1515 })
1516 }
1517
1518 async fn validate_cross_platform_authenticator(
1520 &self,
1521 _assertion: &serde_json::Value,
1522 ) -> Result<TypeSpecificValidationResult> {
1523 tracing::debug!("Validating cross-platform authenticator");
1524
1525 Ok(TypeSpecificValidationResult {
1527 user_verified: true,
1528 attestation_valid: true,
1529 additional_properties: vec![
1530 (
1531 "authenticator_class".to_string(),
1532 "cross_platform".to_string(),
1533 ),
1534 ("roaming_capable".to_string(), "true".to_string()),
1535 ],
1536 })
1537 }
1538
1539 async fn validate_security_key(
1541 &self,
1542 assertion: &serde_json::Value,
1543 ) -> Result<TypeSpecificValidationResult> {
1544 tracing::debug!("Validating security key");
1545
1546 let authenticator_data = assertion
1548 .get("response")
1549 .and_then(|r| r.get("authenticatorData"))
1550 .and_then(|a| a.as_str())
1551 .ok_or_else(|| AuthError::validation("Missing authenticatorData"))?;
1552
1553 let auth_data_bytes = URL_SAFE_NO_PAD
1554 .decode(authenticator_data)
1555 .map_err(|_| AuthError::validation("Invalid authenticatorData"))?;
1556
1557 if auth_data_bytes.len() < 33 {
1558 return Err(AuthError::validation("AuthenticatorData too short"));
1559 }
1560
1561 let flags = auth_data_bytes[32];
1562 let user_present = (flags & 0x01) != 0;
1563 let user_verified = (flags & 0x04) != 0;
1564
1565 if !user_present {
1566 return Err(AuthError::validation(
1567 "User presence required for security key",
1568 ));
1569 }
1570
1571 Ok(TypeSpecificValidationResult {
1572 user_verified,
1573 attestation_valid: true,
1574 additional_properties: vec![
1575 (
1576 "authenticator_class".to_string(),
1577 "security_key".to_string(),
1578 ),
1579 ("user_presence".to_string(), user_present.to_string()),
1580 ("hardware_backed".to_string(), "true".to_string()),
1581 ],
1582 })
1583 }
1584
1585 fn verify_assertion_signature(
1588 &self,
1589 assertion_response: &str,
1590 auth_data_bytes: &[u8],
1591 decoded_client_data: &[u8],
1592 public_key_jwk: &serde_json::Value,
1593 ) -> Result<()> {
1594 use ring::digest;
1595
1596 tracing::debug!("Verifying assertion signature");
1598
1599 let assertion: serde_json::Value = serde_json::from_str(assertion_response)
1601 .map_err(|_| AuthError::validation("Invalid assertion response format"))?;
1602
1603 let signature = assertion
1605 .get("response")
1606 .and_then(|r| r.get("signature"))
1607 .ok_or_else(|| AuthError::validation("Missing signature in assertion response"))?;
1608
1609 let signature_bytes = json_bytes(signature)
1610 .ok_or_else(|| AuthError::validation("Invalid signature encoding"))?;
1611
1612 let client_data_hash = {
1614 let mut context = digest::Context::new(&digest::SHA256);
1615 context.update(decoded_client_data);
1616 context.finish()
1617 };
1618
1619 let mut signed_data = Vec::new();
1620 signed_data.extend_from_slice(auth_data_bytes);
1621 signed_data.extend_from_slice(client_data_hash.as_ref());
1622
1623 self.verify_webauthn_signature(&signed_data, &signature_bytes, public_key_jwk)?;
1625
1626 Ok(())
1627 }
1628
1629 fn extract_counter_from_assertion(&self, assertion_response: &str) -> Result<u32> {
1631 tracing::debug!("Extracting counter from assertion response");
1633
1634 let assertion: serde_json::Value = serde_json::from_str(assertion_response)
1636 .map_err(|_| AuthError::validation("Invalid assertion response format"))?;
1637
1638 let authenticator_data = assertion
1639 .get("response")
1640 .and_then(|r| r.get("authenticatorData"))
1641 .ok_or_else(|| {
1642 AuthError::validation("Missing authenticatorData in assertion response")
1643 })?;
1644
1645 let auth_data_bytes = json_bytes(authenticator_data).ok_or_else(|| {
1646 AuthError::validation("authenticatorData is neither base64url nor a byte array")
1647 })?;
1648
1649 if auth_data_bytes.len() < 37 {
1652 return Err(AuthError::validation(
1653 "authenticatorData is too short to contain a counter",
1654 ));
1655 }
1656
1657 let counter_bytes: [u8; 4] = [
1659 auth_data_bytes[33],
1660 auth_data_bytes[34],
1661 auth_data_bytes[35],
1662 auth_data_bytes[36],
1663 ];
1664
1665 let counter = u32::from_be_bytes(counter_bytes);
1666 tracing::debug!("Extracted signature counter: {}", counter);
1667 Ok(counter)
1668 }
1669}
1670
1671#[derive(Debug, Clone, Serialize, Deserialize)]
1673pub struct AdvancedVerificationResult {
1674 pub user_present: bool,
1675 pub user_verified: bool,
1676 pub new_counter: u32,
1677 pub signature_valid: bool,
1678 pub attestation_valid: bool,
1679}
1680
1681#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1683pub enum AuthenticatorType {
1684 Platform,
1686 CrossPlatform,
1688 SecurityKey,
1690}
1691
1692#[derive(Debug, Clone, Serialize, Deserialize)]
1694pub struct CrossPlatformVerificationResult {
1695 pub authenticator_type: AuthenticatorType,
1696 pub validation_result: TypeSpecificValidationResult,
1697 pub aaguid: Option<Vec<u8>>,
1698}
1699
1700#[derive(Debug, Clone, Serialize, Deserialize)]
1702pub struct TypeSpecificValidationResult {
1703 pub user_verified: bool,
1704 pub attestation_valid: bool,
1705 pub additional_properties: Vec<(String, String)>,
1706}
1707
1708#[cfg(test)]
1709mod tests {
1710 use super::*;
1711 use crate::tokens::TokenManager;
1712
1713 #[tokio::test]
1714 async fn test_passkey_config_validation() {
1715 let token_manager = TokenManager::new_hmac(b"test-secret", "test-issuer", "test-audience");
1716
1717 let config = PasskeyConfig {
1718 rp_id: "example.com".to_string(),
1719 rp_name: "Test App".to_string(),
1720 origin: "https://example.com".to_string(),
1721 timeout_ms: 60000,
1722 user_verification: "preferred".to_string(),
1723 authenticator_attachment: None,
1724 require_resident_key: false,
1725 ..Default::default()
1726 };
1727
1728 let result = PasskeyAuthMethod::new(config, token_manager);
1729
1730 #[cfg(feature = "passkeys")]
1731 {
1732 assert!(result.is_ok());
1733 let method = result.unwrap();
1734 assert!(method.validate_config().is_ok());
1735 }
1736
1737 #[cfg(not(feature = "passkeys"))]
1738 {
1739 assert!(result.is_err());
1740 }
1741 }
1742
1743 #[tokio::test]
1744 async fn test_invalid_passkey_config() {
1745 #[cfg_attr(not(feature = "passkeys"), allow(unused_variables))]
1746 let token_manager = TokenManager::new_hmac(b"test-secret", "test-issuer", "test-audience");
1747
1748 #[cfg_attr(not(feature = "passkeys"), allow(unused_variables))]
1749 let config = PasskeyConfig {
1750 rp_id: "".to_string(), rp_name: "Test App".to_string(),
1752 origin: "https://example.com".to_string(),
1753 timeout_ms: 60000,
1754 user_verification: "invalid".to_string(), authenticator_attachment: None,
1756 require_resident_key: false,
1757 ..Default::default()
1758 };
1759
1760 #[cfg(feature = "passkeys")]
1761 {
1762 let result = PasskeyAuthMethod::new(config, token_manager);
1763 if let Ok(method) = result {
1764 assert!(method.validate_config().is_err());
1765 }
1766 }
1767 }
1768}