Loading...

JWKS Key Rotation & API Key Checksum Reject: เทคนิคป้องกัน API และเตะ token ปลอมตั้งแต่แรก

DevAPI SecurityJWTJWKSKey Rotation
17 พ.ย. 2026
Read in English
Avatar
NEXT4I Developer
Founder & Software Engineer

JWKS Key Rotation & API Key Checksum Reject: เทคนิคป้องกัน API และเตะ token ปลอมตั้งแต่แรก


ถ้า log API ที่เปิดออก internet เป็นประมาณนี้

401 invalid api key 401 invalid api key 401 invalid api key (ซ้ำแบบนี้เป็นหมื่นบรรทัด จาก IP ไม่กี่ตัว)

ดูเผินๆ ไม่มีพิษภัยอะไรครับ request ไม่ผ่านสักตัว แต่ลองถามต่ออีกนิดว่า กว่าระบบจะตอบ 401 ได้ มันต้องทำอะไรบ้าง ส่วนใหญ่ก็คือเอา key ไปค้นใน database ทุกครั้ง บอทยิงมาหมื่นครั้ง database ก็โดน query หมื่นครั้ง ทั้งที่คำตอบทุกครั้งคือ "ไม่มี"

กลับกัน ถ้าวันหนึ่งกุญแจที่ใช้เซ็น token หลุดออกไป request ของแฮกเกอร์จะหน้าตาถูกต้องทุกอย่าง ผ่านทุกด่าน คราวนี้ปัญหาไม่ใช่ request ที่ไม่ผ่านแล้ว แต่เป็น request ที่ผ่านทั้งที่ไม่ควรผ่าน

และจะมีคำถามตามมาว่า:

  • ดีด key มั่วทิ้งโดยไม่ต้องถาม database ได้ไหม (API Key Checksum)
  • ตรวจ token ได้เองในเครื่อง แล้วถอดกุญแจที่หลุดออกได้ทั้งชุดไหม (JWKS และ Key Rotation)
  • "เตะออก" ได้เร็วแค่ไหนจริงๆ และมีอะไรที่มันกันไม่ได้

ในบทความก่อนหน้า เราได้เห็นแล้วว่าทำไมรหัสผ่านที่ไม่แข็งแรงถึงถูกเจาะได้ง่าย คราวนี้เราจะข้ามมาฝั่งคนทำระบบ ดูว่าด่านหน้าของ API ควรตัดสินอะไรได้เองบ้าง ก่อนจะไปรบกวน database ครับ (ตอนนี้ค่อนข้างเทคนิค มี code ประกอบ)


ทำไม key มั่วถึงต้องไปถาม database?

API key ส่วนใหญ่เป็นแค่สตริงสุ่ม เช่น a8f3k2... ระบบรู้ว่าถูกหรือผิดได้วิธีเดียว คือเอาไปค้นในที่เก็บ ไม่เจอก็ปฏิเสธ

ปกติก็ไม่มีอะไรครับ จนกว่าจะมีบอทยิง key สุ่มเข้ามานาทีละหลายหมื่นครั้ง ทุกครั้งคือการค้นหนึ่งรอบ ต่อให้มี cache ข้างหน้า key ที่ไม่มีอยู่จริงก็มักจะ cache miss แล้วทะลุไปถึง database อยู่ดี

ตัวอย่างที่ชัดเจนมากมาจากของใกล้ตัวเช่นเลขบัตรประชาชน

เลขบัตรประชาชนไทย 13 หลัก หลักสุดท้ายเป็นเลขตรวจสอบ (check digit) ที่คำนวณจาก 12 หลักแรก ใครพิมพ์ผิดหลักเดียว ระบบก็รู้ทันทีว่าเลขนี้ใช้ไม่ได้ โดยไม่ต้องเปิดทะเบียนราษฎรดูเลย

API key ก็ทำแบบเดียวกันได้ครับ แบ่งเป็นสามส่วน:

demo_Oc2SF0n3iNUzTBJX466NZoXBcxzv1f4SMxKL
└─┬─┘└──────────────┬─────────────┘└──┬──┘
prefix        ส่วนสุ่ม 30 ตัว        checksum 6 ตัว

ตัวอย่างที่คนรู้จักกันเยอะคือ GitHub ที่ปี 2021 เปลี่ยนรูปแบบ token มาเป็น prefix อย่าง ghp_ ตามด้วยส่วนสุ่ม แล้วปิดท้ายด้วย checksum 32 bit จาก CRC32 ที่เข้ารหัสแบบ Base62 เป็น 6 ตัวอักษร ทีม GitHub เขียนไว้ตรงๆ ว่ามันช่วยให้ตรวจ token ปลอมทิ้งได้โดยไม่ต้องไปที่ database และช่วยลดการแจ้งเตือนผิดตอนสแกนหา secret ที่หลุดอยู่ใน code


