Verificering af en Open Badge-signatur i Node.js, Python og Go
Tre fungerende kodeeksempler (Node, Python, Go) til at hente en signeret Open Badge-akkreditering, finde udstederens offentlige nøgle og verificere JWS-signaturen.
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.
Hvis du udsteder akkrediteringer, sker det meste af verificeringsarbejdet uden dig: en modtager deler et link, en arbejdsgiver klikker på det, og verificeringssiden klarer resten. Men før eller siden er der nogen, der stiller et skarpere spørgsmål. “Hvordan ved jeg, at filen virkelig er signeret af dig og ikke er redigeret bagefter?” Det spørgsmål besvares af en digital signatur, og at kontrollere en tager omkring femten linjers kode i et hvilket som helst gængs sprog.
Denne tutorial viser, hvordan du verificerer en signeret Open Badges 3.0-akkreditering udstedt via https://badges.ninja, trin for trin i Node.js, Python og Go. Du behøver ikke køre noget af det for at udstede akkrediteringer. Det er til dem, der vil auditere systemet, bygge et internt verificeringsværktøj eller blot forstå, hvad “verificerbar” betyder i praksis.
Hvad du egentlig verificerer
Der er to lag af verificering i Open Badges, og det hjælper at holde dem adskilt.
Hostet verificering er Open Badges 2.0-modellen. Tildelingen har en offentlig URL, og enhver, der åbner den, ser udstederen, badget, modtagerens hashede identitet og status. Tilliden kommer af, at dataene serveres fra udstederens eget domæne. Kan du nå siden på https://badges.ninja, er akkrediteringen ægte. Det kræver hverken kode eller signatur.
Signaturverificering er Open Badges 3.0-modellen, bygget på W3C Verifiable Credentials. Akkrediteringen er pakket som et signeret token, så den kan kontrolleres offline, år senere, selv hvis den er kopieret ind i en wallet eller en e-mail-vedhæftning. Tilliden kommer fra matematikken: tokenet bærer en signatur, som kun indehaveren af udstederens private nøgle kan have produceret.
På https://badges.ninja findes hver tildeling i begge former. Denne artikel handler om den anden. Vil du have baggrunden for forskellen på de to versioner, så læs Open Badges v2 vs v3, og for en rundtur i den hostede JSON, se gennemgangen af Open Badge JSON-LD.
De bevægelige dele
Den signerede akkreditering er et VC-JWT: en kompakt JWS, som er tre base64url-strenge adskilt af punktummer.
header.payload.signature
- Headeren fortæller, hvordan der er signeret. For vores akkrediteringer indeholder den
alg: EdDSA,typ: JWTog enkid(nøgle-id), der ser ud somdid:web:api.badges.ninja#<thumbprint>. - Payloaden rummer påstandene (claims), herunder
iss(udsteder-DID’endid:web:api.badges.ninja),jti(akkrediteringens id),nbf(gyldig fra), en valgfriexp(udløb) og etvc-objekt med selveOpenBadgeCredential. - Signaturen er en Ed25519-signatur over de nøjagtige bytes i
header.payload.
Den offentlige nøgle, der kontrollerer signaturen, udgives af udstederen to steder, begge uden autentificering:
https://api.badges.ninja/.well-known/jwks.jsonreturnerer et JWK Set.https://api.badges.ninja/.well-known/did.jsonreturnerer DID-dokumentet fordid:web:api.badges.ninja.
JWKS-kid er nøglens RFC 7638-thumbprint. kid i token-headeren er DID-URL’en, og dens fragment (delen efter #) er det samme thumbprint. Det fragment er sådan, du finder den rigtige nøgle.
Verificeringsopskriften
Alle sprog følger de samme fem trin:
- Hent den signerede akkreditering fra det offentlige endpoint.
- Del tokenet op i dets tre dele.
- Læs headeren, kontrollér at
alger præcisEdDSA, og tag thumbprintet frakid. - Hent JWKS og find nøglen, hvis
kidmatcher. - Verificér Ed25519-signaturen over
header.payloadmed den nøgle.
Akkreditering-endpointet er offentligt og tager tildelings-id’et (den samme GUID, du ser i en verificerings-URL som https://badges.ninja/awards/<awardId>):
curl https://api.badges.ninja/certify-badge/award/<awardId>/vc
Som standard returnerer det den signerede VC-JWT som application/jwt. Tilføj ?format=json for at få den usignerede akkreditering som JSON til læsning. Verificeringsreferencen dokumenterer begge dele.
Bemærk, at der ikke findes noget separat “verificér det for mig”-endpoint, og det er med vilje. En server, der fortæller dig “ja, gyldig”, beder dig stole på serveren. Hele pointen med en signatur er, at du selv kan kontrollere den mod en offentliggjort nøgle.
Node.js
Nodes indbyggede crypto-modul understøtter Ed25519 og JWK-import, så du behøver ingen afhængigheder.
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);
Argumentet null for algoritmen er korrekt: med Ed25519 fastlægger nøgletypen algoritmen. Foretrækker du et bibliotek, gør jose det samme med compactVerify og importJWK og tager sig af header-kontrollerne for dig.
Python
Pakken cryptography giver dig Ed25519 direkte. Installér den med 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 har ingen JWK-import til Ed25519 i dette bibliotek, så vi afkoder selv x-koordinaten (den rå 32-byte offentlige nøgle). Det er alt, en JWK af typen OKP med kurven Ed25519 indeholder.
Go
Go’s standardbibliotek dækker alt, også 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)
}
Kør det med go run main.go <awardId>. Fejlhåndteringen er skåret ned for læsbarhedens skyld; i et rigtigt værktøj ville du kontrollere hver afkodning.
Almindelige fejl og hvordan du læser dem
Nøglen findes ikke i JWKS. Du har sammenlignet hele kid fra token-headeren (did:web:api.badges.ninja#abc) med JWKS-kid (abc). Sammenlign kun fragmentet efter #. Hvis fragmentet stadig ikke matcher, kan udstederen have roteret nøgler, siden tokenet blev udstedt; hent DID-dokumentet og se på dets verificationMethod-poster.
Ugyldig signatur på et token, du lige har hentet. Kontrollér, at du verificerede header.payload som den oprindelige base64url-tekst og ikke gen-kodet JSON. Hvis du serialiserer JSON’en igen, ændres bytes, og signaturen brydes. Tjek også for et efterfølgende linjeskift på det downloadede token.
Algoritmeforvirring. Det klassiske JWT-angreb er et token, der påstår alg: none eller skifter til en symmetrisk algoritme, så en verificerer narres til at acceptere det. Vores eksempler undgår det ved at hårdkode den forventede algoritme, EdDSA, og afvise alt andet. Lad aldrig tokenet bestemme, hvordan det bliver verificeret.
Fejl med base64-padding. JWS bruger base64url uden padding. Python skal have padding lagt til igen (vist ovenfor), og Go skal bruge RawURLEncoding, ikke URLEncoding.
Gyldig signatur, men er akkrediteringen stadig god? En signatur beviser ægthed og integritet, ikke aktuel status. En akkreditering kan være korrekt signeret og alligevel tilbagekaldt eller udløbet. Tjek exp i payloaden, og tjek tilbagekaldelsesstatus som beskrevet herunder.
Glem ikke tilbagekaldelse
Hver Open Badges 3.0-akkreditering fra https://badges.ninja indeholder en credentialStatus-post, der følger W3C Bitstring Status List. Den peger på en statuslisteakkreditering, du kan hente på /certify-badge/status/<listId>. Når en udsteder tilbagekalder en tildeling, vendes en bit i listen; listen caches i cirka et minut, så tilbagekaldelser når verificerere hurtigt. Afkod listen og læs bitten ved akkrediteringens statusListIndex: 1 betyder tilbagekaldt, 0 betyder aktiv. Verificeringsreferencen indeholder et kort Node-eksempel på den bit-kontrol.
En komplet verificerer gør tre ting: verificerer signaturen, tjekker udløbet og tjekker tilbagekaldelsesbitten. Vil du se, hvordan tilbagekaldelse ser ud fra udstederens side, er handlingen i dashboardet beskrevet i vejledningen om tildelinger.
Når du ikke har brug for noget af dette
De fleste programejere skriver aldrig denne kode, og det er helt fint. Til den daglige kontrol kan du åbne tildelingens offentlige side på https://badges.ninja/awards/<awardId> og læse den. Siden kræver ingen tilmelding og ingen nøgle, og den viser udsteder, badge og status. Modtagere kan også downloade Verifiable Credential fra Download-menuen på deres offentlige akkrediteringsside og importere den i enhver Open Badges 3.0-wallet.
Signaturkontrol bliver værdifuld, når:
- en arbejdsgiver eller et universitet vil automatisere kontrol af akkrediteringer, de modtager;
- du bygger et journalsystem, der gemmer kopier af akkrediteringer og skal kunne bevise, at de ikke er ændret;
- en revisor beder om dokumentation for, at dine akkrediteringer er uafhængigt verificerbare og ikke bare “stol på vores hjemmeside”.
Den samme API-nøgleopsætning, der bruges til udstedelse, er ikke nødvendig her, fordi alle disse endpoints er offentlige. Hvis du vil udstede akkrediteringer fra kode, gennemgår API-quickstarten, hvordan du opretter en nøgle og din første tildeling.

Hurtig reference
| Element | Værdi |
|---|---|
| Signeret akkreditering | GET https://api.badges.ninja/certify-badge/award/<awardId>/vc |
| Usigneret JSON til læsning | samme URL med ?format=json |
| Udsteder-DID | did:web:api.badges.ninja |
| Offentlige nøgler | /.well-known/jwks.json og /.well-known/did.json |
| Algoritme | Ed25519 (EdDSA) |
| Nøglematch | fragmentet af header-kid er lig JWKS-kid |
| Tilbagekaldelse | credentialStatus peger på /certify-badge/status/<listId> |
Opsummering
At verificere en Open Badge-signatur er en kort, mekanisk rutine: hent tokenet, lås algoritmen fast, find nøglen via thumbprint, og kontrollér Ed25519-signaturen over de to første segmenter. Tilføj kontrol af udløb og tilbagekaldelse, og du har en verificerer, der ikke stoler på andre end udstederens offentliggjorte nøgle. Den uafhængighed er netop det, der gør en digital akkreditering mere værd end en PDF.
Klar til at udstede din første verificerbare akkreditering? Kom i gang gratis på badges.ninja — visuel designer, offentlig verificeringsside, PDF-certifikat, Open Badge v2.0-output. Intet kreditkort kræves.
Sådan blev denne artikel til
Nogle indlæg på denne blog udarbejdes med hjælp fra en AI-assistent og gennemgås, faktatjekkes og redigeres af Badges Ninja-teamet inden udgivelse. Alle kodeeksempler og priser verificeres mod det live produkt. Læs mere om vores redaktionelle proces og AI-proces på vores side om vores redaktionelle proces .

Om forfatteren
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.
Mere fra Nacho Coll
- Open Badges til coding bootcamps: Udsted verificerbare beviser i kohorte-skala19. nov. 2026 · 10min. læsning
- Opsætning af webhooks til badge-hændelser: realtidsintegration med din backend16. nov. 2026 · 9min. læsning
- Udløb og fornyelse af Open Badges: livscyklusstyring af tidsbegrænsede legitimationer12. nov. 2026 · 11min. læsning


