package auth import ( "strings" "testing" "time" "aidanwoods.dev/go-paseto" ) const ( testUserID = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" testDeviceID = "0123456789abcdef0123456789abcdef" ) func TestIssueVerifyRoundtrip(t *testing.T) { m, err := NewManager("test-secret") if err != nil { t.Fatalf("NewManager: %v", err) } signed, err := m.Issue(testUserID, testDeviceID) if err != nil { t.Fatalf("Issue: %v", err) } got, err := m.Verify(signed) if err != nil { t.Fatalf("Verify: %v", err) } if got.UserID != testUserID { t.Errorf("Verify.UserID = %q, want %q", got.UserID, testUserID) } if got.DeviceID != testDeviceID { t.Errorf("Verify.DeviceID = %q, want %q", got.DeviceID, testDeviceID) } } func TestIssueIsUserSubject(t *testing.T) { m, _ := NewManager("test-secret") signed, err := m.Issue(testUserID, testDeviceID) if err != nil { t.Fatalf("Issue: %v", err) } parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil) if err != nil { t.Fatalf("parse: %v", err) } if subject, _ := parsed.GetSubject(); subject != testUserID { t.Errorf("subject = %q, want user %q", subject, testUserID) } } func TestVerifyRejectsTamperedToken(t *testing.T) { m, _ := NewManager("test-secret") signed, _ := m.Issue(testUserID, testDeviceID) parts := strings.Split(signed, ".") parts[len(parts)-1] = "nope" tampered := strings.Join(parts, ".") if _, err := m.Verify(tampered); err == nil { t.Fatal("expected tampered token to be rejected") } } func TestVerifyRejectsGarbage(t *testing.T) { m, _ := NewManager("test-secret") if _, err := m.Verify("not-a-token"); err == nil { t.Fatal("expected garbage to be rejected") } } func TestDifferentSecretRejectsToken(t *testing.T) { a, _ := NewManager("secret-a") b, _ := NewManager("secret-b") signed, _ := a.Issue(testUserID, testDeviceID) if _, err := b.Verify(signed); err == nil { t.Fatal("expected token from another manager to be rejected") } } func TestVerifyRequiresDeviceClaim(t *testing.T) { m, _ := NewManager("test-secret") // Token sans claim device_id (subject seul, type de l'ancien format) → invalide. now := time.Now() token := paseto.NewToken() token.SetIssuedAt(now) token.SetNotBefore(now) token.SetExpiration(now.Add(TokenTTL)) token.SetSubject(testUserID) signed := token.V4Encrypt(m.key, nil) if _, err := m.Verify(signed); err == nil { t.Fatal("expected token without device claim to be rejected") } } func TestVerifyRejectsNonHex32IDs(t *testing.T) { m, _ := NewManager("test-secret") issueWith := func(userID, deviceID string) string { token := paseto.NewToken() now := time.Now() token.SetIssuedAt(now) token.SetNotBefore(now) token.SetExpiration(now.Add(TokenTTL)) token.SetSubject(userID) token.SetString("device_id", deviceID) return token.V4Encrypt(m.key, nil) } cases := map[string][2]string{ "subject vide": {"", testDeviceID}, "subject non-hex": {"not-hex-at-all-!!!!!!!!!!!!!!!!", testDeviceID}, "subject majuscules": {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", testDeviceID}, "subject trop court": {"abc123", testDeviceID}, "device vide": {testUserID, ""}, "device non-hex": {testUserID, "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"}, "device majuscules": {testUserID, "0123456789ABCDEF0123456789ABCDEF"}, "device trop long": {testUserID, testDeviceID + "00"}, "device avec tirets": {testUserID, "01234567-89ab-cdef-0123-456789abcdef"}, } for name, ids := range cases { signed := issueWith(ids[0], ids[1]) if _, err := m.Verify(signed); err == nil { t.Errorf("%s: token accepté (user=%q device=%q), attendu rejet", name, ids[0], ids[1]) } } // Sanity : les IDs 32-hex valides passent toujours. if _, err := m.Verify(issueWith(testUserID, testDeviceID)); err != nil { t.Errorf("IDs valides rejetés: %v", err) } } func TestIssueSetsExpiration(t *testing.T) { m, _ := NewManager("test-secret") before := time.Now() signed, err := m.Issue(testUserID, testDeviceID) if err != nil { t.Fatalf("Issue: %v", err) } parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil) if err != nil { t.Fatalf("parse: %v", err) } exp, err := parsed.GetExpiration() if err != nil { t.Fatalf("GetExpiration: %v", err) } // Le TTL est fixé à 7 jours (docs/api-v1.md) — marge de 1 min par sécurité. lower := before.Add(TokenTTL - time.Minute) upper := before.Add(TokenTTL + time.Minute) if exp.Before(lower) || exp.After(upper) { t.Errorf("expiration = %v, attendu ≈ now+%v (fenêtre [%v, %v])", exp, TokenTTL, lower, upper) } } func TestIssueWithExpiryMatchesTokenExp(t *testing.T) { m, _ := NewManager("test-secret") signed, expiresAt, err := m.IssueWithExpiry(testUserID, testDeviceID, 3) if err != nil { t.Fatalf("IssueWithExpiry: %v", err) } parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil) if err != nil { t.Fatalf("parse: %v", err) } exp, err := parsed.GetExpiration() if err != nil { t.Fatalf("GetExpiration: %v", err) } // L'expiresAt retourné doit être le exp embarqué (pas un Now()+TTL // recalculé — cf. FEEDBACK A7). Comparaison à la seconde : le token // sérialise sans lecture monotonique ni sous-seconde. if exp.Unix() != expiresAt.Unix() { t.Errorf("expiresAt = %v, exp token = %v", expiresAt, exp) } id, err := m.Verify(signed) if err != nil { t.Fatalf("Verify: %v", err) } if id.TokenVersion != 3 { t.Errorf("tv = %d, attendu 3", id.TokenVersion) } } func TestVerifyLegacyTokenWithoutTv(t *testing.T) { m, _ := NewManager("test-secret") // Tokens pré-V3 (Issue, tv=0) : Verify lit 0 — valides tant que le // compte n'a jamais bumpé (montée en version sans coupure). signed, err := m.Issue(testUserID, testDeviceID) if err != nil { t.Fatalf("Issue: %v", err) } id, err := m.Verify(signed) if err != nil { t.Fatalf("Verify legacy: %v", err) } if id.TokenVersion != 0 { t.Errorf("tv legacy = %d, attendu 0", id.TokenVersion) } }