Checksum หน้าตาเป็นยังไงใน code?

ตัวอย่างนี้เป็น Go แบบย่อ ผมตั้ง prefix ว่า demo_ จะได้ไม่ไปซ้ำกับของจริงของใคร

const (
	prefix  = "demo_"
	bodyLen = 30
	sumLen  = 6
	base62  = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
)

func encodeBase62(n uint32, width int) string {
	b := make([]byte, width)
	for i := width - 1; i >= 0; i-- {
		b[i] = base62[n%62]
		n /= 62
	}
	return string(b)
}

// ด่านแรก: ตรวจรูปแบบและ checksum ในหน่วยความจำ ไม่แตะ database
func LooksValid(key string) bool {
	if len(key) != len(prefix)+bodyLen+sumLen || !strings.HasPrefix(key, prefix) {
		return false
	}
	body := key[len(prefix) : len(prefix)+bodyLen]
	sum := key[len(prefix)+bodyLen:]
	return encodeBase62(crc32.ChecksumIEEE([]byte(body)), sumLen) == sum
}

ตอนสร้าง key ก็ใช้สูตรเดียวกัน สุ่มส่วนกลางด้วย crypto/rand แล้วต่อ checksum ไว้ท้าย (Base62 หกตัวเก็บค่าได้ประมาณ 56,000 ล้านแบบ เกินค่าสูงสุดของ CRC32 ที่ประมาณ 4,300 ล้าน เลยพอดี)

แต่ checksum เป็นแค่ด่านแรกนะครับ ลำดับที่ gateway ที่ผมคิดว่าคลีนคือแบบนี้:

request เข้ามาพร้อม API key
      │
      ▼
1. รูปแบบถูกไหม (ความยาว, prefix, ชุดตัวอักษร) ──► ไม่ถูก: ปฏิเสธ
      │
      ▼
2. checksum ตรงไหม ───────────────────────────► ไม่ตรง: ปฏิเสธ
      │              (สองด่านแรกจบในหน่วยความจำ)
      ▼
3. hash key (เช่น SHA-256) แล้วค้นใน cache หรือ database
      │
      ▼
4. ผิดซ้ำๆ จาก IP หรือ client เดิม ───────────► เข้า rate limit

ที่ข้อ 3 ต้อง hash ก่อนค้น เพราะเราไม่ควรเก็บ key ตัวจริงไว้ตรงๆ อยู่แล้ว key ที่สุ่มมั่วมาจะแทบไม่มีโอกาสหลุดไปถึงข้อนี้เลยครับ

เพิ่มเติมเกี่ยวกับ checksum

checksum ป้องกันได้แค่ key ที่พิมพ์ผิด หรือสุ่มมั่ว ส่วนถ้า checksum ผ่านจะไปเจอด่านที่ 3 hash key กับ ด่าน 4 rate limit แทน

ถ้าอยากให้ด่านแรกแน่นขึ้น จะใช้ HMAC กับ secret ของเซิร์ฟเวอร์แทน CRC32 ก็ได้ คนนอกจะสร้าง key ที่หน้าตาถูกไม่ได้ถ้าไม่มี secret แต่ต้องแลกกับสองเรื่อง คือระบบสแกน secret ภายนอกจะตรวจ checksum เองไม่ได้ และเราจะมี secret เพิ่มมาอีกตัวที่ต้องดูแลและต้องมีแผนหมุนเหมือนกัน แบบไหนดีกว่าก็ขึ้นอยู่กับว่าเรายอมแลกอะไรได้มากกว่ากันครับ


JWT กับ JWKS คืออะไร แล้วต่างกันยังไง?

สองคำนี้ชื่อคล้ายกันมาก เลยสับสนกันบ่อยครับ ขอแยกให้เห็นทีละตัวก่อน

JWT (JSON Web Token) คือ token ที่ผู้ใช้ได้มาหลัง login แล้วแนบมากับทุก request เพื่อยืนยันตัวตนกับ API ข้างในมีข้อมูลผู้ใช้ (claims) กับลายเซ็นดิจิทัลอยู่ในตัว ฝั่งที่ออก token (เช่น auth server) เซ็นด้วย private key ส่วน API ปลายทางตรวจด้วย public key

