ToolDeck

ถอดรหัส JWT

ถอดรหัสและตรวจสอบ JSON Web Token

ลองตัวอย่าง

JWT Token

ประมวลผลในเครื่อง · ปลอดภัยในการวางข้อมูลลับ
ลองดูด้วย:ตัวเข้ารหัส JWT

JWT (JSON Web Token) คืออะไร?

JSON Web Token (JWT) คือรูปแบบโทเค็นที่กระชับและปลอดภัยสำหรับ URL ซึ่งกำหนดไว้ใน RFC 7519 โดยจะเข้ารหัสชุด claims เป็นออบเจกต์ JSON จากนั้นลงนาม — และเข้ารหัสข้อมูลเพิ่มเติมตามต้องการ — เพื่อให้ผู้รับสามารถยืนยันได้ว่าข้อมูลไม่ถูกแก้ไข JWT เป็นมาตรฐานโดยพฤตินัยสำหรับการตรวจสอบตัวตนแบบไร้สถานะใน REST API ระบบ single sign-on และการอนุญาตไมโครเซอร์วิส

โครงสร้าง JWT: Header · Payload · Signature

JWT ทุกตัวประกอบด้วยสามส่วนที่เข้ารหัส base64url คั่นด้วยจุด Header และ Payload เป็น JSON ธรรมดา — ใครก็อ่านได้ — ในขณะที่ Signature เป็นค่าเข้ารหัสที่สามารถยืนยันได้ด้วยคีย์ที่ถูกต้องเท่านั้น

โทเค็นที่เข้ารหัสแล้ว

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwibmFtZSI6IkFsaWNlIiwicm9sZSI6ImFkbWluIiwiaWF0IjoxNzE3MjAwMDAwLCJleHAiOjE3MTcyMDM2MDB9.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

HeaderPayloadSignature
Header
json
{
  "alg": "HS256",
  "typ": "JWT"
}
Payload
json
{
  "sub":  "user123",
  "name": "Alice",
  "role": "admin",
  "iat":  1717200000,
  "exp":  1717203600
}

ทำไมต้องใช้ JWT Decoder?

JWT ดิบดูเหมือนข้อความสุ่ม เครื่องมือนี้แสดง Header และ Payload ในรูป JSON ที่จัดรูปแบบทันที เพื่อให้คุณตรวจสอบ claims ดูเวลาหมดอายุ และตรวจสอบการเลือกอัลกอริทึมโดยไม่ต้องเขียนโค้ดแม้แต่บรรทัดเดียว

🔍
ตรวจสอบ Claim ได้ทันที
ดู claim ทุกรายการใน Payload — sub, iss, aud, exp, บทบาทที่กำหนดเอง, สิทธิ์ต่างๆ — จัดรูปแบบและอ่านได้ด้วยคลิกเดียว
🔓
ไม่ต้องใช้คีย์ลับ
Header และ Payload เป็นสาธารณะ มีเพียง Signature เท่านั้นที่ต้องการความลับ เครื่องมือนี้ถอดรหัสทั้งสองโดยไม่ต้องใช้คีย์การลงนามของคุณ
⏱️
การวิเคราะห์เวลาหมดอายุและ Timestamp
Unix timestamp (exp, iat, nbf) จะถูกแปลงเป็นวันที่ที่อ่านได้โดยอัตโนมัติ เพื่อให้คุณตรวจสอบได้ทันทีว่าโทเค็นหมดอายุแล้วหรือไม่
🔒
ทำงานในเบราว์เซอร์ทั้งหมด
ทุกอย่างประมวลผลในเครื่อง — ไม่มีข้อมูลโทเค็นใดถูกส่งไปยังเซิร์ฟเวอร์ ปลอดภัยในการใช้กับโทเค็นสำหรับระบบจริงระหว่างการดีบัก

การอ้างอิง JWT Claims มาตรฐาน

