Verifisering av en Open Badge-signatur i Node.js, Python og Go
Tre fungerende kodeeksempler (Node, Python, Go) for å hente en signert Open Badge-legitimasjon, finne utstederens offentlige nøkkel og verifisere 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 utsteder legitimasjon, skjer det meste av verifiseringsarbeidet uten deg: en mottaker deler en lenke, en arbeidsgiver klikker på den, og verifiseringssiden gjør resten. Men før eller siden er det noen som stiller et skarpere spørsmål. «Hvordan vet jeg at denne filen virkelig er signert av deg, og ikke endret i etterkant?» Det spørsmålet besvares av en digital signatur, og å sjekke en tar omtrent femten linjer kode i et hvilket som helst vanlig språk.
Denne veiledningen viser hvordan du verifiserer en signert Open Badges 3.0-legitimasjon utstedt via https://badges.ninja, trinn for trinn i Node.js, Python og Go. Du trenger ikke kjøre noe av dette for å utstede legitimasjon. Det er for dem som vil revidere systemet, bygge et internt verifiseringsverktøy eller bare forstå hva «verifiserbar» betyr i praksis.
Hva du egentlig verifiserer
Det finnes to lag av verifisering i Open Badges, og det hjelper å holde dem fra hverandre.
Hostet verifisering er Open Badges 2.0-modellen. Tildelingen har en offentlig URL, og alle som åpner den, ser utstederen, merket, mottakerens hashede identitet og statusen. Tilliten kommer av at dataene serveres fra utstederens eget domene. Hvis du kan nå siden på https://badges.ninja, er legitimasjonen ekte. Dette krever verken kode eller signatur.
Signaturverifisering er Open Badges 3.0-modellen, bygget på W3C Verifiable Credentials. Legitimasjonen er pakket som et signert token, slik at den kan sjekkes offline, år senere, selv om den er kopiert inn i en lommebok eller et e-postvedlegg. Tilliten kommer fra matematikken: tokenet bærer en signatur som bare innehaveren av utstederens private nøkkel kan ha laget.
På https://badges.ninja er hver tildeling tilgjengelig i begge former. Denne artikkelen handler om den andre. Vil du ha bakgrunnen for forskjellen mellom de to versjonene, les Open Badges v2 vs v3, og for en omvisning i den hostede JSON-en, se gjennomgangen av Open Badge JSON-LD.
Delene som er i spill
Den signerte legitimasjonen er en VC-JWT: en kompakt JWS, som er tre base64url-strenger atskilt med punktum.
header.payload.signature
- Headeren forteller hvordan den ble signert. For våre legitimasjoner inneholder den
alg: EdDSA,typ: JWTog enkid(nøkkel-ID) som ser ut somdid:web:api.badges.ninja#<thumbprint>. - Payloaden inneholder påstandene (claims), blant annet
iss(utsteder-DID-endid:web:api.badges.ninja),jti(legitimasjonens ID),nbf(gyldig fra), en valgfriexp(utløp) og etvc-objekt med selveOpenBadgeCredential. - Signaturen er en Ed25519-signatur over de nøyaktige bytene i
header.payload.
Den offentlige nøkkelen som sjekker signaturen, publiseres av utstederen to steder, begge uten autentisering:
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økkelens RFC 7638-thumbprint. kid i token-headeren er DID-URL-en, og fragmentet (delen etter #) er det samme thumbprintet. Det fragmentet er hvordan du velger riktig nøkkel.
Verifiseringsoppskriften
Alle språk følger de samme fem trinnene:
- Hent den signerte legitimasjonen fra det offentlige endepunktet.
- Del tokenet i de tre delene.
- Les headeren, sjekk at
alger nøyaktigEdDSA, og ta thumbprintet frakid. - Hent JWKS og finn nøkkelen med matchende
kid. - Verifiser Ed25519-signaturen over
header.payloadmed den nøkkelen.
Legitimasjonsendepunktet er offentlig og tar tildelings-ID-en (den samme GUID-en du ser i en verifiserings-URL som https://badges.ninja/awards/<awardId>):
curl https://api.badges.ninja/certify-badge/award/<awardId>/vc
Som standard returnerer dette den signerte VC-JWT-en som application/jwt. Legg til ?format=json for å få den usignerte legitimasjons-JSON-en for lesing. Verifiseringsreferansen dokumenterer begge deler.
Merk at det ikke finnes noe eget «verifiser dette for meg»-endepunkt, og det er med vilje. En server som sier «ja, gyldig» ber deg stole på serveren. Hele poenget med en signatur er at du kan sjekke den selv mot en publisert nøkkel.
Node.js
Nodes innebygde crypto-modul støtter Ed25519 og JWK-import, så du trenger ingen avhengigheter.
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 riktig: med Ed25519 bestemmer nøkkeltypen algoritmen. Foretrekker du et bibliotek, gjør jose samme jobb med compactVerify og importJWK, og tar seg av header-sjekkene for deg.
Python
Pakken cryptography gir deg Ed25519 direkte. Installer 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 for Ed25519 i dette biblioteket, så vi dekoder x-koordinaten (den rå 32-byte offentlige nøkkelen) selv. Det er alt en JWK av typen OKP med kurven Ed25519 inneholder.
Go
Go sitt standardbibliotek dekker alt, inkludert 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)
}
Kjør den med go run main.go <awardId>. Feilhåndteringen er forenklet for lesbarhetens skyld; i et ekte verktøy ville du sjekket hver dekoding.
Vanlige feil og hvordan du leser dem
Nøkkelen finnes ikke i JWKS. Du sammenlignet hele kid fra token-headeren (did:web:api.badges.ninja#abc) med JWKS-kid (abc). Sammenlign bare fragmentet etter #. Hvis fragmentet fortsatt ikke stemmer, kan utstederen ha rotert nøkler siden tokenet ble laget; hent DID-dokumentet og se på verificationMethod-oppføringene.
Ugyldig signatur på et token du nettopp lastet ned. Sjekk at du verifiserte header.payload som den opprinnelige base64url-teksten, ikke omkodet JSON. Å serialisere JSON på nytt endrer bytene og ødelegger signaturen. Sjekk også om det er et linjeskift på slutten av det nedlastede tokenet.
Algoritmeforvirring. Det klassiske JWT-angrepet er et token som påstår alg: none eller bytter til en symmetrisk algoritme slik at en verifiserer lures til å godta det. Eksemplene våre unngår dette ved å hardkode den forventede algoritmen, EdDSA, og avvise alt annet. La aldri tokenet bestemme hvordan det blir verifisert.
Feil med base64-padding. JWS bruker base64url uten padding. Python må få padding lagt til igjen (vist ovenfor), og Go trenger RawURLEncoding, ikke URLEncoding.
Gyldig signatur, men er legitimasjonen fortsatt god? En signatur beviser autentisitet og integritet, ikke gjeldende status. En legitimasjon kan være riktig signert og likevel tilbakekalt eller utløpt. Sjekk exp i payloaden, og sjekk tilbakekallingsstatusen som beskrives under.
Ikke glem tilbakekalling
Hver Open Badges 3.0-legitimasjon fra https://badges.ninja har en credentialStatus-oppføring som følger W3C Bitstring Status List. Den peker på en statuslistelegitimasjon du kan hente på /certify-badge/status/<listId>. Når en utsteder tilbakekaller en tildeling, snus en bit i listen; listen caches i omtrent ett minutt, så tilbakekallinger når verifisererne raskt. Dekod listen og les biten ved legitimasjonens statusListIndex: 1 betyr tilbakekalt, 0 betyr aktiv. Verifiseringsreferansen inneholder et kort Node-eksempel på den bitsjekken.
En komplett verifiserer gjør tre ting: verifiserer signaturen, sjekker utløpet og sjekker tilbakekallingsbiten. Vil du se hvordan tilbakekalling ser ut fra utstederens side, er handlingen i dashbordet beskrevet i veiledningen om tildelinger.
Når du ikke trenger noe av dette
De fleste programeiere kommer aldri til å skrive denne koden, og det er helt greit. For daglige sjekker kan du åpne tildelingens offentlige side på https://badges.ninja/awards/<awardId> og lese den. Siden krever ingen registrering og ingen nøkkel, og viser utsteder, merke og status. Mottakere kan også laste ned Verifiable Credential fra Last ned-menyen på sin offentlige legitimasjonsside og importere den i en hvilken som helst Open Badges 3.0-lommebok.
Signatursjekk blir verdifull når:
- en arbeidsgiver eller et universitet vil automatisere sjekker av legitimasjon de mottar;
- du bygger et journalsystem som lagrer kopier av legitimasjon og må kunne bevise at de ikke er endret;
- en revisor ber om bevis for at legitimasjonen din kan verifiseres uavhengig, ikke bare «stol på nettsiden vår».
Det samme API-nøkkeloppsettet som brukes til utstedelse, trengs ikke her, fordi alle disse endepunktene er offentlige. Hvis du vil utstede legitimasjon fra kode, går API-hurtigstarten gjennom hvordan du lager en nøkkel og din første tildeling.

Hurtigreferanse
| Element | Verdi |
|---|---|
| Signert legitimasjon | GET https://api.badges.ninja/certify-badge/award/<awardId>/vc |
| Usignert JSON for lesing | samme URL med ?format=json |
| Utsteder-DID | did:web:api.badges.ninja |
| Offentlige nøkler | /.well-known/jwks.json og /.well-known/did.json |
| Algoritme | Ed25519 (EdDSA) |
| Nøkkelmatch | fragmentet av header-kid er lik JWKS-kid |
| Tilbakekalling | credentialStatus som peker til /certify-badge/status/<listId> |
Oppsummering
Å verifisere en Open Badge-signatur er en kort, mekanisk rutine: hent tokenet, lås algoritmen, finn nøkkelen via thumbprint, og sjekk Ed25519-signaturen over de to første segmentene. Legg til sjekk av utløp og tilbakekalling, og du har en verifiserer som ikke stoler på noen andre enn utstederens publiserte nøkkel. Den uavhengigheten er nettopp det som gjør en digital legitimasjon mer verdt enn en PDF.
Klar til å utstede din første verifiserbare legitimasjon? Kom i gang gratis på badges.ninja — visuell designer, offentlig verifiseringsside, PDF-sertifikat, Open Badge v2.0-utdata. Ingen kredittkort kreves.
Slik ble denne artikkelen laget
Enkelte innlegg på denne bloggen er utarbeidet med hjelp av en KI-assistent, og deretter gjennomgått, faktasjekket og redigert av Badges Ninja-teamet før publisering. Alle kodeeksempler og priser er verifisert mot det faktiske produktet. Les mer om vår redaksjonelle prosess og KI-bruk på vår side om redaksjonell prosess .

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.
Mer fra Nacho Coll
- Open Badges for coding bootcamps: Utsted verifiserbare bevis i kohortskala19. nov. 2026 · 10min lesing
- Sette opp webhooks for badge-hendelser: sanntidsintegrasjon med din backend16. nov. 2026 · 9min lesing
- Utløp og fornyelse av Open Badges: livssyklusstyring for tidsbegrensede legitimasjoner12. nov. 2026 · 11min lesing