หน้าตาของ JWT เป็นข้อความยาวๆ สามท่อนคั่นด้วยจุด ถ้าถอดออกมาดูจะเป็นประมาณนี้

header.payload.signature

header     {"alg":"ES256","kid":"key-2026-10"}       ◄── เซ็นด้วยวิธีไหน ใช้กุญแจตัวไหน
payload    {"sub":"user-1",                           ◄── เป็นใคร
            "iss":"https://auth.example.com",         ◄── ใครออกให้
            "aud":"orders-api",                       ◄── ออกให้ใช้กับ API ไหน
            "exp":1794836000}                         ◄── หมดอายุเมื่อไร
signature  ลายเซ็นของสองท่อนแรก ที่เซ็นด้วย private key

ตรงนี้มีเรื่องที่คนเข้าใจผิดกันบ่อยครับ payload ของ JWT ไม่ได้ถูกเข้ารหัส แค่แปลงรูปแบบ (Base64URL) ใครได้ token ไปก็ถอดอ่านได้ ลายเซ็นมีไว้กันการแก้ไข ไม่ได้มีไว้ซ่อนข้อมูล เพราะฉะนั้นอย่าใส่ข้อมูลลับลงไปใน JWT

JWKS (JSON Web Key Set) คือไฟล์ JSON ที่ auth server เปิดให้ดึงไปใช้ ข้างในเป็นรายการ public key สำหรับตรวจลายเซ็นของ JWT และไม่มีข้อมูลผู้ใช้อยู่เลย มักอยู่ที่ /.well-known/jwks.json แต่ละกุญแจมีชื่อกำกับที่เรียกว่า kid (key ID)

{
  "keys": [
    { "kid": "key-2026-10", "kty": "EC", "crv": "P-256", "alg": "ES256", "use": "sig", "x": "...", "y": "..." },
    { "kid": "key-2026-07", "kty": "EC", "crv": "P-256", "alg": "ES256", "use": "sig", "x": "...", "y": "..." }
  ]
}

สรุปความต่างแบบสั้นๆ:

JWT JWKS
คืออะไร token ที่เซ็นแล้ว ใช้ยืนยันตัวตน รายการ public key ใช้ตรวจลายเซ็น
ใครออก auth server ออกให้ผู้ใช้แต่ละคน auth server เผยแพร่ชุดเดียวให้ทุก API
ใครถือ ผู้ใช้หรือแอป แนบมากับทุก request API ดึงไปเก็บไว้ใน cache
ข้างในมีอะไร ข้อมูลผู้ใช้ + ลายเซ็น public key + kid ไม่มีข้อมูลผู้ใช้
เปลี่ยนเมื่อไร ออกใหม่ทุกครั้งที่ login หรือต่ออายุ เปลี่ยนตอนหมุนกุญแจ

สองตัวนี้ทำงานคู่กันครับ JWT ทุกใบจะบอกใน header ว่าเซ็นด้วย kid ไหน API ก็หยิบ public key ตัวนั้นจาก JWKS ใน cache มาตรวจ

ถ้าจะให้เปรียบเทียบให้เห็นภาพ คล้ายๆ กับตู้ประกาศหน้าสำนักงานที่ติดตัวอย่างลายเซ็นของผู้มีอำนาจลงนามไว้นั่นแหล่ะครับ JWT คือเอกสารที่มีลายเซ็น ส่วน JWKS คือตู้ตัวอย่างลายเซ็น เอกสารทุกฉบับระบุว่าใครเซ็น คนตรวจก็เทียบกับตัวอย่างในตู้ วันไหนผู้มีอำนาจคนหนึ่งพ้นตำแหน่ง ก็ดึงตัวอย่างลายเซ็นของเขาออกจากตู้ เอกสารที่เขาเซ็นก็ตรวจไม่ผ่านอีกเลย การถอด kid ออกจาก JWKS ก็คือแบบเดียวกัน

แล้วทำไมต้องมี JWKS ในเมื่อ JWT ตรวจได้เองในเครื่องอยู่แล้ว? ข้อดีของ JWT คือ API ไม่ต้องถาม database ทุก request ข้อเสียคือเวลาจะถอนสิทธิทีละใบยาก token ที่ออกไปแล้วจะใช้ได้จนหมดอายุ ถ้าไม่มีกลไกอื่นมาช่วย JWKS ก็คือกลไกนั้นครับ เพราะเราถอดกุญแจที่หลุดออกจาก JWKS ได้ทั้งชุด และหมุนกุญแจใหม่ได้โดยไม่ต้องแก้ทุก API


