Een Open Badge-handtekening verifiëren in Node.js, Python en Go
Drie werkende codevoorbeelden (Node, Python, Go) om een ondertekende Open Badge-credential op te halen, de publieke sleutel van de uitgever te achterhalen en de JWS-handtekening te verifiëren.
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.
Als je credentials uitgeeft, gebeurt het meeste verificatiewerk zonder jou: een ontvanger deelt een link, een werkgever klikt erop en de verificatiepagina doet de rest. Maar vroeg of laat stelt iemand een scherpere vraag. “Hoe weet ik dat dit bestand echt door jou is ondertekend en daarna niet is aangepast?” Die vraag wordt beantwoord door een digitale handtekening, en het controleren ervan kost ongeveer vijftien regels code in elke gangbare taal.
Deze tutorial laat stap voor stap zien hoe je een ondertekende Open Badges 3.0-credential verifieert die is uitgegeven via https://badges.ninja, in Node.js, Python en Go. Je hoeft niets hiervan uit te voeren om credentials uit te geven. Het is voor wie het systeem wil auditen, een interne verificatietool wil bouwen of gewoon wil begrijpen wat “verifieerbaar” in de praktijk betekent.
Wat je eigenlijk verifieert
Er zijn twee verificatielagen in Open Badges, en het helpt om ze uit elkaar te houden.
Gehoste verificatie is het Open Badges 2.0-model. De toekenning heeft een openbare URL en wie die opent, ziet de uitgever, de badge, de gehashte identiteit van de ontvanger en de status. Het vertrouwen komt voort uit het feit dat de data van het eigen domein van de uitgever komt. Als je de pagina op https://badges.ninja kunt bereiken, is de credential echt. Hiervoor heb je geen code en geen handtekening nodig.
Handtekeningverificatie is het Open Badges 3.0-model, gebouwd op W3C Verifiable Credentials. De credential is verpakt als ondertekend token, dus je kunt het offline controleren, jaren later, zelfs als het naar een wallet of een e-mailbijlage is gekopieerd. Het vertrouwen komt uit wiskunde: het token bevat een handtekening die alleen de bezitter van de privésleutel van de uitgever kan hebben gemaakt.
Op https://badges.ninja is elke toekenning in beide vormen beschikbaar. Dit artikel gaat over de tweede. Voor achtergrond over de verschillen tussen de twee versies lees je Open Badges v2 vs v3, en voor een rondleiding door de gehoste JSON zie je de Open Badge JSON-LD-walkthrough.
De bewegende delen
De ondertekende credential is een VC-JWT: een compacte JWS, oftewel drie base64url-strings gescheiden door punten.
header.payload.signature
- De header zegt hoe er is ondertekend. Voor onze credentials bevat die
alg: EdDSA,typ: JWTen eenkid(key id) die eruitziet alsdid:web:api.badges.ninja#<thumbprint>. - De payload bevat de claims, waaronder
iss(de DID van de uitgeverdid:web:api.badges.ninja),jti(de credential-id),nbf(geldig vanaf), een optioneleexp(vervaldatum) en eenvc-object met de eigenlijkeOpenBadgeCredential. - De handtekening is een Ed25519-handtekening over de exacte bytes van
header.payload.
De publieke sleutel waarmee je de handtekening controleert, publiceert de uitgever op twee plekken, beide zonder authenticatie:
https://api.badges.ninja/.well-known/jwks.jsongeeft een JWK Set terug.https://api.badges.ninja/.well-known/did.jsongeeft het DID-document voordid:web:api.badges.ninjaterug.
De kid in de JWKS is de RFC 7638-thumbprint van de sleutel. De kid in de tokenheader is de DID-URL, en het fragment daarvan (het deel na #) is diezelfde thumbprint. Dat fragment gebruik je om de juiste sleutel te kiezen.
Het verificatierecept
Elke taal volgt dezelfde vijf stappen:
- Haal de ondertekende credential op via het publieke endpoint.
- Splits het token in zijn drie delen.
- Lees de header, controleer dat
algexactEdDSAis en haal de thumbprint uitkid. - Haal de JWKS op en zoek de sleutel waarvan de
kidovereenkomt. - Verifieer de Ed25519-handtekening over
header.payloadmet die sleutel.
Het credential-endpoint is openbaar en neemt de toekennings-id (dezelfde GUID die je ziet in een verificatie-URL zoals https://badges.ninja/awards/<awardId>):
curl https://api.badges.ninja/certify-badge/award/<awardId>/vc
Standaard geeft dit de ondertekende VC-JWT terug als application/jwt. Voeg ?format=json toe om de niet-ondertekende credential-JSON te krijgen, om te lezen. De verificatiereferentie beschrijft beide.
Let op: er is geen apart “verifieer dit voor mij”-endpoint, en dat is bewust. Een server die zegt “ja, geldig” vraagt je de server te vertrouwen. Het hele punt van een handtekening is dat je hem zelf kunt controleren met een gepubliceerde sleutel.
Node.js
De ingebouwde crypto-module van Node ondersteunt Ed25519 en JWK-import, dus je hebt geen dependencies nodig.
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);
Het null-algoritmeargument klopt: bij Ed25519 bepaalt het sleuteltype het algoritme. Liever een bibliotheek? jose doet hetzelfde met compactVerify en importJWK en regelt de headercontroles voor je.
Python
Het cryptography-pakket geeft je Ed25519 direct. Installeer het met 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 heeft in deze bibliotheek geen JWK-import voor Ed25519, dus we decoderen de x-coördinaat (de ruwe publieke sleutel van 32 bytes) zelf. Dat is alles wat een JWK van type OKP met curve Ed25519 bevat.
Go
De standaardbibliotheek van Go dekt alles af, inclusief 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)
}
Voer het uit met go run main.go <awardId>. De foutafhandeling is ingekort voor de leesbaarheid; in een echte tool controleer je elke decodering.
Veelvoorkomende fouten en hoe je ze leest
De sleutel staat niet in de JWKS. Je hebt de volledige kid uit de tokenheader (did:web:api.badges.ninja#abc) vergeleken met de JWKS-kid (abc). Vergelijk alleen het fragment na #. Komt het fragment dan nog steeds niet overeen, dan kan de uitgever sinds het aanmaken van het token de sleutels hebben gerouleerd; haal het DID-document op en bekijk de verificationMethod-items.
Ongeldige handtekening op een token dat je net hebt gedownload. Controleer of je header.payload hebt geverifieerd als de originele base64url-tekst, niet als opnieuw gecodeerde JSON. Door JSON opnieuw te serialiseren veranderen de bytes en breekt de handtekening. Controleer ook of het gedownloade token geen afsluitende regeleinde heeft.
Algoritmeverwarring. De klassieke JWT-aanval is een token dat alg: none claimt of overschakelt op een symmetrisch algoritme, zodat een verificateur wordt misleid het te accepteren. Onze voorbeelden voorkomen dat door het verwachte algoritme, EdDSA, hard te coderen en al het andere te weigeren. Laat het token nooit bepalen hoe het wordt geverifieerd.
Base64-paddingfouten. JWS gebruikt base64url zonder padding. Python heeft de padding terug nodig (zie hierboven) en Go heeft RawURLEncoding nodig, niet URLEncoding.
Geldige handtekening, maar is de credential nog goed? Een handtekening bewijst authenticiteit en integriteit, niet de huidige status. Een credential kan correct ondertekend zijn en toch ingetrokken of verlopen. Controleer exp in de payload en controleer de intrekkingsstatus die hierna wordt beschreven.
Vergeet de intrekking niet
Elke Open Badges 3.0-credential van https://badges.ninja bevat een credentialStatus-item volgens de W3C Bitstring Status List. Het wijst naar een statuslijst-credential die je kunt ophalen via /certify-badge/status/<listId>. Als een uitgever een toekenning intrekt, wordt er een bit omgedraaid in die lijst; de lijst wordt ongeveer een minuut gecachet, dus intrekkingen bereiken verificateurs snel. Decodeer de lijst en lees de bit op de statusListIndex van de credential: 1 betekent ingetrokken, 0 betekent actief. De verificatiereferentie bevat een kort Node-voorbeeld van die bitcontrole.
Een complete verificateur doet drie dingen: de handtekening verifiëren, de vervaldatum controleren en de intrekkingsbit controleren. Wil je zien hoe intrekking er vanuit de uitgever uitziet, dan staat de dashboardactie beschreven in de toekenningengids.
Wanneer je dit allemaal niet nodig hebt
De meeste programmaverantwoordelijken zullen deze code nooit schrijven, en dat is prima. Voor dagelijkse controles open je de openbare pagina van de toekenning op https://badges.ninja/awards/<awardId> en lees je die. De pagina vereist geen aanmelding en geen sleutel, en toont de uitgever, de badge en de status. Ontvangers kunnen de Verifiable Credential ook downloaden via het Download-menu op hun openbare credentialpagina en importeren in elke Open Badges 3.0-wallet.
Handtekeningcontrole wordt waardevol wanneer:
- een werkgever of universiteit controles op ontvangen credentials wil automatiseren;
- je een registratiesysteem bouwt dat kopieën van credentials opslaat en moet kunnen bewijzen dat ze niet zijn gewijzigd;
- een auditor bewijs vraagt dat je credentials onafhankelijk verifieerbaar zijn, en niet alleen “vertrouw onze website”.
Dezelfde API-sleutelconfiguratie die je voor uitgeven gebruikt, is hier niet nodig, omdat al deze endpoints openbaar zijn. Wil je wel credentials uitgeven vanuit code, dan leidt de API-quickstart je door het aanmaken van een sleutel en je eerste toekenning.

Snelle referentie
| Onderdeel | Waarde |
|---|---|
| Ondertekende credential | GET https://api.badges.ninja/certify-badge/award/<awardId>/vc |
| Niet-ondertekende JSON om te lezen | dezelfde URL met ?format=json |
| DID van de uitgever | did:web:api.badges.ninja |
| Publieke sleutels | /.well-known/jwks.json en /.well-known/did.json |
| Algoritme | Ed25519 (EdDSA) |
| Sleutelmatch | fragment van header-kid is gelijk aan JWKS-kid |
| Intrekking | credentialStatus die wijst naar /certify-badge/status/<listId> |
Afronding
Een Open Badge-handtekening verifiëren is een korte, mechanische routine: haal het token op, leg het algoritme vast, vind de sleutel via de thumbprint en controleer de Ed25519-handtekening over de eerste twee segmenten. Voeg controles op vervaldatum en intrekking toe en je hebt een verificateur die niemand vertrouwt behalve de gepubliceerde sleutel van de uitgever. Die onafhankelijkheid maakt een digitale credential meer waard dan een pdf.
Klaar om je eerste verifieerbare credential uit te geven? Begin gratis op badges.ninja — visuele ontwerper, openbare verificatiepagina, pdf-certificaat, Open Badge v2.0-uitvoer. Geen creditcard nodig.
Hoe dit artikel is gemaakt
Sommige berichten op deze blog worden met behulp van een AI-assistent opgesteld en vervolgens door het Badges Ninja-team gecontroleerd, geverifieerd en bewerkt voordat ze worden gepubliceerd. Elk codevoorbeeld en elke prijs wordt geverifieerd aan de hand van het live product. Lees meer over ons redactionele en AI-proces op onze pagina over ons redactieproces .

Over de auteur
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.
Meer van Nacho Coll
- Open Badges voor codeerbootcamps: verifieerbare credentials uitgeven op cohortschaal19 nov 2026 · 11min leestijd
- Webhooks instellen voor badge-events: realtime integratie met je backend16 nov 2026 · 9min leestijd
- Verval en verlenging van Open Badges: levenscyclusbeheer voor tijdelijke credentials12 nov 2026 · 11min leestijd


