Pag-verify ng Open Badge Signature sa Node.js, Python, at Go
Tatlong gumaganang code sample (Node, Python, Go) para kunin ang signed na Open Badge credential, hanapin ang public key ng issuer, at i-verify ang JWS signature.
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.
Kung nag-iissue ka ng mga credential, karamihan ng verification ay nangyayari nang hindi mo kailangang gumawa ng anuman: nagshe-share ng link ang recipient, kinlik ito ng employer, at ang verification page na ang bahala sa iba. Pero maya-maya, may magtatanong ng mas matalas na tanong. “Paano ko malalaman na talagang ikaw ang pumirma sa file na ito, at hindi ito binago pagkatapos?” Sinasagot iyan ng digital signature, at ang pag-check nito ay halos labinlimang linya lang ng code sa kahit anong mainstream na language.
Ipinapakita ng tutorial na ito, hakbang-hakbang, kung paano i-verify ang signed na Open Badges 3.0 credential na na-issue sa pamamagitan ng https://badges.ninja, sa Node.js, Python, at Go. Hindi mo kailangang patakbuhin ang alinman dito para mag-issue ng mga credential. Para ito sa mga gustong mag-audit ng system, bumuo ng internal na verification tool, o maintindihan lang kung ano ang ibig sabihin ng “verifiable” sa praktika.
Ano talaga ang vine-verify mo
May dalawang layer ng verification sa Open Badges, at nakakatulong na paghiwalayin ang mga ito.
Hosted verification ang modelo ng Open Badges 2.0. May public URL ang award, at ang sinumang magbukas nito ay makikita ang issuer, ang badge, ang hashed na identity ng recipient, at ang status. Ang tiwala ay galing sa katotohanang ang data ay galing mismo sa domain ng issuer. Kung mabubuksan mo ang page sa https://badges.ninja, totoo ang credential. Hindi ito nangangailangan ng code o signature.
Signature verification ang modelo ng Open Badges 3.0, na nakabatay sa W3C Verifiable Credentials. Ang credential ay naka-package bilang signed token, kaya puwede itong i-check offline, makalipas ang mga taon, kahit na nakopya ito sa wallet o sa email attachment. Ang tiwala ay galing sa matematika: may dalang signature ang token na tanging ang may hawak ng private key ng issuer lang ang makakagawa.
Sa https://badges.ninja, ang bawat award ay available sa dalawang anyo. Tungkol sa pangalawa ang artikulong ito. Kung gusto mo ng background sa pagkakaiba ng dalawang bersyon, basahin ang Open Badges v2 vs v3, at para sa tour ng hosted JSON, tingnan ang Open Badge JSON-LD walkthrough.
Ang mga bahaging kasangkot
Ang signed na credential ay isang VC-JWT: isang compact na JWS, na tatlong base64url string na pinaghihiwalay ng tuldok.
header.payload.signature
- Sinasabi ng header kung paano ito pinirmahan. Para sa mga credential namin, naglalaman ito ng
alg: EdDSA,typ: JWT, at isangkid(key id) na mukhangdid:web:api.badges.ninja#<thumbprint>. - Hawak ng payload ang mga claim, kasama ang
iss(ang issuer DID nadid:web:api.badges.ninja),jti(ang id ng credential),nbf(valid mula), isang opsyonal naexp(expiry), at isangvcobject na naglalaman ng mismongOpenBadgeCredential. - Ang signature ay isang Ed25519 signature sa eksaktong mga byte ng
header.payload.
Ang public key na nagche-check ng signature ay inilalathala ng issuer sa dalawang lugar, parehong walang authentication:
- Ang
https://api.badges.ninja/.well-known/jwks.jsonay nagbabalik ng JWK Set. - Ang
https://api.badges.ninja/.well-known/did.jsonay nagbabalik ng DID document para sadid:web:api.badges.ninja.
Ang kid ng JWKS ay ang RFC 7638 thumbprint ng key. Ang kid sa token header ay ang DID URL, at ang fragment nito (ang bahaging nasa pagkatapos ng #) ay ang parehong thumbprint. Ang fragment na iyon ang gamit mo para piliin ang tamang key.
Ang recipe ng verification
Sinusunod ng bawat language ang parehong limang hakbang:
- Kunin ang signed na credential mula sa public endpoint.
- Hatiin ang token sa tatlong bahagi nito.
- Basahin ang header, tiyaking eksaktong
EdDSAangalg, at kunin ang thumbprint mula sakid. - Kunin ang JWKS at hanapin ang key na tumutugma ang
kid. - I-verify ang Ed25519 signature sa
header.payloadgamit ang key na iyon.
Public ang credential endpoint at tumatanggap ito ng award id (ang parehong GUID na makikita mo sa verification URL gaya ng https://badges.ninja/awards/<awardId>):
curl https://api.badges.ninja/certify-badge/award/<awardId>/vc
Bilang default, ibinabalik nito ang signed na VC-JWT bilang application/jwt. Idagdag ang ?format=json para makuha ang unsigned na credential JSON na pambasa. Dokumentado ang dalawa sa verification reference.
Tandaan na walang hiwalay na “i-verify mo ito para sa akin” na endpoint, at sinadya iyon. Ang server na nagsasabing “oo, valid” ay humihingi sa iyo na magtiwala sa server. Ang buong punto ng signature ay ikaw mismo ang makakapag-check nito laban sa isang nailathalang key.
Node.js
Sinusuportahan ng built-in na crypto module ng Node ang Ed25519 at JWK import, kaya hindi mo kailangan ng anumang dependency.
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);
Tama ang null na algorithm argument: sa Ed25519, ang key type na ang nagtatakda ng algorithm. Kung mas gusto mo ang library, ginagawa rin ito ng jose gamit ang compactVerify at importJWK, at ito na ang bahala sa mga header check.
Python
Ibinibigay ng cryptography package ang Ed25519 nang direkta. I-install ito gamit ang 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"])
Walang JWK import para sa Ed25519 ang Python sa library na ito, kaya kami mismo ang nagde-decode ng x coordinate (ang raw na 32-byte na public key). Iyon lang ang laman ng JWK na may type na OKP at curve na Ed25519.
Go
Sakop ng standard library ng Go ang lahat, kasama ang 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)
}
Patakbuhin ito gamit ang go run main.go <awardId>. Pinaikli ang error handling para madaling basahin; sa totoong tool, dapat mong i-check ang bawat decode.
Mga karaniwang error at kung paano basahin ang mga ito
Hindi makita ang key sa JWKS. Ikinumpara mo ang buong kid mula sa token header (did:web:api.badges.ninja#abc) sa kid ng JWKS (abc). Ang fragment lang pagkatapos ng # ang ikumpara. Kung hindi pa rin tumutugma ang fragment, baka nag-rotate na ng keys ang issuer mula nang gawin ang token; kunin ang DID document at tingnan ang mga verificationMethod entry nito.
Invalid ang signature sa token na kaka-download mo lang. Tiyaking vineri-fy mo ang header.payload bilang orihinal na base64url text, hindi bilang na-re-encode na JSON. Binabago ng muling pag-serialize ng JSON ang mga byte at sinisira ang signature. I-check din kung may trailing newline ang na-download na token.
Algorithm confusion. Ang klasikong JWT attack ay ang token na nagke-claim ng alg: none o lumilipat sa symmetric algorithm para malinlang ang verifier na tanggapin ito. Iniiwasan ito ng mga sample namin sa pamamagitan ng pag-hard-code sa inaasahang algorithm, EdDSA, at pagtanggi sa lahat ng iba. Huwag kailanman hayaang ang token ang pumili kung paano ito ive-verify.
Mga error sa Base64 padding. Gumagamit ang JWS ng base64url nang walang padding. Kailangang ibalik ng Python ang padding (makikita sa itaas), at kailangan ng Go ng RawURLEncoding, hindi URLEncoding.
Valid ang signature, pero maayos pa ba ang credential? Pinatutunayan ng signature ang authenticity at integrity, hindi ang kasalukuyang status. Puwedeng tama ang pagkakapirma ng credential pero na-revoke o expired na. I-check ang exp sa payload, at ang revocation status na ilalarawan sa susunod.
Huwag kalimutan ang revocation
Ang bawat Open Badges 3.0 credential mula sa https://badges.ninja ay may credentialStatus entry na sumusunod sa W3C Bitstring Status List. Tumuturo ito sa status list credential na makukuha mo sa /certify-badge/status/<listId>. Kapag nag-revoke ng award ang isang issuer, may bit na nagbabago sa listahang iyon; naka-cache ang listahan nang mga isang minuto, kaya mabilis na umaabot sa mga verifier ang mga revocation. I-decode ang listahan at basahin ang bit sa statusListIndex ng credential: ang 1 ay revoked, ang 0 ay active. May kasamang maikling Node example ng bit check na iyon ang verification reference.
Tatlong bagay ang ginagawa ng kumpletong verifier: i-verify ang signature, i-check ang expiry, at i-check ang revocation bit. Kung gusto mong makita kung ano ang hitsura ng revocation mula sa panig ng issuer, tinatalakay ang dashboard action sa awards guide.
Kapag hindi mo kailangan ang alinman dito
Karamihan ng program owner ay hindi kailanman magsusulat ng code na ito, at okay lang iyon. Para sa pang-araw-araw na check, buksan ang public page ng award sa https://badges.ninja/awards/<awardId> at basahin ito. Hindi kailangan ng signup o key ang page, at ipinapakita nito ang issuer, badge, at status. Puwede ring i-download ng mga recipient ang Verifiable Credential mula sa Download menu sa public credential page nila, at i-import ito sa kahit anong Open Badges 3.0 wallet.
Nagiging mahalaga ang signature checking kapag:
- gustong i-automate ng employer o unibersidad ang pag-check sa mga credential na natatanggap nila;
- bumubuo ka ng records system na nag-iimbak ng mga kopya ng credential at kailangang patunayang hindi ito binago;
- humihingi ang auditor ng ebidensyang independently verifiable ang mga credential mo, hindi lang “magtiwala sa website namin”.
Hindi kailangan dito ang parehong API key setup na gamit sa pag-issue, dahil public ang lahat ng endpoint na ito. Kung gusto mong mag-issue ng mga credential mula sa code, ginagabayan ka ng API quickstart sa paggawa ng key at ng una mong award.

Mabilis na reference
| Item | Value |
|---|---|
| Signed na credential | GET https://api.badges.ninja/certify-badge/award/<awardId>/vc |
| Unsigned na JSON pambasa | parehong URL na may ?format=json |
| Issuer DID | did:web:api.badges.ninja |
| Mga public key | /.well-known/jwks.json at /.well-known/did.json |
| Algorithm | Ed25519 (EdDSA) |
| Key match | ang fragment ng header kid ay katumbas ng JWKS kid |
| Revocation | credentialStatus na tumuturo sa /certify-badge/status/<listId> |
Pagtatapos
Ang pag-verify ng Open Badge signature ay maikli at mekanikal na routine: kunin ang token, i-pin ang algorithm, hanapin ang key gamit ang thumbprint, at i-check ang Ed25519 signature sa unang dalawang segment. Magdagdag ng expiry at revocation check at mayroon ka nang verifier na walang pinagkakatiwalaan maliban sa nailathalang key ng issuer. Ang kalayaang iyon ang dahilan kung bakit mas may halaga ang digital credential kaysa sa PDF.
Handa ka na bang mag-issue ng una mong verifiable credential? Magsimula nang libre sa badges.ninja — visual designer, public verification page, PDF certificate, Open Badge v2.0 output. Hindi kailangan ng credit card.
Paano ginawa ang artikulong ito
Ang ilang artikulo sa blog na ito ay ginagawa gamit ang tulong ng AI assistant, pagkatapos ay sinusuri, tinitiyak ang katumpakan, at ine-edit ng Badges Ninja team bago ilathala. Bawat code sample at presyo ay beripikado laban sa live na produkto. Alamin pa ang tungkol sa aming editorial at AI na proseso sa aming pahina ng editorial process .

Tungkol sa may-akda
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.
Higit pa mula kay Nacho Coll
- Open Badges para sa Coding Bootcamp: Mag-issue ng Verifiable Credentials sa Laki ng Buong CohortNob 19, 2026 · 12min basahin
- Pag-set Up ng Webhooks para sa Badge Events: Real-Time na Integration sa Iyong BackendNob 16, 2026 · 10min basahin
- Expiration at Renewal ng Open Badge: Lifecycle Management para sa mga Credentials na may Takdang PanahonNob 12, 2026 · 12min basahin