RFC 7519 กำหนดชื่อ claim ที่ลงทะเบียนไว้เจ็ดรายการ ไม่บังคับให้ใช้ แต่แนะนำอย่างยิ่งเพื่อให้สามารถทำงานร่วมกันได้ คุณสามารถเพิ่ม claim ที่กำหนดเองใน Payload ได้

Claimคำอธิบายประเภท
issผู้ออกโทเค็นระบุว่าใครเป็นผู้ออกโทเค็น เช่น URL ของเซิร์ฟเวอร์ตรวจสอบตัวตนหรือชื่อแอปพลิเคชันstring
subหัวข้อระบุหน่วยงานที่ JWT เกี่ยวข้อง โดยทั่วไปคือ ID ผู้ใช้หรือบัญชีบริการstring
audกลุ่มเป้าหมายระบุผู้รับที่ตั้งใจไว้ ฝ่ายรับต้องยืนยันว่าตรงกับตัวระบุของตนstring | string[]
expเวลาหมดอายุUnix timestamp ที่หลังจากนั้นไม่ควรยอมรับโทเค็น ควรตั้งค่านี้เสมอเพื่อจำกัดความเสียหายจากโทเค็นที่ถูกขโมยnumber
nbfไม่ก่อนหน้านี้Unix timestamp ที่ก่อนหน้านั้นไม่ควรยอมรับโทเค็น มีประโยชน์สำหรับการกำหนดเวลาโทเค็นที่มีวันที่ในอนาคตnumber
iatออกเมื่อUnix timestamp ที่ออกโทเค็น ใช้เพื่อคำนวณอายุของโทเค็นnumber
jtiJWT IDตัวระบุเฉพาะสำหรับโทเค็น ช่วยให้สามารถยกเลิกได้โดยการจัดเก็บและตรวจสอบค่า JTI ที่ใช้ไปแล้วฝั่งเซิร์ฟเวอร์string

อัลกอริทึมการลงนาม JWT

claim ส่วนหัว alg ประกาศว่าอัลกอริทึมใดลงนามโทเค็น การเลือกส่งผลต่อความปลอดภัย ประสิทธิภาพ และว่าบริการของบุคคลที่สามสามารถยืนยันโทเค็นโดยไม่มีคีย์ส่วนตัวหรือไม่

อัลกอริทึมตระกูลประเภทคีย์หมายเหตุ
HS256HMACSymmetricพบบ่อยที่สุด ความลับที่ใช้ร่วมกัน — ผู้ที่มีความลับสามารถลงนามและยืนยันได้
HS384HMACSymmetricHMAC ที่แข็งแกร่งกว่า ต้นทุนประสิทธิภาพปานกลาง
HS512HMACSymmetricHMAC ที่แข็งแกร่งที่สุด
RS256RSAAsymmetricอัลกอริทึมแบบอสมมาตรที่ใช้กันมากที่สุด (Google, Auth0, Okta) คีย์สาธารณะยืนยันได้โดยไม่ต้องใช้คีย์ส่วนตัว
RS384RSAAsymmetricRS ที่มีความปลอดภัยสูงกว่า
RS512RSAAsymmetricRS ที่แข็งแกร่งที่สุด
ES256ECDSAAsymmetricเส้นโค้งวงรี ลายเซ็นสั้นกว่า RSA เป็นที่นิยมบนมือถือและ IoT
PS256RSA-PSSAsymmetricRSA-PSS: ทันสมัยและปลอดภัยกว่า RS256 ที่ใช้ PKCS1v1.5
noneไม่มีลายเซ็น — อันตรายอย่างยิ่ง อย่ายอมรับโทเค็นที่มี alg: none ในระบบจริงเด็ดขาด

ข้อควรพิจารณาด้านความปลอดภัย

การถอดรหัส JWT ปลอดภัยเสมอ แต่การเชื่อถือ JWT โดยไม่ตรวจสอบลายเซ็นที่ถูกต้องนั้นไม่ปลอดภัย โปรดจำกฎเหล่านี้ทุกครั้งที่ใช้โทเค็นในแอปพลิเคชันของคุณ

