Weryfikator podpisu JWT
Weryfikuj podpis JWT tokenu: HS256 (HMAC) i RS256 (RSA). Sprawdź claims, exp i iss. Bezpiecznie w przeglądarce. Bezpłatnie.
-
1Wprowadź dane
Wpisz treść, wklej tekst lub załaduj plik z dysku. -
2Kliknij przycisk
Narzędzie natychmiast przetworzy Twoje dane w przeglądarce. -
3Pobierz wynik
Skopiuj gotowy tekst lub zapisz plik na urządzeniu.
return "Wynik gotowy w 0.1s";
}
Algorytm
pobrany z pola alg nagłówka tokenu
Weryfikacja podpisu
porównanie timing-safe (hash_equals / openssl_verify)
Ważność czasowa
claimy exp/nbf z tolerancją skew
Ładunek
liczba pól JSON w payload
Weryfikator podpisu JWT
========================
Algorytm: HS256 (z nagłówka)
Podpis: WAŻNY — hash_hmac(sha256) + hash_equals — porównanie timing-safe.
Ważność czasowa: Ważny czasowo — exp: 2030-03-17 17:46:40, zapas ≈ 1244 dni
Nagłówek:
{
"alg": "HS256",
"typ": "JWT"
}
Ładunek (5 pól):
{
"sub": "1234567890",
"name": "Pat Doe",
"admin": false,
"iat": 1700000000,
"exp": 1900000000
}
| Algorytm | Charakterystyka | Wsparcie w tym narzędziu |
|---|---|---|
| HS256 | HMAC z SHA-256 — symetryczny sekret (ten sam do podpisu i weryfikacji) | Tak — hash_hmac(sha256) + hash_equals (porównanie timing-safe) |
| HS384 | HMAC z SHA-384 — symetryczny sekret | Tak — hash_hmac(sha384) + hash_equals |
| HS512 | HMAC z SHA-512 — symetryczny sekret | Tak — hash_hmac(sha512) + hash_equals |
| RS256 | RSA z SHA-256 — asymetryczny (weryfikacja kluczem publicznym PEM) | Tak — openssl_verify z kluczem publicznym |
| RS384 | RSA z SHA-384 — asymetryczny | Tak — openssl_verify z kluczem publicznym |
| RS512 | RSA z SHA-512 — asymetryczny | Tak — openssl_verify z kluczem publicznym |
| ES256 / ES384 / ES512 | ECDSA na krzywych eliptycznych | NIE w tym narzędziu — uczciwie zwracamy informację o braku wsparcia zamiast wyniku „na oko” |
| none (z nagłówka przy „Auto”) | Token bez podpisu — trzecia część pusta | ZAWSZE odrzucony — pułapka alg „none”, znasz ją z ataków na biblioteki JWT z 2015 r. |
| Auto | Algorytm pobierany z pola alg nagłówka tokenu | Tryb ścisły pilnuje zgodności alg z nagłówka z wyborem; zwykły tryb tylko ostrzega |
| Scenariusz | Wynik weryfikacji | Notatka silnika |
|---|---|---|
| Poprawny sekret | PODPIS WAŻNY — Ważny czasowo | hash_hmac(sha256) + hash_equals — porównanie timing-safe. |
| Zły sekret (ta sama struktura tokenu) | PODPIS NIEPOPRAWNY — Ważny czasowo | obliczony hash_hmac(sha256) nie zgadza się z podpisem tokenu (hash_equals — porównanie timing-safe). |
| Token alg „none” (bez podpisu) — nawet z poprawnym sekretem | PODPIS NIEPOPRAWNY — Ważny czasowo | Token używa alg „none” (bez podpisu). Weryfikacja nieudana — takiego tokenu nigdy nie należy akceptować. |
Warto wiedzieć — weryfikacja podpisu JWT
Sekret HS* a klucz RS*
HS256/384/512 są symetryczne: ten sam sekret podpisuje i weryfikuje, więc każdy, kto go zna, może podrobić token — sekret zostawaj w backendzie. RS256/384/512 są asymetryczne: podpisujesz kluczem prywatnym, weryfikujesz publicznym (PEM), więc klucz do weryfikacji można nawet publikować.
Nie wklejaj sekretów produkcyjnych
Weryfikacja liczy się na serwerze narzędzia, a token i klucz trafiają do formularza — używaj wyłącznie sekretów testowych i tokenów diagnostycznych (jak „demo-secret-please-change”). Nigdy sekretów z produkcji ani tokenów sesyjnych prawdziwych użytkowników.
Pułapki alg „none” i alg confusion
Token z alg „none” nie ma podpisu — akceptowanie takich tokenów zniszczyło wiele bibliotek w 2015 r. Tu „none” jest zawsze odrzucone, nawet gdy podasz poprawny sekret. Druga pułapka to mylenie rodzin algorytmów (np. RS256 podpisany, weryfikowany jak HS256) — tryb ścisły przerywa weryfikację przy niezgodności alg nagłówka z wyborem.
Czas: exp, nbf, skew
Podpis potwierdza autentyczność, ale nie świeżość — o tym mówią claimy exp (wygaśnięcie) i nbf (nie wcześniej niż). Zegary serwerów potrafią się różnić o sekundy–minuty, więc tolerancję ustawia parametr skew (0–600 s). Token bez exp nigdy nie wygasa — zawsze ustawiaj krótki czas życia i odnawiaj przez refresh token.
Oceń to narzędzie:
Powiązane narzędzia
Inne narzędzia, które mogą Ci się przydaćWeryfikator podpisu JWT – weryfikacja HMAC i RSA w przeglądarce
Weryfikacja podpisu JWT to kluczowy krok bezpieczeństwa. Narzędzie weryfikuje podpis tokenu JWT dla algorytmów HS256 (HMAC-SHA256) i RS256 (RSA-SHA256) bezpośrednio w przeglądarce – bez wysyłania tokenu na zewnętrzny serwer, co jest bezpieczne dla produkcyjnych tokenów.
Jak działa weryfikacja JWT
JWT = header.payload.signature. Header + payload: base64url encoded. Signature: HMAC-SHA256(base64url(header) + "." + base64url(payload), secret) dla HS256. Weryfikacja: oblicz podpis lokalne → porównaj z podpisem w tokenie. Wynik: valid (podpisy zgodne) lub invalid (zmieniony token lub błędny klucz).
Algorytmy podpisu JWT
HS256 (HMAC-SHA256): symetryczny klucz sekretny. Serwer podpisuje i weryfikuje tym samym kluczem. Prosty, ale klucz musi być chroniony. RS256 (RSA-SHA256): asymetryczny. Private key podpisuje, public key weryfikuje. Bezpieczniejszy w distributed systems. ES256 (ECDSA-SHA256): eliptyczna krzywa, mniejsze klucze. Unikaj "none" (brak podpisu – podatność!).
Weryfikacja RS256 – Public Key
RS256: potrzebujesz public key do weryfikacji. Format: PEM (-----BEGIN PUBLIC KEY-----). JWKS: JSON Web Key Set (endpoint serwera z public keys). Automatyczne pobieranie: well-known/jwks.json. Narzędzie: wklej public key PEM lub JWKS URL. Weryfikacja: Web Crypto API (SubtleCrypto.verify()) – natywna, bezpieczna w przeglądarce.
Claims do sprawdzenia
exp (expiration): czy token nie wygasł. iat (issued at): czy token nie jest z przyszłości. nbf (not before): czy jest już ważny. iss (issuer): czy od oczekiwanego serwera. aud (audience): czy dla Twojej aplikacji. sub (subject): identyfikator użytkownika. jti (JWT ID): czy token nie jest na blackliście.
Mechanika weryfikacji: co dokładnie liczy przeglądarka
Podpis JWT nie szyfruje treści – to skrót kryptograficzny, który dowodzi, że nagłówek i ładunek nie zostały zmienione po wystawieniu tokenu. Przeglądarka składa tak zwany signing input: dokładnie te same dwa pierwsze segmenty tokenu, sklejone kropką, potraktowane jako znaki ASCII. Następnie liczy skrót SHA-256 z tego napisu i wiąże go z kluczem – w HS256 przez HMAC, w RS256 przez operację na kluczu RSA z dopełnieniem PKCS#1 v1.5. Dopiero tak powstała wartość jest porównywana z trzecim segmentem tokenu.
W HS256 klucz jest jeden: ten sam sekret podpisuje i weryfikuje. HMAC-SHA256 zwraca zawsze 32 bajty, które w base64url – bez znaków wyrównania – dają 43 znaki. W RS256 długość podpisu wynika z długości modułu klucza: klucz 2048-bitowy daje 256 bajtów, czyli 342 znaki base64url, a 4096-bitowy 512 bajtów, czyli 683 znaki. Już po samej długości trzeciego segmentu można więc wstępnie ocenić, z jakim algorytmem i jaką długością klucza mamy do czynienia, choć sama długość nie jest dowodem poprawności.
Porównanie podpisów musi być odporne na pomiar czasu, dlatego bajty zestawia się w stałym czasie – z liczby wykonanych operacji nie da się wywnioskować, po ilu znakach porównanie się rozjechało. Dla RS256 narzędzie korzysta z Web Crypto API: SubtleCrypto.verify() sprawdza matematycznie, czy podpis mógł powstać z klucza prywatnego odpowiadającego wklejonemu kluczowi publicznemu. Wynik valid oznacza wyłącznie zgodność podpisu z kluczem – nie mówi nic o tym, czy token nie wygasł ani czy wystawił go właściwy serwis.
Przykład: weryfikacja tokenu HS256 krok po kroku
- Bierzemy token HS256 zbudowany z trzech segmentów rozdzielonych kropkami. Pierwszy segment to eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9, drugi to zakodowany ładunek, trzeci to podpis.
- Dekodujemy base64url pierwszego segmentu i otrzymujemy {"alg":"HS256","typ":"JWT"}. Sprawdzamy, że algorytm to HS256 – a nie none ani RS256. To pierwszy punkt kontrolny, bo pole alg pochodzi z tokenu, a nie z konfiguracji aplikacji.
- Sklejamy signing input: pierwszy segment + kropka + drugi segment, znak w znak. Nie dopisujemy znaków wyrównania, nie zmieniamy wielkości liter, nie dodajemy spacji ani końcowego znaku nowej linii.
- Pobieramy sekret, którym token podpisano, i traktujemy go jako ciąg bajtów w UTF-8. Liczymy HMAC-SHA256 z sekretu i signing input – wynikiem jest 32 bajty.
- Kodujemy te 32 bajty w base64url. Powstaje 43 znaki – dokładnie taki ciąg powinien znajdować się w trzecim segmencie tokenu.
- Porównujemy oczekiwane 43 znaki z tym, co jest w tokenie. Identyczny ciąg daje wynik valid, różnica choćby jednego znaku to invalid. Na koniec narzędzie odczytuje pole exp i pokazuje, czy token nie wygasł.
Rozmiary podpisów i klucze dla typowych algorytmów
| Algorytm | Klucz potrzebny do weryfikacji | Rozmiar trzeciego segmentu |
|---|---|---|
| HS256 | sekret HMAC – ten sam, którym podpisano token | 32 bajty, czyli 43 znaki base64url |
| HS384 | sekret HMAC – ten sam, którym podpisano token | 48 bajtów, czyli 64 znaki base64url |
| HS512 | sekret HMAC – ten sam, którym podpisano token | 64 bajty, czyli 86 znaków base64url |
| RS256, klucz 2048-bit | klucz publiczny RSA w formacie PEM lub z JWKS | 256 bajtów, czyli 342 znaki base64url |
| RS256, klucz 4096-bit | klucz publiczny RSA w formacie PEM lub z JWKS | 512 bajtów, czyli 683 znaki base64url |
| ES256 | klucz publiczny krzywej eliptycznej P-256 | 64 bajty, czyli 86 znaków base64url |
| none | klucz nie jest potrzebny | trzeci segment jest pusty – podpisu nie ma |
Jak używać weryfikatora bez wpadek
- Wymuszaj algorytm po stronie serwera – pole alg z nagłówka tokenu to dane wejściowe od potencjalnego atakującego. Weryfikator pokazuje, jaki algorytm faktycznie zadeklarowano, ale to Twoja aplikacja musi odrzucać wszystko poza oczekiwanym HS256 lub RS256.
- Zadbaj o entropię sekretu w HS256 – HMAC nie naprawi słabego klucza. Krótki, słownikowy sekret można złamać metodą siłową offline, bo atakujący ma cały token i może zgadywać w nieskończoność.
- Do RS256 wklejaj wyłącznie klucz publiczny – fragment zaczynający się od nagłówka klucza publicznego. Klucza prywatnego nie ma po co wklejać do przeglądarki, a JWKS pobieraj tylko z zaufanego adresu po HTTPS.
- Sprawdź claims osobno – poprawny podpis nie znaczy, że token jest aktualny. Po wyniku valid przejrzyj exp, nbf, iss i aud, bo to one decydują o przyjęciu tokenu.
- Zrób test negatywny – zmień jeden znak w drugim segmencie i sprawdź, czy narzędzie zwraca invalid. To najszybszy sposób potwierdzenia, że porównujesz właściwy podpis z właściwym kluczem.
Czego weryfikator nie sprawdzi
- Algorytmów spoza HS256 i RS256 – token podpisany jako ES256, PS256 czy HS512 zostanie rozpoznany po nagłówku, ale weryfikacji podpisu nie wykonasz. Tabela rozmiarów podpisów ma charakter referencyjny, nie jest listą obsługiwanych metod.
- Twojej polityki ważności tokenu – narzędzie odczyta exp, ale nie wie, jakiego wystawcy (iss) i odbiorcy (aud) oczekujesz ani czy dany identyfikator tokenu (jti) nie trafił na blacklistę.
- Rotacji kluczy i łańcucha certyfikatów – przy JWKS zawierającym wiele kluczy trzeba samodzielnie wskazać ten zgodny z polem kid z nagłówka; weryfikator nie przeszuka wszystkich ani nie sprawdzi daty ważności certyfikatu.
- Bezpieczeństwa środowiska lokalnego – obliczenia odbywają się w przeglądarce, więc wklejony klucz pozostaje w pamięci karty do jej zamknięcia. Na komputerze współdzielonym lub z niezaufanym rozszerzeniem wynik może być obserwowany.
Najczęstsze pytania
Jak bezpiecznie weryfikować JWT w Node.js?
npm install jsonwebtoken. const jwt = require("jsonwebtoken"). jwt.verify(token, secret, (err, decoded) => { if(err) throw err; console.log(decoded); }). Opcje: algorithms: ["HS256"] (whitelista, zapobiega alg confusion). audience: "myapp". issuer: "https://auth.example.com". clockTolerance: 30 (sekundy).
Jak weryfikować JWT z JWKS (RS256)?
npm install jwks-rsa jsonwebtoken. const jwksClient = require("jwks-rsa"); const client = jwksClient({ jwksUri: "https://auth.example.com/.well-known/jwks.json" }). Pobierz public key przez kid (key ID) z header tokenu. Weryfikuj przez jwt.verify(token, key.publicKey). Caching JWKS: jwks-rsa robi to automatycznie.
Najczęstsze błędy weryfikacji JWT?
Algorithm confusion: serwer akceptuje "none" lub RS256 zamieniony na HS256 z public key jako secret → krytyczna podatność. Fix: zawsze jawnie określ algorithms: ["RS256"]. Expired token: sprawdź exp. Klucz rotacja: jeśli klucz się zmienił, stare tokeny stają się invalid. Audience mismatch: token dla innej aplikacji – sprawdź aud.
Czy mogę ufać narzędziom online do weryfikacji JWT?
NIE dla produkcyjnych tokenów z prawdziwymi danymi. Ryzyko: token zawiera payload z danymi użytkownika. Bezpieczne: to narzędzie weryfikuje w przeglądarce (JavaScript), bez wysyłania na serwer. Sprawdź: czy narzędzie jest open-source, czy używa network requests. Deweloperskie tokeny testowe: bezpieczne. Produkcyjne: używaj lokalnie (node-jose, python-jose).
Co to jest "alg:none" atak na JWT?
Podatność: jeśli serwer akceptuje JWT z "alg":"none" w headerze – każdy może stworzyć ważny token bez podpisu. Przykład ataku: zmień header na {"alg":"none","typ":"JWT"}, usuń signature, dodaj {admin:true} w payload. Fix: zawsze sprawdź algorytm w kodzie serwerowym. Nigdy nie ufaj algorytmowi deklarowanemu w tokenie – whitelist.
Czym różni się weryfikacja HS256 od RS256?
W HS256 podpis liczy się i sprawdza tym samym sekretem, więc każdy, kto zna klucz, może wystawić ważny token. W RS256 podpis powstaje kluczem prywatnym, a weryfikacja używa wyłącznie klucza publicznego – dlatego sprawdza się tam, gdzie tokeny wystawia jeden serwis, a weryfikuje wiele innych.
Czy wklejanie tokenu do weryfikatora jest bezpieczne?
Obliczenia wykonuje Web Crypto API lokalnie w przeglądarce, token nie jest wysyłany na żaden serwer. Na komputerze współdzielonym pamiętaj jednak, że ładunek tokenu i wklejony klucz pozostają w pamięci karty do momentu zamknięcia strony.
Dlaczego wynik to invalid, mimo że token działa w aplikacji?
Najczęstsze przyczyny to inny sekret lub klucz niż użyty do podpisania, zmiana choćby jednego znaku w ładunku albo klucz publiczny z zupełnie innej pary. Sprawdź też, czy kopiując token, nie urwałeś ostatniego znaku trzeciego segmentu.
Czy mogę zweryfikować token HS256 kluczem publicznym RSA?
Nie i nie należy tego robić. Podstawienie klucza publicznego w roli sekretu HMAC to klasyczny atak alg confusion, w którym atakujący sam podpisuje token algorytmem symetrycznym. Aplikacja musi wymuszać algorytm z góry, zamiast ufać polu alg z nagłówka.
Co oznacza alg ustawione na none?
Taki token nie ma podpisu – trzeci segment jest pusty. Każdy może zmienić jego zawartość bez wykrycia, dlatego żadna aplikacja produkcyjna nie powinna przyjmować algorytmu none.
Powiązane narzedzia: analizator JWT, koder base64 i generator klucza API.