Cómo funciona la verificación

Los cinco pasos

1. 1Descargue la credencial

   Cada página de pasaporte ofrece su credencial como un token firmado, una sola línea de texto. Descárguelo. Todo lo que sigue opera sobre ese archivo, nunca sobre la página que lo muestra.

   Esto establece que usted tiene el mismo artefacto que publicó el emisor. No establece que nada de lo que contiene sea cierto.

2. 2Verifique la firma del emisor

   El token lleva una firma sobre su contenido. Un verificador rehace la comprobación con la clave pública del emisor; cambie un carácter del contenido y la comprobación falla.

   Esto establece que el contenido no ha cambiado desde que el titular de esa clave lo firmó. No establece quién tiene la clave: ese es el paso siguiente.

3. 3Compruebe la identidad del emisor

   El emisor se nombra como did:web:anydpp.eu, que resuelve a un documento público de identificación en anydpp.eu. La clave usada en el paso dos debe figurar allí, bajo el propio nombre y dominio del emisor.

   Esto establece que la clave pertenece a quien controla ese dominio. No establece que el dueño del dominio sea, en el mundo real, quien dice ser.

4. 4Compruebe la lista de estado

   La credencial nombra una lista de estado, publicada y firmada por el mismo emisor, y su propia posición en ella. Lea el bit en esa posición: 0 significa no revocada, 1 significa revocada.

   Esto establece si el emisor ha retirado la credencial desde que la emitió. No establece por qué, y no vuelve a comprobar nada de lo que la credencial dice.

5. 5Inspeccione las referencias de evidencia

   La credencial lista los documentos de origen a partir de los que se construyó, cada uno por identificador y por un resumen del registro, y nombra el documento de origen detrás de cada atributo y su nivel de confianza. No contiene los documentos en sí.

   Esto establece qué documentos afirma haber leído el emisor, y permite a quien tenga uno probar que es el mismo. No establece que esos documentos sean auténticos ni que su contenido sea cierto.

Abrir el pasaporte de demostración

Cómo funciona la verificación

Del documento de origen a una firma que un tercero puede comprobar. El método, al nivel en que lo publicamos.

Esta película: producción asistida por IA, contenido verificado por personas. Locución sintética en inglés, subtítulos en cinco idiomas. Accesibilidad y transparencia de IA

Qué ha cambiado

Qué no establece la verificación

• La verdad de cada afirmación de un documento de origen. Un resumen prueba que un documento es el que se leyó, no que lo que dice sea exacto.
• El cumplimiento legal. La credencial registra evidencia y no emite veredicto sobre si las mercancías pueden comercializarse en ningún mercado.
• La completitud de la diligencia debida. Lista los documentos que se leyeron, no los documentos que las propias obligaciones de un operador aún puedan exigir.
• Una certificación de ningún tipo. Nadie ha auditado al productor, la parcela ni el envío sobre la base de esta credencial.
• La aprobación de un regulador. Ninguna autoridad competente ha revisado ni respaldado la credencial, el emisor ni el método.

Para ingenieros: la misma comprobación, en comandos

Copy and paste

1. 1. Download the three artefacts

   # 1. the credential, as a compact JWS (application/vc+jwt)
   curl -s https://anylai.eu/api/corridor/passports/DEMO26-000001/credential.jwt -o DEMO26-000001.jwt
   
   # 2. the issuer's DID document (the public key lives HERE, not in the credential)
   curl -s https://anydpp.eu/.well-known/did.json -o did.json
   
   # 3. the status list credential (an EnvelopedVerifiableCredential around its own JWS)
   curl -s https://anylai.eu/api/corridor/status-list/1 -o status-list-1.json
   
   # what you downloaded
   sha256sum DEMO26-000001.jwt

   The credential is one line of text: header, payload and signature, base64url-encoded and dot-separated. The DID document is fetched from the issuer's own domain, never taken from inside the credential: a forged credential must not be allowed to vouch for itself.