ปลอดภัยเสมอ
  • ถอดรหัสและตรวจสอบ JWT ในเครื่องมือสำหรับนักพัฒนาหรือเครื่องมือนี้
  • ใช้ exp, iat และ nbf เพื่อทำความเข้าใจอายุของโทเค็น
  • บันทึก claims ใน Payload เพื่อดีบัก (ละเว้นข้อมูลส่วนตัวที่ละเอียดอ่อน)
  • อ่าน header alg เพื่อทำความเข้าใจวิธีการลงนามโทเค็น
อย่าทำสิ่งนี้เด็ดขาด
  • เชื่อถือ claims ใน Payload โดยไม่ตรวจสอบลายเซ็นฝั่งเซิร์ฟเวอร์
  • ยอมรับโทเค็นที่มี alg: none ซึ่งหมายความว่าไม่มีลายเซ็นเลย
  • จัดเก็บ access token ใน localStorage บนแอปพลิเคชันที่มีความปลอดภัยสูง (ควรใช้ cookie httpOnly แทน)
  • ตั้งค่า exp ไว้ในอนาคตอันไกลโพ้นสำหรับโทเค็นที่มีสิทธิ์ละเอียดอ่อน

กรณีการใช้งานทั่วไป

ดีบักขั้นตอนการตรวจสอบตัวตน
วางโทเค็นจากแท็บเครือข่ายของเบราว์เซอร์เพื่อตรวจสอบ claims บทบาทที่ฝังไว้ และยืนยันการหมดอายุโดยไม่ต้องแตะโค้ดสำหรับระบบจริง
ตรวจสอบโทเค็นจากบุคคลที่สาม
อ่านโทเค็นจาก Google, Auth0, Okta หรือ Azure AD อย่างรวดเร็วเพื่อดูว่า claims ที่ผู้ให้บริการของคุณรวมอยู่คืออะไร และเปรียบเทียบกับสคีมาที่คาดหวัง
การพัฒนาและทดสอบ API
เมื่อเขียนหรือทดสอบ API endpoints ให้ถอดรหัส authorization header เพื่อยืนยันว่าลอจิกการสร้างโทเค็นตั้งค่า sub, aud และ scope ถูกต้อง
การอนุญาตไมโครเซอร์วิส
ในเครือข่ายบริการ แต่ละบริการจะตรวจสอบ JWT จากผู้เรียกใช้ต้นทาง ถอดรหัสโทเค็นเพื่อติดตามว่าบริการใดออกโทเค็นและสิทธิ์ใดที่อ้างสิทธิ์
การสนับสนุนและการตอบสนองต่อเหตุการณ์
เมื่อผู้ใช้รายงานข้อผิดพลาดในการตรวจสอบตัวตน ให้ถอดรหัสโทเค็นของพวกเขาเพื่อตรวจสอบว่าหมดอายุแล้ว กลุ่มเป้าหมายผิด หรือขาด claim ที่จำเป็น
การตรวจสอบความปลอดภัย
ตรวจสอบการใช้งาน JWT ในบริการต่างๆ โดยดูการเลือกอัลกอริทึม ช่วงเวลาหมดอายุ และข้อมูลที่ละเอียดอ่อนถูกเก็บโดยไม่ตั้งใจใน Payload ที่ไม่ได้เข้ารหัสหรือไม่

การถอดรหัส JWT ในโค้ด

Header และ Payload ถูกเข้ารหัส base64url เพียงแค่กลับการเข้ารหัส Base64url แทน + ด้วย - และ / ด้วย _ และไม่มีการเติม = เฉพาะ Signature เท่านั้นที่ต้องการคีย์ลับ

JavaScript (browser)
function decodeJWT(token) {
  const [, payload] = token.split('.')
  const json = atob(payload.replace(/-/g, '+').replace(/_/g, '/'))
  return JSON.parse(json)
}
Node.js
const [, payload] = token.split('.')
const decoded = JSON.parse(
  Buffer.from(payload, 'base64url').toString()
)
Python
import base64, json

