ตรวจสอบลายเซ็นของ Open Badge ด้วย Node.js, Python และ Go
ตัวอย่างโค้ดที่ใช้งานได้จริงสามภาษา (Node, Python, Go) สำหรับดึงข้อมูลรับรองแบบ Open Badge ที่ลงลายเซ็นแล้ว หากุญแจสาธารณะของผู้ออก และตรวจสอบลายเซ็น JWS
Nacho founded Badges Ninja to make issuing verifiable digital credentials as simple as a single API call — Open Badge v2.0 badges and certificates, minted, hosted, and verifiable without standing up your own issuer infrastructure.
หากคุณออกข้อมูลรับรอง งานตรวจสอบส่วนใหญ่เกิดขึ้นโดยที่คุณไม่ต้องทำอะไร ผู้รับแชร์ลิงก์ นายจ้างคลิกเข้าไป แล้วหน้าตรวจสอบจะจัดการส่วนที่เหลือเอง แต่ไม่ช้าก็เร็วจะมีคนถามคำถามที่เฉียบคมขึ้นว่า “ฉันจะรู้ได้อย่างไรว่าไฟล์นี้ถูกลงนามโดยคุณจริง และไม่ได้ถูกแก้ไขภายหลัง” คำถามนี้ตอบได้ด้วยลายเซ็นดิจิทัล และการตรวจสอบลายเซ็นใช้โค้ดเพียงราวสิบห้าบรรทัดในภาษาหลักๆ ทุกภาษา
บทแนะนำนี้แสดงวิธีตรวจสอบข้อมูลรับรอง Open Badges 3.0 ที่ลงลายเซ็นและออกผ่าน https://badges.ninja ทีละขั้นตอนด้วย Node.js, Python และ Go คุณไม่จำเป็นต้องรันอะไรเหล่านี้เพื่อออกข้อมูลรับรอง บทความนี้เหมาะกับผู้ที่ต้องการตรวจสอบระบบ สร้างเครื่องมือตรวจสอบภายในองค์กร หรืออยากเข้าใจว่าคำว่า “ตรวจสอบได้” หมายถึงอะไรในทางปฏิบัติ
สิ่งที่คุณกำลังตรวจสอบจริงๆ
การตรวจสอบใน Open Badges มีสองชั้น และควรแยกให้ออกจากกัน
การตรวจสอบแบบโฮสต์ คือโมเดลของ Open Badges 2.0 การมอบแต่ละครั้งมี URL สาธารณะ และใครก็ตามที่เปิดจะเห็นผู้ออก ตราสัญลักษณ์ดิจิทัล ตัวตนของผู้รับที่ผ่านการแฮช และสถานะ ความน่าเชื่อถือมาจากข้อเท็จจริงที่ว่าข้อมูลถูกให้บริการจากโดเมนของผู้ออกเอง หากคุณเข้าถึงหน้านั้นบน https://badges.ninja ได้ ข้อมูลรับรองนั้นก็เป็นของจริง วิธีนี้ไม่ต้องใช้โค้ดและไม่ต้องใช้ลายเซ็น
การตรวจสอบลายเซ็น คือโมเดลของ Open Badges 3.0 ซึ่งสร้างบน W3C Verifiable Credentials ข้อมูลรับรองถูกแพ็กเป็นโทเค็นที่ลงลายเซ็น จึงตรวจสอบแบบออฟไลน์ได้แม้ผ่านไปหลายปี และแม้จะถูกคัดลอกไปไว้ในกระเป๋าเงินดิจิทัลหรือไฟล์แนบอีเมลแล้วก็ตาม ความน่าเชื่อถือมาจากคณิตศาสตร์ โทเค็นมีลายเซ็นที่มีเพียงผู้ถือกุญแจส่วนตัวของผู้ออกเท่านั้นที่สร้างได้
บน https://badges.ninja ทุกการมอบมีให้ทั้งสองรูปแบบ บทความนี้พูดถึงแบบที่สอง หากต้องการพื้นหลังว่าสองเวอร์ชันต่างกันอย่างไร อ่าน Open Badges v2 vs v3 และหากต้องการดูภาพรวมของ JSON แบบโฮสต์ ดู คู่มือ Open Badge JSON-LD แบบทีละขั้น
ส่วนประกอบที่ทำงานร่วมกัน
ข้อมูลรับรองที่ลงลายเซ็นคือ VC-JWT ซึ่งเป็น JWS แบบกะทัดรัด คือสตริง base64url สามส่วนคั่นด้วยจุด
header.payload.signature
- header บอกว่าลงลายเซ็นอย่างไร สำหรับข้อมูลรับรองของเรา มี
alg: EdDSA,typ: JWTและkid(key id) ที่มีหน้าตาเป็นdid:web:api.badges.ninja#<thumbprint> - payload เก็บ claim ต่างๆ รวมถึง
iss(DID ของผู้ออกdid:web:api.badges.ninja),jti(id ของข้อมูลรับรอง),nbf(เริ่มมีผล),exp(วันหมดอายุ ซึ่งไม่บังคับ) และออบเจกต์vcที่เก็บOpenBadgeCredentialจริง - signature คือลายเซ็น Ed25519 ที่คำนวณจากไบต์ที่แน่นอนของ
header.payload
กุญแจสาธารณะที่ใช้ตรวจสอบลายเซ็นถูกเผยแพร่โดยผู้ออกใน 2 แห่ง โดยไม่ต้องยืนยันตัวตนทั้งคู่
https://api.badges.ninja/.well-known/jwks.jsonส่งคืน JWK Sethttps://api.badges.ninja/.well-known/did.jsonส่งคืนเอกสาร DID ของdid:web:api.badges.ninja
kid ใน JWKS คือ thumbprint ตาม RFC 7638 ของกุญแจ ส่วน kid ใน header ของโทเค็นคือ DID URL และส่วนเศษ (fragment) ของมัน (ส่วนหลัง #) ก็คือ thumbprint เดียวกัน ส่วนเศษนี้คือสิ่งที่ใช้เลือกกุญแจให้ถูกต้อง
สูตรการตรวจสอบ
ทุกภาษาทำตามห้าขั้นตอนเดียวกัน
- ดึงข้อมูลรับรองที่ลงลายเซ็นจาก endpoint สาธารณะ
- แยกโทเค็นออกเป็นสามส่วน
- อ่าน header ตรวจสอบว่า
algเป็นEdDSAเท่านั้น และนำ thumbprint จากkid - ดึง JWKS และหากุญแจที่มี
kidตรงกัน - ตรวจสอบลายเซ็น Ed25519 บน
header.payloadด้วยกุญแจนั้น
endpoint ของข้อมูลรับรองเป็นสาธารณะและรับ id ของการมอบ (GUID เดียวกับที่เห็นใน URL ตรวจสอบ เช่น https://badges.ninja/awards/<awardId>)
curl https://api.badges.ninja/certify-badge/award/<awardId>/vc
โดยค่าเริ่มต้นจะส่งคืน VC-JWT ที่ลงลายเซ็นเป็น application/jwt เพิ่ม ?format=json เพื่อรับ JSON ของข้อมูลรับรองที่ยังไม่ลงลายเซ็นไว้อ่าน เอกสารอ้างอิงการตรวจสอบ อธิบายทั้งสองแบบ
โปรดสังเกตว่าไม่มี endpoint “ตรวจสอบให้ฉัน” แยกต่างหาก และนี่เป็นความตั้งใจ เซิร์ฟเวอร์ที่บอกว่า “ใช่ ถูกต้อง” คือการขอให้คุณเชื่อใจเซิร์ฟเวอร์ แต่หัวใจของลายเซ็นคือคุณตรวจสอบเองได้จากกุญแจที่เผยแพร่ไว้
Node.js
โมดูล crypto ที่มาพร้อมกับ Node รองรับ Ed25519 และการนำเข้า JWK จึงไม่ต้องพึ่งพาไลบรารีใดๆ
import crypto from "node:crypto";
const API = "https://api.badges.ninja";
const awardId = process.argv[2];
// —— 1. fetch the signed credential
const jwt = (await (await fetch(`${API}/certify-badge/award/${awardId}/vc`)).text()).trim();
// —— 2. split into parts
const [h, p, s] = jwt.split(".");
const header = JSON.parse(Buffer.from(h, "base64url").toString());
const payload = JSON.parse(Buffer.from(p, "base64url").toString());
// —— 3. refuse anything but EdDSA
if (header.alg !== "EdDSA") throw new Error(`unexpected alg: ${header.alg}`);
const thumbprint = header.kid.split("#")[1];
// —— 4. resolve the public key
const jwks = await (await fetch(`${API}/.well-known/jwks.json`)).json();
const jwk = jwks.keys.find((k) => k.kid === thumbprint);
if (!jwk) throw new Error("no matching key in JWKS");
const publicKey = crypto.createPublicKey({ key: jwk, format: "jwk" });
// —— 5. verify the signature over "header.payload"
const ok = crypto.verify(null, Buffer.from(`${h}.${p}`), publicKey, Buffer.from(s, "base64url"));
console.log(ok ? "signature valid" : "signature INVALID");
console.log("issuer:", payload.iss, "credential:", payload.jti);
อาร์กิวเมนต์อัลกอริทึม null นั้นถูกต้องแล้ว เพราะกับ Ed25519 ชนิดของกุญแจกำหนดอัลกอริทึมอยู่แล้ว หากคุณชอบใช้ไลบรารี jose ทำงานเดียวกันได้ด้วย compactVerify และ importJWK และจัดการการตรวจสอบ header ให้คุณ
Python
แพ็กเกจ cryptography ให้ Ed25519 ใช้ได้โดยตรง ติดตั้งด้วย pip install cryptography requests
import base64, json, sys
import requests
from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
API = "https://api.badges.ninja"
award_id = sys.argv[1]
def b64url(data: str) -> bytes:
return base64.urlsafe_b64decode(data + "=" * (-len(data) % 4))
# —— 1. fetch the signed credential
jwt = requests.get(f"{API}/certify-badge/award/{award_id}/vc").text.strip()
# —— 2. split into parts
h, p, s = jwt.split(".")
header = json.loads(b64url(h))
payload = json.loads(b64url(p))
# —— 3. refuse anything but EdDSA
if header["alg"] != "EdDSA":
raise SystemExit(f"unexpected alg: {header['alg']}")
thumbprint = header["kid"].split("#")[1]
# —— 4. resolve the public key
keys = requests.get(f"{API}/.well-known/jwks.json").json()["keys"]
jwk = next((k for k in keys if k["kid"] == thumbprint), None)
if jwk is None:
raise SystemExit("no matching key in JWKS")
public_key = Ed25519PublicKey.from_public_bytes(b64url(jwk["x"]))
# —— 5. verify the signature over "header.payload"
try:
public_key.verify(b64url(s), f"{h}.{p}".encode())
print("signature valid")
except InvalidSignature:
print("signature INVALID")
print("issuer:", payload["iss"], "credential:", payload["jti"])
ไลบรารีนี้ของ Python ไม่มีการนำเข้า JWK สำหรับ Ed25519 เราจึงถอดรหัสพิกัด x (กุญแจสาธารณะดิบขนาด 32 ไบต์) เอง และนั่นคือทุกอย่างที่ JWK ชนิด OKP ที่ใช้เส้นโค้ง Ed25519 มีอยู่
Go
ไลบรารีมาตรฐานของ Go ครอบคลุมทุกอย่าง รวมถึง crypto/ed25519
package main
import (
"crypto/ed25519"
"encoding/base64"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"strings"
)
const api = "https://api.badges.ninja"
func get(url string) []byte {
res, err := http.Get(url)
if err != nil {
panic(err)
}
defer res.Body.Close()
b, _ := io.ReadAll(res.Body)
return b
}
func main() {
awardID := os.Args[1]
// —— 1. fetch the signed credential
jwt := strings.TrimSpace(string(get(api + "/certify-badge/award/" + awardID + "/vc")))
// —— 2. split into parts
parts := strings.Split(jwt, ".")
if len(parts) != 3 {
panic("not a compact JWS")
}
enc := base64.RawURLEncoding
hb, _ := enc.DecodeString(parts[0])
var header struct{ Alg, Kid string }
json.Unmarshal(hb, &header)
// —— 3. refuse anything but EdDSA
if header.Alg != "EdDSA" {
panic("unexpected alg: " + header.Alg)
}
thumbprint := strings.Split(header.Kid, "#")[1]
// —— 4. resolve the public key
var jwks struct {
Keys []struct{ Kid, X string } `json:"keys"`
}
json.Unmarshal(get(api+"/.well-known/jwks.json"), &jwks)
var pub ed25519.PublicKey
for _, k := range jwks.Keys {
if k.Kid == thumbprint {
pub, _ = enc.DecodeString(k.X)
}
}
if pub == nil {
panic("no matching key in JWKS")
}
// —— 5. verify the signature over "header.payload"
sig, _ := enc.DecodeString(parts[2])
ok := ed25519.Verify(pub, []byte(parts[0]+"."+parts[1]), sig)
fmt.Println("signature valid:", ok)
}
รันด้วย go run main.go <awardId> การจัดการข้อผิดพลาดถูกตัดทอนเพื่อให้อ่านง่าย ในเครื่องมือจริงคุณควรตรวจสอบการถอดรหัสทุกจุด
ข้อผิดพลาดที่พบบ่อยและวิธีอ่าน
ไม่พบกุญแจใน JWKS คุณเปรียบเทียบ kid แบบเต็มจาก header ของโทเค็น (did:web:api.badges.ninja#abc) กับ kid ของ JWKS (abc) ให้เปรียบเทียบเฉพาะส่วนเศษหลัง # หากส่วนเศษยังไม่ตรง ผู้ออกอาจหมุนเวียนกุญแจหลังจากโทเค็นถูกสร้างขึ้น ให้ดึงเอกสาร DID แล้วดูรายการ verificationMethod
ลายเซ็นไม่ถูกต้องกับโทเค็นที่เพิ่งดาวน์โหลด ตรวจสอบว่าคุณตรวจสอบ header.payload ในรูปข้อความ base64url ต้นฉบับ ไม่ใช่ JSON ที่เข้ารหัสใหม่ การทำ serialize JSON ซ้ำจะเปลี่ยนไบต์และทำให้ลายเซ็นพัง และตรวจสอบด้วยว่าโทเค็นที่ดาวน์โหลดไม่มีอักขระขึ้นบรรทัดใหม่ต่อท้าย
ความสับสนเรื่องอัลกอริทึม การโจมตี JWT แบบคลาสสิกคือโทเค็นที่อ้าง alg: none หรือสลับไปใช้อัลกอริทึมแบบสมมาตร เพื่อหลอกให้ตัวตรวจสอบยอมรับ ตัวอย่างของเราหลีกเลี่ยงได้ด้วยการกำหนดอัลกอริทึมที่คาดหวังคือ EdDSA ไว้ในโค้ด และปฏิเสธทุกอย่างที่ต่างออกไป อย่าปล่อยให้โทเค็นเป็นผู้เลือกว่าจะถูกตรวจสอบอย่างไร
ข้อผิดพลาดเรื่อง padding ของ Base64 JWS ใช้ base64url แบบไม่มี padding Python ต้องเติม padding กลับเข้าไป (ดังที่แสดงด้านบน) และ Go ต้องใช้ RawURLEncoding ไม่ใช่ URLEncoding
ลายเซ็นถูกต้อง แต่ข้อมูลรับรองยังใช้ได้หรือไม่ ลายเซ็นพิสูจน์ความถูกต้องแท้จริงและความสมบูรณ์ ไม่ใช่สถานะปัจจุบัน ข้อมูลรับรองอาจลงลายเซ็นถูกต้องแต่ถูกเพิกถอนหรือหมดอายุไปแล้ว ให้ตรวจสอบ exp ใน payload และตรวจสอบสถานะการเพิกถอนที่อธิบายต่อไป
อย่าลืมการเพิกถอน
ข้อมูลรับรอง Open Badges 3.0 ทุกรายการจาก https://badges.ninja มีรายการ credentialStatus ตาม W3C Bitstring Status List ซึ่งชี้ไปยังข้อมูลรับรองรายการสถานะที่คุณดึงได้ที่ /certify-badge/status/<listId> เมื่อผู้ออกเพิกถอนการมอบ บิตหนึ่งในรายการนั้นจะถูกพลิก รายการถูกแคชไว้ประมาณหนึ่งนาที การเพิกถอนจึงไปถึงตัวตรวจสอบได้อย่างรวดเร็ว ถอดรหัสรายการแล้วอ่านบิตที่ statusListIndex ของข้อมูลรับรอง 1 หมายถึงถูกเพิกถอน 0 หมายถึงยังใช้งานอยู่ เอกสารอ้างอิงการตรวจสอบ มีตัวอย่าง Node สั้นๆ ของการตรวจสอบบิตนั้น
ตัวตรวจสอบที่สมบูรณ์ทำสามอย่าง คือตรวจสอบลายเซ็น ตรวจสอบวันหมดอายุ และตรวจสอบบิตการเพิกถอน หากต้องการดูว่าการเพิกถอนมีหน้าตาอย่างไรจากฝั่งผู้ออก การดำเนินการบนแดชบอร์ดมีอธิบายไว้ใน คู่มือการมอบ
เมื่อคุณไม่จำเป็นต้องใช้สิ่งเหล่านี้
เจ้าของโปรแกรมส่วนใหญ่จะไม่มีวันเขียนโค้ดนี้ และไม่เป็นไรเลย สำหรับการตรวจสอบประจำวัน เปิดหน้าสาธารณะของการมอบที่ https://badges.ninja/awards/<awardId> แล้วอ่านได้เลย หน้านี้ไม่ต้องสมัครสมาชิกและไม่ต้องใช้กุญแจ และแสดงผู้ออก ตราสัญลักษณ์ดิจิทัล และสถานะ ผู้รับยังดาวน์โหลด Verifiable Credential ได้จากเมนู Download บนหน้าข้อมูลรับรองสาธารณะของตน และนำเข้าไปยังกระเป๋าเงินดิจิทัล Open Badges 3.0 ใดก็ได้
การตรวจสอบลายเซ็นมีค่ามากเมื่อ
- นายจ้างหรือมหาวิทยาลัยต้องการตรวจสอบข้อมูลรับรองที่ได้รับโดยอัตโนมัติ
- คุณกำลังสร้างระบบบันทึกข้อมูลที่เก็บสำเนาข้อมูลรับรอง และต้องพิสูจน์ว่าไม่ถูกแก้ไข
- ผู้ตรวจสอบบัญชีขอหลักฐานว่าข้อมูลรับรองของคุณตรวจสอบได้อย่างเป็นอิสระ ไม่ใช่เพียง “เชื่อเว็บไซต์ของเรา”
การตั้งค่า API key แบบเดียวกับที่ใช้ออกข้อมูลรับรองไม่จำเป็นที่นี่ เพราะ endpoint เหล่านี้เป็นสาธารณะทั้งหมด หากคุณต้องการออกข้อมูลรับรองจากโค้ด คู่มือเริ่มต้นใช้งาน API จะพาคุณสร้างกุญแจและการมอบครั้งแรก

ตารางอ้างอิงด่วน
| รายการ | ค่า |
|---|---|
| ข้อมูลรับรองที่ลงลายเซ็น | GET https://api.badges.ninja/certify-badge/award/<awardId>/vc |
| JSON ที่ไม่ลงลายเซ็นไว้อ่าน | URL เดียวกันพร้อม ?format=json |
| DID ของผู้ออก | did:web:api.badges.ninja |
| กุญแจสาธารณะ | /.well-known/jwks.json และ /.well-known/did.json |
| อัลกอริทึม | Ed25519 (EdDSA) |
| การจับคู่กุญแจ | ส่วนเศษของ kid ใน header ตรงกับ kid ของ JWKS |
| การเพิกถอน | credentialStatus ที่ชี้ไปยัง /certify-badge/status/<listId> |
สรุป
การตรวจสอบลายเซ็นของ Open Badge เป็นขั้นตอนสั้นๆ ที่ทำได้เป็นกลไก ดึงโทเค็น ตรึงอัลกอริทึม หากุญแจด้วย thumbprint และตรวจสอบลายเซ็น Ed25519 บนสองส่วนแรก เพิ่มการตรวจสอบวันหมดอายุและการเพิกถอน แล้วคุณจะได้ตัวตรวจสอบที่ไม่เชื่อใจใครเลยนอกจากกุญแจที่ผู้ออกเผยแพร่ ความเป็นอิสระนี้เองที่ทำให้ข้อมูลรับรองดิจิทัลมีค่ากว่าไฟล์ PDF
พร้อมออกข้อมูลรับรองที่ตรวจสอบได้ชุดแรกของคุณหรือยัง เริ่มใช้ฟรีที่ badges.ninja — เครื่องมือออกแบบภาพ หน้าตรวจสอบสาธารณะ ใบรับรอง PDF และเอาต์พุต Open Badge v2.0 ไม่ต้องใช้บัตรเครดิต
บทความนี้จัดทำขึ้นอย่างไร
บางบทความในบล็อกนี้ร่างขึ้นด้วยความช่วยเหลือของผู้ช่วย AI จากนั้นทีมงาน Badges Ninja จะตรวจสอบ ยืนยันข้อเท็จจริง และแก้ไขก่อนเผยแพร่ ตัวอย่างโค้ดและราคาทุกรายการได้รับการตรวจสอบกับผลิตภัณฑ์จริง อ่านเพิ่มเติมเกี่ยวกับกระบวนการด้านบรรณาธิการและ AI ของเราได้ที่ หน้ากระบวนการด้านบรรณาธิการ .

เกี่ยวกับผู้เขียน
Nacho Coll
Founder & Engineer at Badges Ninja
Nacho founded Badges Ninja to make issuing verifiable digital credentials as simple as a single API call — Open Badge v2.0 badges and certificates, minted, hosted, and verifiable without standing up your own issuer infrastructure. Writes about the Open Badges spec, credential verification, and running a credentialing platform serverless on AWS, from the operator side of the wire.
เพิ่มเติมจาก Nacho Coll
- Open Badges สำหรับบูตแคมป์เขียนโค้ด: ออกเครดิตที่ตรวจสอบได้ในระดับรุ่น19 พ.ย. 2569 · 3นาทีอ่าน
- การตั้งค่า Webhook สำหรับเหตุการณ์ของตราสัญลักษณ์ดิจิทัล: เชื่อมต่อกับแบ็กเอนด์ของคุณแบบเรียลไทม์16 พ.ย. 2569 · 4นาทีอ่าน
- การหมดอายุและการต่ออายุของ Open Badge: การจัดการวงจรชีวิตของข้อมูลรับรองที่มีกำหนดเวลา12 พ.ย. 2569 · 3นาทีอ่าน


