Sprytne Okazje — promocje, kody rabatowe i wyprzedaże

Weryfikator podpisu JWT

Weryfikuj podpis JWT tokenu: HS256 (HMAC) i RS256 (RSA). Sprawdź claims, exp i iss. Bezpiecznie w przeglądarce. Bezpłatnie.

Bezpieczne (SSL)
Przetwarzanie Lokalne
100% Darmowe
Instrukcja
  • 1
    Wprowadź dane
    Wpisz treść, wklej tekst lub załaduj plik z dysku.
  • 2
    Kliknij przycisk
    Narzędzie natychmiast przetworzy Twoje dane w przeglądarce.
  • 3
    Pobierz wynik
    Skopiuj gotowy tekst lub zapisz plik na urządzeniu.
function runTool() {
  return "Wynik gotowy w 0.1s";
}

Algorytm

HS256

pobrany z pola alg nagłówka tokenu

Weryfikacja podpisu

Podpis ważny
OK

porównanie timing-safe (hash_equals / openssl_verify)

Ważność czasowa

Ważny czasowo
OK

claimy exp/nbf z tolerancją skew

Ładunek

5 pól

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
}
Porównanie podpisu zawsze timing-safe: hash_equals dla HS* (hash_hmac), openssl_verify dla RS*; algorytmy ES* są uczciwie zgłaszane jako niewspierane, a „none” zawsze odrzucone
AlgorytmCharakterystykaWsparcie 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
Token startowy (przycisk „Przykład”) jest podpisany HS256 sekretem „demo-secret-please-change” — to sekret testowy, nie produkcyjny; weryfikacja czasu: exp 2027-03-14 w przyszłości
ScenariuszWynik weryfikacjiNotatka 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.

weryfikator JWT weryfikacja podpisu JWT HS256 RS256 JWT JWT signature verify

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

  1. Bierzemy token HS256 zbudowany z trzech segmentów rozdzielonych kropkami. Pierwszy segment to eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9, drugi to zakodowany ładunek, trzeci to podpis.
  2. 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.
  3. 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.
  4. 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.
  5. Kodujemy te 32 bajty w base64url. Powstaje 43 znaki – dokładnie taki ciąg powinien znajdować się w trzecim segmencie tokenu.
  6. 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

AlgorytmKlucz potrzebny do weryfikacjiRozmiar trzeciego segmentu
HS256sekret HMAC – ten sam, którym podpisano token32 bajty, czyli 43 znaki base64url
HS384sekret HMAC – ten sam, którym podpisano token48 bajtów, czyli 64 znaki base64url
HS512sekret HMAC – ten sam, którym podpisano token64 bajty, czyli 86 znaków base64url
RS256, klucz 2048-bitklucz publiczny RSA w formacie PEM lub z JWKS256 bajtów, czyli 342 znaki base64url
RS256, klucz 4096-bitklucz publiczny RSA w formacie PEM lub z JWKS512 bajtów, czyli 683 znaki base64url
ES256klucz publiczny krzywej eliptycznej P-25664 bajty, czyli 86 znaków base64url
noneklucz nie jest potrzebnytrzeci 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.

Zainstaluj Webp.pl Miej narzędzia we własnej kieszeni!