2. 2. Verify it in Node (one file, one dependency)

   // verify.mjs  --  npm i jose  --  node verify.mjs
   import { compactVerify, importJWK } from "jose";
   import { gunzipSync } from "node:zlib";
   
   const b64 = (s) => Buffer.from(s, "base64url");
   const jws = (await (await fetch("https://anylai.eu/api/corridor/passports/DEMO26-000001/credential.jwt")).text()).trim();
   const header = JSON.parse(b64(jws.split(".")[0]));
   if (header.typ !== "vc+jwt" || header.cty !== "vc") throw new Error("not a vc+jwt");
   
   const did = header.kid.split("#")[0];
   const didDoc = await (await fetch(`https://${did.replace("did:web:", "")}/.well-known/did.json`)).json();
   const method = didDoc.verificationMethod.find((m) => m.id === header.kid);
   if (!method || !didDoc.assertionMethod.includes(header.kid)) throw new Error("kid not under assertionMethod");
   
   const key = await importJWK(method.publicKeyJwk, header.alg);
   const { payload } = await compactVerify(jws, key); // throws JWSSignatureVerificationFailed on a bad signature
   const vc = JSON.parse(Buffer.from(payload).toString("utf8"));
   if (vc.issuer.id !== method.controller) throw new Error("key controller is not the issuer");
   console.log("signature: valid | issuer:", vc.issuer.id, "| kid:", header.kid);
   
   const wrapper = await (await fetch(vc.credentialStatus.statusListCredential)).json();
   const listJws = wrapper.id.replace("data:application/vc+jwt,", "");
   const listHeader = JSON.parse(b64(listJws.split(".")[0]));
   const listMethod = didDoc.verificationMethod.find((m) => m.id === listHeader.kid);
   const listKey = await importJWK(listMethod.publicKeyJwk, listHeader.alg);
   const list = JSON.parse(Buffer.from((await compactVerify(listJws, listKey)).payload).toString("utf8"));
   const encoded = list.credentialSubject.encodedList;
   if (!encoded.startsWith("u")) throw new Error("encodedList is not multibase base64url");
   const bits = gunzipSync(b64(encoded.slice(1)));
   const index = Number(vc.credentialStatus.statusListIndex);
   const revoked = (bits[index >> 3] >> (7 - (index & 7))) & 1;
   console.log("status:", revoked ? "revoked" : "active", "| status list signature: valid");

   Steps two to four of the page above, as code. It throws on a bad signature, on a key that is not listed under the issuer's assertionMethod, on a controller that is not the issuer, and on a status list that is not signed by the same key.

3. 3. Or in Python

   # verify.py  --  pip install pyjwt cryptography requests  --  python verify.py
   import base64, gzip, json, jwt, requests
   
   jws = requests.get("https://anylai.eu/api/corridor/passports/DEMO26-000001/credential.jwt").text.strip()
   header = jwt.get_unverified_header(jws)
   assert header["typ"] == "vc+jwt" and header["cty"] == "vc"
   
   did = header["kid"].split("#")[0]
   did_doc = requests.get(f"https://{did.removeprefix('did:web:')}/.well-known/did.json").json()
   method = next(m for m in did_doc["verificationMethod"] if m["id"] == header["kid"])
   assert header["kid"] in did_doc["assertionMethod"]
   
   key = jwt.algorithms.OKPAlgorithm.from_jwk(json.dumps(method["publicKeyJwk"]))
   vc = jwt.decode(jws, key=key, algorithms=["EdDSA"])  # raises InvalidSignatureError on a bad signature
   assert vc["issuer"]["id"] == method["controller"], "key controller is not the issuer"
   print("signature: valid | issuer:", vc["issuer"]["id"], "| kid:", header["kid"])
   
   wrapper = requests.get(vc["credentialStatus"]["statusListCredential"]).json()
   list_jws = wrapper["id"].removeprefix("data:application/vc+jwt,")
   list_header = jwt.get_unverified_header(list_jws)
   list_method = next(m for m in did_doc["verificationMethod"] if m["id"] == list_header["kid"])
   list_key = jwt.algorithms.OKPAlgorithm.from_jwk(json.dumps(list_method["publicKeyJwk"]))
   status_list = jwt.decode(list_jws, key=list_key, algorithms=["EdDSA"])
   encoded = status_list["credentialSubject"]["encodedList"]
   assert encoded.startswith("u"), "encodedList is not multibase base64url"
   body = encoded[1:]
   bits = gzip.decompress(base64.urlsafe_b64decode(body + "=" * (-len(body) % 4)))
   index = int(vc["credentialStatus"]["statusListIndex"])
   print("status:", "revoked" if bits[index // 8] >> (7 - index % 8) & 1 else "active", "| status list signature: valid")

   The same check with PyJWT and cryptography. Both verifiers are the reader's own code calling an open-source library; neither calls anything of AnyLAI's except the three public downloads.

4. 4. Prove the check has teeth

   // tamper.mjs -- change ONE character of the payload segment and the signature check must fail
   import { compactVerify, importJWK } from "jose";
   const jws = (await (await fetch("https://anylai.eu/api/corridor/passports/DEMO26-000001/credential.jwt")).text()).trim();
   const [h, p, s] = jws.split(".");
   const flipped = p.slice(0, 10) + (p[10] === "A" ? "B" : "A") + p.slice(11);
   const didDoc = await (await fetch("https://anydpp.eu/.well-known/did.json")).json();
   const key = await importJWK(didDoc.verificationMethod[0].publicKeyJwk, "EdDSA");
   await compactVerify(`${h}.${flipped}.${s}`, key)
     .then(() => { throw new Error("TAMPERED CREDENTIAL VERIFIED: stop trusting this check"); })
     .catch((e) => console.log("tampered credential rejected:", e.code ?? e.message));

   Feed a credential with one character of its payload changed to the same verifier. If it still passes, the verification is not doing anything and you should stop trusting it. That is the test worth running first.

Published values

The digest is read from the live passport API when this page is viewed, so it names the artefact actually being served; compare it with the output of sha256sum above.