def decode_jwt(token):
    payload = token.split('.')[1]
    padding = '=' * (-len(payload) % 4)
    return json.loads(base64.urlsafe_b64decode(payload + padding))
CLI (bash + jq)
TOKEN="eyJhbGc..."
echo $TOKEN | cut -d. -f2 | base64 -d 2>/dev/null | jq .

คำถามที่พบบ่อย

ฉันสามารถถอดรหัส JWT โดยไม่มีคีย์ลับได้หรือไม่?
ได้ Header และ Payload ของ JWT เป็นเพียง JSON ที่เข้ารหัส base64url ไม่ใช่การเข้ารหัสข้อมูล ทุกคนสามารถถอดรหัสและอ่านได้ ความลับ (หรือคีย์ส่วนตัวสำหรับอัลกอริทึม RS/ES) จำเป็นเฉพาะสำหรับยืนยันลายเซ็น ซึ่งยืนยันว่าโทเค็นไม่ถูกแก้ไข
การถอดรหัส JWT หมายความว่าลายเซ็นได้รับการยืนยันแล้วหรือไม่?
ไม่ การถอดรหัสอ่านเพียง claims เท่านั้น การยืนยันเป็นขั้นตอนแยกต่างหากที่ตรวจสอบลายเซ็นเข้ารหัสโดยใช้คีย์ที่ถูกต้อง ยืนยันลายเซ็นเสมอก่อนเชื่อถือ claims ใดๆ ในแอปพลิเคชันของคุณ
ความแตกต่างระหว่าง HS256 และ RS256 คืออะไร?
HS256 ใช้ความลับสมมาตรเดียวที่แชร์ระหว่างผู้ออกและผู้ยืนยัน ใครก็ตามที่มีความลับสามารถสร้างและยืนยันโทเค็นได้ RS256 ใช้คู่คีย์แบบอสมมาตร คีย์ส่วนตัวลงนาม คีย์สาธารณะยืนยัน ด้วย RS256 คุณสามารถเผยแพร่คีย์สาธารณะเพื่อให้บริการภายนอกสามารถยืนยันโทเค็นโดยไม่มีความสามารถในการปลอมแปลง
ทำไมการถอดรหัส base64 จึงล้มเหลวบางครั้ง?
JWT ใช้การเข้ารหัส base64url ซึ่งใช้ - แทน + และ _ แทน / และละเว้นอักขระเติม = ตัวถอดรหัส base64 มาตรฐานต้องการ + และ / และอาจต้องการการเติม เพิ่มการเติม (เติมให้เป็นทวีคูณของ 4 ด้วย =) และสลับอักขระก่อนถอดรหัสด้วยตนเอง
การวาง JWT สำหรับระบบจริงลงในเครื่องมือนี้ปลอดภัยหรือไม่?
ใช่ เครื่องมือนี้ทำงานในเบราว์เซอร์ของคุณทั้งหมดและไม่ส่งข้อมูลไปยังเซิร์ฟเวอร์ใดๆ อย่างไรก็ตาม ระวังว่าใครสามารถมองเห็นหน้าจอหรือประวัติเบราว์เซอร์ของคุณ สำหรับโทเค็นที่ละเอียดอ่อนมาก ให้ถอดรหัสในเครื่องของคุณผ่าน terminal แทน
alg: none หมายความว่าอะไรและอันตรายหรือไม่?
alg: none หมายความว่าโทเค็นไม่มีลายเซ็นเข้ารหัส ใครก็ตามสามารถสร้างโทเค็นที่มี claims ใดๆ และตั้งค่า alg เป็น none ไลบรารี JWT รุ่นแรกๆ บางตัวยอมรับโทเค็นเหล่านี้ ทำให้เกิดช่องโหว่ร้ายแรง ไลบรารี JWT ที่ปลอดภัยจะปฏิเสธโทเค็นที่มี alg: none เสมอ เว้นแต่จะกำหนดค่าเป็นอย่างอื่นอย่างชัดเจน อย่าปิดการตรวจสอบนี้เด็ดขาด

คู่มือภาษา