หมุนกุญแจยังไงไม่ให้ระบบล้ม?

ถ้าเป็นการหมุนตามรอบปกติ ผมแบ่งเป็นสามขั้นครับ

ขั้น ทำอะไร ทำไม
1. ประกาศล่วงหน้า ใส่ public key ตัวใหม่ลง JWKS แต่ยังเซ็นด้วยตัวเก่า ให้ทุก API มีเวลาดึง JWKS ใหม่เข้า cache
2. สลับมาเซ็นด้วยตัวใหม่ token ที่ออกใหม่ใช้ kid ใหม่ token เก่ายังตรวจผ่าน เพราะกุญแจเก่ายังอยู่ใน JWKS
3. ถอดตัวเก่า เอากุญแจเก่าออกจาก JWKS รอให้ token ที่เซ็นด้วยกุญแจเก่าหมดอายุก่อน

ขั้นที่ 1 เป็นจุดที่พลาดกันบ่อย สเปก OpenID Connect บอกว่าฝั่งตรวจควรกลับไปดึง JWKS ใหม่เมื่อเจอ kid ที่ไม่รู้จัก อ่านแล้วเหมือนจะข้ามขั้นที่ 1 ไปได้เลย

แต่ในทางปฏิบัติบางทีก็อาจจะทำไม่ได้ครับ library ตรวจ JWT หลายตัวจำกัดความถี่ในการดึง JWKS ใหม่ เพื่อกันคนส่ง kid มั่วๆ มาให้เซิร์ฟเวอร์วิ่งไปโหลดรัวๆ อย่าง jose ใน Node.js ตั้ง cooldown ไว้ 30 วินาทีเป็นค่าเริ่มต้น ถ้าเราสลับไปเซ็นด้วยกุญแจใหม่ทันทีหลังประกาศ API บางเครื่องจะปฏิเสธ token ที่ถูกต้องไปช่วงหนึ่ง วิธีแก้ง่ายๆ คือประกาศกุญแจใหม่ แล้วรอให้นานกว่า cache ของฝั่งตรวจก่อนค่อยสลับ

ขั้นที่ 3 ก็เหมือนกัน ถ้า access token อายุ 15 นาที ก็ต้องรออย่างน้อย 15 นาทีหลังสลับ บวกเผื่อนาฬิกาเพี้ยนอีกนิด ค่อยถอดกุญแจเก่าออก


ถ้า private key หลุด จะเตะแฮกเกอร์ออกได้เร็วแค่ไหน?

สมมติ private key หลุด แฮกเกอร์เอาไปเซ็น token ปลอมเป็นใครก็ได้ คราวนี้ไม่มีเวลารอแล้วครับ

  1. สร้างกุญแจใหม่ แล้วสลับมาเซ็นด้วยตัวใหม่ทันที
  2. ถอด kid ที่หลุดออกจาก JWKS ทันที
  3. สั่งให้ทุก API ล้าง cache ของ JWKS หรือรอให้ cache หมดอายุ

พอ cache อัปเดต token ทุกใบที่เซ็นด้วยกุญแจที่หลุดจะตรวจไม่ผ่านพร้อมกันหมด และการปฏิเสธแต่ละ request ก็เกิดในเครื่องของ API เอง ไม่ต้องถาม database นี่แหล่ะครับคือส่วนที่ "เตะออก" ได้เร็วจริง

แต่ก็มี trade-off สองเรื่อง

เรื่องแรก ผู้ใช้จริงก็โดนเตะไปด้วย ทุกคนที่ถือ token จากกุญแจเก่าต้องได้ token ใหม่ ถ้าระบบ refresh token ทำงานดี ผู้ใช้อาจไม่รู้สึกอะไร ถ้าไม่ดี ทุกคนต้อง login ใหม่ และถ้าสงสัยว่า refresh token หลุดด้วย ก็ต้องถอนทั้งหมด

เรื่องที่สองสำคัญกว่า คือมันไม่ได้มีผลทันทีถ้า cache ยังเก่า ถ้า API cache JWKS ไว้ 10 นาที (ค่าเริ่มต้นของ jose) และเราไม่มีทางสั่งล้าง token ปลอมก็ยังผ่านได้อีกสูงสุด 10 นาที ระบบจึงควรมีช่องทางสั่ง refresh cache ของทุก instance ได้ หรือตั้ง cache ให้สั้นพอกับความเสี่ยงที่รับได้

เราเตะแฮกเกอร์ออกได้เร็ว เท่ากับ cache ที่เราตั้งไว้เองครับ


