#!/bin/sh # verificar-pod.sh · An:des · verifica un paquete PoD (Proof of Decision) en tu Mac, sin confiar en An:des. # # Hace dos cosas, con herramientas que trae el Mac (shasum, openssl y curl): # 1. Recalcula la huella SHA-256 de cada archivo y la compara con la del paquete. # 2. Verifica cada sello de tiempo RFC 3161 (.tsr) contra la cadena pública de la TSA (FreeTSA): # el sello es de esa huella y lo firmó la TSA con su certificado. # # Uso, en el Terminal o como acción de Atajos («Ejecutar script de shell», con la entrada como argumentos): # sh verificar-pod.sh el paquete descomprimido: checksums.sha256, anchors/*.tsr # sh verificar-pod.sh [acta.sha256] un acta, su sello y, si la tienes, su huella esperada # Opciones (antes de los archivos): # --ca --tsa usa estos certificados en vez de bajarlos de freetsa.org # --ca-sha256 --tsa-sha256 las huellas que deben tener (por omisión, las de FreeTSA que fija An:des) # # Los certificados se bajan de https://freetsa.org/files/ y se comparan con las huellas de abajo antes de usarlos. # No sube nada: lo único que sale del Mac es la descarga de esos dos certificados, cuando no los das tú. # Salidas: 0 = comprobaciones criptográficas completas del ámbito descrito; 1 = fallo; # 2 = comprobación parcial (faltan componentes, receta o herramientas). No acredita facultades ni eficacia jurídica. CA_SHA256="2151b61137ffa86bf664691ba67e7da0b19f98c758e3d228d5d8ebf27e044438" TSA_SHA256="8bfb0305bb64e2571ca507552ef3245cb1c2fee8728e0ff8689225081ea13467" CA=""; TSA="" while [ $# -gt 0 ]; do case "$1" in --ca) CA="$2"; shift 2 ;; --tsa) TSA="$2"; shift 2 ;; --ca-sha256) CA_SHA256="$2"; shift 2 ;; --tsa-sha256) TSA_SHA256="$2"; shift 2 ;; *) break ;; esac done [ $# -ge 1 ] || { echo "Uso: sh verificar-pod.sh | [acta.sha256]"; exit 2; } FALLAS=0; PARCIAL=0; HUELLAS=0; SELLOS=0; CONTENIDOS=0 bien() { echo "✓ $1"; } mal() { echo "✗ $1"; FALLAS=$((FALLAS + 1)); } parcial() { echo "· PARCIAL: $1"; PARCIAL=$((PARCIAL + 1)); } huella() { shasum -a 256 "$1" | cut -d ' ' -f 1; } TMP=$(mktemp -d "${TMPDIR:-/tmp}/verificar-pod.XXXXXX") || exit 1 trap 'rm -rf "$TMP"' EXIT # La cadena pública de la TSA: la que das, o la que se baja de freetsa.org; en los dos casos, con su huella fijada. cadena() { if [ -z "$CA" ]; then CA="$TMP/cacert.pem"; curl -fsS --proto =https -o "$CA" https://freetsa.org/files/cacert.pem || { mal "No se pudo bajar cacert.pem de freetsa.org"; return 1; }; fi if [ -z "$TSA" ]; then TSA="$TMP/tsa.crt"; curl -fsS --proto =https -o "$TSA" https://freetsa.org/files/tsa.crt || { mal "No se pudo bajar tsa.crt de freetsa.org"; return 1; }; fi if [ "$(huella "$CA")" = "$CA_SHA256" ]; then bien "Certificado raíz de la TSA: huella $CA_SHA256"; else mal "El certificado raíz de la TSA no tiene la huella esperada"; return 1; fi if [ "$(huella "$TSA")" = "$TSA_SHA256" ]; then bien "Certificado de la TSA: huella $TSA_SHA256"; else mal "El certificado de la TSA no tiene la huella esperada"; return 1; fi } # Un sello: el TimeStampResp (.tsr) de la huella $2 (hexadecimal), firmado por la TSA de la cadena. Se verifica por partes, igual # con el openssl que trae el Mac (LibreSSL, que no lee el atributo ESSCertIDv2 de «ts -verify») que con el de Homebrew: # 1. la respuesta dice «Granted» y trae el sello; # 2. la firma CMS del sello verifica hasta la raíz de la cadena, con un certificado para sellar tiempo (timestampsign); # 3. quien firmó es el certificado de la TSA fijado (su huella SHA-256); # 4. lo sellado es esa huella, en SHA-256. sello() { HORA=$(openssl ts -reply -in "$1" -text 2>/dev/null | sed -n 's/^Time stamp: *//p') rm -f "$TMP/token.der" "$TMP/tst.der" "$TMP/firmante.pem" if openssl ts -reply -in "$1" -text 2>/dev/null | grep -q '^Status: Granted' \ && openssl ts -reply -in "$1" -token_out -out "$TMP/token.der" >/dev/null 2>&1 \ && openssl cms -verify -inform DER -binary -purpose timestampsign -in "$TMP/token.der" -CAfile "$CA" -certfile "$TSA" -signer "$TMP/firmante.pem" -out "$TMP/tst.der" >/dev/null 2>&1 \ && [ "$(openssl x509 -in "$TMP/firmante.pem" -noout -fingerprint -sha256)" = "$(openssl x509 -in "$TSA" -noout -fingerprint -sha256)" ]; then INFO=$(openssl asn1parse -inform DER -in "$TMP/tst.der" 2>/dev/null) ALG=$(printf '%s\n' "$INFO" | awk '/d=3/ && /OBJECT/ { sub(/.*:/, ""); print; exit }') IMP=$(printf '%s\n' "$INFO" | awk '/d=2/ && /OCTET STRING/ { sub(/.*:/, ""); print tolower($0); exit }') if [ "$ALG" = "sha256" ] && [ "$IMP" = "$2" ]; then SELLOS=$((SELLOS + 1)); bien "Sello RFC 3161 de $(basename "$1"): es de la huella $2 y lo firmó la TSA (${HORA:-sin hora legible})"; return fi fi mal "Sello RFC 3161 de $(basename "$1"): no es de la huella $2 o no lo firmó la TSA de la cadena" } # Recalcular únicamente recetas con bytes originales explícitos; las demás # permanecen parciales, nunca se sustituye una huella declarada por una prueba. recomputar() { if ! command -v python3 >/dev/null 2>&1; then parcial "Falta python3 para recalcular el contenido PoD"; return; fi python3 - "$1" "$2" "$3" <<'PY_POD' import hashlib,json,pathlib,sys p=pathlib.Path(sys.argv[1]);expected=sys.argv[2];root=pathlib.Path(sys.argv[3]).resolve() def unique(pairs): d={} for k,v in pairs: if k in d:raise ValueError('clave JSON duplicada') d[k]=v return d try: d=json.loads(p.read_text(),object_pairs_hook=unique) if isinstance(d.get('datos_probados'),str): raw=d['datos_probados'].encode();body=json.loads(d['datos_probados'],object_pairs_hook=unique) assert all(k in d and d[k]==v for k,v in body.items()),'contenido y registro difieren' elif d.get('canonical_algo')=='sha256_raw_bytes_v1' and isinstance(d.get('canonical_event_body_pack_path'),str): path=pathlib.PurePosixPath(d['canonical_event_body_pack_path']);assert not path.is_absolute() and '..' not in path.parts f=(root/path).resolve();assert f.is_relative_to(root) and f.is_file();raw=f.read_bytes() else:sys.exit(2) assert hashlib.sha256(raw).hexdigest()==expected,'el contenido no produce la huella anclada' except Exception: sys.exit(1) PY_POD rc=$? case "$rc" in 0) CONTENIDOS=$((CONTENIDOS + 1)); bien "$(basename "$1"): contenido recalculado contra la huella anclada" ;; 2) parcial "$(basename "$1"): receta sin bytes reconstruibles; no se acredita integridad de contenido" ;; *) mal "$(basename "$1"): contenido inválido o no coincide con la huella anclada" ;; esac } if [ -d "$1" ]; then # El paquete: cada archivo contra checksums.sha256, y cada sello contra la huella anclada que declara su constancia de anclaje (.receipt.json). P="$1" [ -f "$P/checksums.sha256" ] || { mal "Falta checksums.sha256 en $P"; exit 1; } if (cd "$P" && shasum -a 256 -c checksums.sha256 >/dev/null 2>&1); then HUELLAS=$(grep -c . "$P/checksums.sha256"); [ "$HUELLAS" -gt 0 ] || mal "Manifiesto de huellas vacío"; bien "Huellas SHA-256: los $HUELLAS archivos de checksums.sha256 coinciden" else mal "Huellas SHA-256: algún archivo no coincide con checksums.sha256" (cd "$P" && shasum -a 256 -c checksums.sha256 2>/dev/null | grep -v ': OK$' | sed 's/^/ /') fi find "$P/anchors" -name '*.tsr' 2>/dev/null | sort > "$TMP/sellos" if [ ! -s "$TMP/sellos" ]; then parcial "El paquete no trae sellos RFC 3161 (anchors/*.tsr)"; elif cadena; then while IFS= read -r T; do R="${T%.tsr}.receipt.json" H=$(sed -n 's/.*"content_hash"[[:space:]]*:[[:space:]]*"\([0-9a-f]\{64\}\)".*/\1/p' "$R" 2>/dev/null | head -n 1) [ -n "$H" ] || { mal "$(basename "$T"): falta la huella anclada en $(basename "$R")"; continue; } POD="$P/pods/$(basename "${T%.tsr}").json" if [ -f "$POD" ]; then A=$(sed -n 's/.*"anchored_hash"[[:space:]]*:[[:space:]]*"\([0-9a-f]\{64\}\)".*/\1/p' "$POD" | head -n 1) [ "$A" = "$H" ] && bien "$(basename "$POD"): su huella anclada es la de su constancia de anclaje" || mal "$(basename "$POD"): su huella anclada no es la de su constancia de anclaje" recomputar "$POD" "$H" "$P" else mal "$(basename "$T"): falta el PoD asociado; no se omite el contraste" fi sello "$T" "$H" done < "$TMP/sellos" fi else # Un acta suelta, su sello y, si la das, su huella esperada (un .sha256 de shasum o la huella en hexadecimal). ACTA=""; TSR=""; ESPERADA="" for X in "$@"; do case "$X" in *.tsr) TSR="$X" ;; *.sha256) ESPERADA=$(cut -d ' ' -f 1 < "$X") ;; *) if printf '%s' "$X" | grep -Eq '^[0-9a-fA-F]{64}$'; then ESPERADA=$(printf '%s' "$X" | tr 'A-F' 'a-f'); else ACTA="$X"; fi ;; esac done [ -f "$ACTA" ] || { mal "No encuentro el acta"; exit 1; } H=$(huella "$ACTA"); HUELLAS=1 echo "· Huella SHA-256 de $(basename "$ACTA"): $H" if [ -n "$ESPERADA" ]; then [ "$H" = "$ESPERADA" ] && bien "Coincide con la huella esperada" || mal "No coincide con la huella esperada ($ESPERADA)"; else parcial "No se aportó una huella esperada independiente"; fi if [ -n "$TSR" ]; then cadena && sello "$TSR" "$H"; else parcial "Sin sello .tsr: solo se calculó o contrastó la huella"; fi fi # Enumerar solo verificaciones efectivamente ejecutadas, incluso en modo parcial. echo "Comprobado: $HUELLAS huella(s) de archivo; $SELLOS sello(s) RFC 3161; $CONTENIDOS contenido(s) PoD recalculados." if [ "$FALLAS" -gt 0 ]; then echo "Resultado: FALLIDO, $FALLAS comprobación(es) no verifican."; exit 1; fi if [ "$PARCIAL" -gt 0 ]; then echo "Resultado: PARCIAL. No se acredita un paquete íntegramente verificado."; exit 2; fi echo "Resultado: VERIFICADO dentro del ámbito enumerado. No comprueba facultades, validez jurídica ni vigencia actual."; exit 0