ตรวจ JWT ยังไง ให้การหมุนกุญแจมีความหมาย?

ถ้าฝั่งตรวจหละหลวม หมุนกุญแจไปก็ไม่ช่วยครับ RFC 8725 ซึ่งเป็นแนวปฏิบัติที่แนะนำสำหรับ JWT มีหลายข้อ ข้อที่ผมว่าสำคัญสุดคือ

  • กำหนด algorithm ที่ยอมรับเอง: อย่าเชื่อ alg ใน header ของ token
  • ตรวจ iss และ aud ทุกครั้ง: ให้แน่ใจว่ามาจากผู้ออกที่เราเชื่อ และออกให้ API นี้จริงๆ
  • อย่าตามลิงก์ jku หรือ x5u ใน header: ใช้ JWKS URL ที่เราตั้งเองเท่านั้น
  • ถือ kid เป็น input ที่ไม่น่าเชื่อถือ: ถ้าเอาไปค้นใน database ต้องกัน injection

ตัวอย่างกับ jose ใน Node.js:

import { createRemoteJWKSet, jwtVerify } from "jose";

const JWKS = createRemoteJWKSet(
  new URL("https://auth.example.com/.well-known/jwks.json"),
  { cooldownDuration: 30_000, cacheMaxAge: 600_000 },
);

const { payload } = await jwtVerify(token, JWKS, {
  issuer: "https://auth.example.com",
  audience: "orders-api",
  algorithms: ["ES256"],
  clockTolerance: 30,
});

แล้วเหตุการณ์แบบไหน ควรใช้อะไร?

สรุปง่ายๆ ว่า:

เหตุการณ์ ใช้อะไร
บอทสุ่ม API key ยิงรัวๆ Checksum reject ที่ gateway + rate limit
API key ของลูกค้ารายหนึ่งหลุด ถอน key นั้นในที่เก็บ (และใน cache) แล้วออก key ใหม่ให้
access token ของผู้ใช้คนหนึ่งหลุด อายุ token สั้น + ถอน refresh token ถ้าจำเป็นจริงๆ ค่อยทำ denylist ตาม jti
private key ที่ใช้เซ็น JWT หลุด หมุนกุญแจฉุกเฉิน ถอด kid ออกจาก JWKS แล้วสั่งล้าง cache
ไม่มีเหตุอะไรเลย หมุนกุญแจตามรอบ ให้ทีมคุ้นกับขั้นตอนก่อนวันที่ต้องใช้จริง

ภาพรวมนี้ ไม่ได้หมายความว่าแถวสุดท้ายเป็นงานไม่สำคัญนะครับ ทีมที่ไม่เคยหมุนกุญแจเลย วันที่ต้องหมุนฉุกเฉินมักเจอปัญหาที่ไม่เคยเห็นมาก่อน เช่นบริการเก่าที่ hardcode public key ไว้ใน config แทนที่จะดึงจาก JWKS


สรุป: ใช้ Checksum เตะ key มั่วทิ้งก่อน ส่วน JWKS ใช้ถอดกุญแจที่ผ่านเข้ามาได้

Checksum ทำให้ API เตะ key มั่วทิ้งได้โดยยังไม่ถึง database ส่วน JWKS ทำให้ API ตรวจ JWT ได้เองในเครื่อง และให้เรามีปุ่มถอดกุญแจที่หลุดออกได้ทั้งชุด ทำให้จับ token แปลกปลอมได้เร็วขึ้น และลด workload ของเรา แต่ level ต่อไปก็ต้องมีการค้นแบบ hash กับ rate limit ด้วย


แหล่งอ่านต่อ

ติดตามการเดินทางของ NEXT4I ได้โดยตรงผ่านเว็บไซต์นี้ และสามารถลงทะเบียนเพื่อทดลองใช้ผลิตภัณฑ์ → ได้ที่นี่
#Dev#API Security#JWT#JWKS#Key Rotation
Discuss on:
Discuss on:
About Dev Notes

Shared knowledge from NEXT4I and the web community.

Back to Dev Notes

Related Articles

All Dev Notes

Be the first to try it

ลงชื่อเพื่อรับแจ้งเตือน และร่วมเป็นผู้ใช้งานกลุ่มแรกพร้อมรับสิทธิพิเศษ

Drop your email to get notified. Early access members get exclusive perks!

Please provide a valid email address.
Please provide a valid email address.

We hate spam as much as you do. Only big updates, no junk.

No subscriptions. No annual fees. No lock-ins.

We provide quality products, ultimate experiences, and AI-integrated solutions. We’re scaling up to create something new.

Top
Top