JSON Toolkit

Un mismo JSON, dos veredictos: diferencias entre parsers y el límite de confianza de la validación

En resumen: Cuando un validador acepta un documento y el servicio posterior falla, normalmente dos parsers han discrepado sobre el mismo texto. Este artículo compara claves duplicadas, bytes NUL, UTF-8 inválido, NaN y ceros a la izquierda en runtimes reales, explica cómo CVE-2026-33948 convirtió la discrepancia en superficie de ataque y muestra cómo asignar un árbitro único a cada frontera.

Advanced~6 min de lecturaPublicado el 2026-11-11Actualizado el 2026-11-11
Portada con dos herramientas que emiten veredictos opuestos sobre el mismo documento JSON

Que la validación pase demuestra exactamente una cosa: el texto fue aceptado por ese parser, bajo esa política. Cambia el parser y el veredicto puede cambiar.

El síntoma: la herramienta A aprueba, la herramienta B rechaza

Es la escena que todos hemos vivido. Una respuesta de API se pega en un formateador online y recibe la marca verde. El mismo payload llega a un servicio posterior y lanza una excepción. Cuando pones ambos parsers lado a lado y comparas carácter por carácter, normalmente ninguno está "mal": los datos cayeron exactamente en un punto donde las dos implementaciones discrepan.

No hay muchos puntos así, pero cada uno es frecuente. La tabla siguiente recoge el comportamiento real ante entradas de alta frecuencia (probado contra Node 22 JSON.parse, Python 3.11 stdlib json, jq 1.8 y validadores online habituales):

Entrada Node JSON.parse Python json.loads jq Notas
{"a":1,"a":2} clave duplicada acepta, conserva la última acepta, conserva la última acepta, conserva la última RFC 8259 solo dice SHOULD; los cuatro la dejan pasar
{"n":NaN} error acepta error La stdlib de Python la acepta por defecto: la trampa silenciosa mayor
{"n":01} cero inicial error error error Rechazada por todos, pero las posiciones de error difieren
"中文" guardada como bytes GBK error o mojibake depende de la codificación error RFC exige UTF-8, pero decodificar es tarea de la capa IO
{"a":1} con BOM error acepta (utf-8-sig) error Quien elimina el BOM decide
comentarios, comillas simples, comas finales error error error Solo los parsers JSON5/JSONC los aceptan

Fíjate en la segunda fila: json.loads('{"cpu":NaN}') es legal en Python. La biblioteca estándar acepta NaN/Infinity deliberadamente por compatibilidad hacia atrás, y muchos pipelines han contado estas líneas basura como registros normales sin notar la contaminación. Bloquearlas exige un argumento parse_constant explícito — código más abajo.

De dónde vienen las diferencias: huecos de la especificación y decisiones de implementación

El RFC 8259 no es impreciso; deja deliberadamente tres zonas "a la implementación", y cada implementación las rellena de forma distinta.

Primera, la unicidad de los nombres de objeto. La sección 4 dice que los nombres DEBERÍAN ser únicos — una recomendación, no una regla. Así, una clave duplicada no es un error de sintaxis, y los parsers de todas partes eligen "gana la última". Un validador de negocio ve entonces solo el valor superviviente; el valor que el emisor envió primero ha desaparecido sin error ni línea de log.

Segunda, los números. La gramática solo fija la forma int frac exp; la magnitud queda en manos de la implementación. JavaScript fuerza todo por dobles IEEE 754, así que 9007199254740993 se convierte en ...992. jq conserva los literales decimales fielmente desde 1.8, pero cualquier aritmética vuelve a dobles. El mismo documento puede presentar tres valores distintos entre comparación, almacenamiento y transporte.

Tercera, UTF-8 y caracteres invisibles. La especificación exige que el JSON intercambiado sea UTF-8, pero cómo se abre el archivo, si se elimina el BOM y cómo se tratan los bytes inválidos son decisiones de la capa IO. El mismo flujo de bytes da veredictos distintos según Python lo abra como utf-8 o utf-8-sig.

Una cuarta fuente son los dialectos permisivos. JSON5 admite comentarios, comillas simples y comas finales; JSONC relaja las mismas reglas en el ecosistema VS Code. Configuración parseada con un parser laxo y APIs parseadas con uno estricto es la divergencia más común dentro de un mismo equipo.

CVE-2026-33948: cuando la discrepancia se convierte en superficie de ataque

Las diferencias entre parsers suelen ser una molestia de UX. En cuanto "validar" y "parsear" corren sobre dos implementaciones distintas, se vuelven superficie de ataque. CVE-2026-33948, divulgado en 2026, es un caso de manual: jq en versiones anteriores a 1.8.2 admitía bytes NUL incrustados (\0) al leer JSON de ficheros, de modo que la misma entrada producía dos veredictos — la fase de validación trataba el contenido como terminado ahí, mientras la fase real de procesado seguía leyendo más allá. El bypass es total. El aviso de seguridad de GitHub confirma la corrección: actualizar a 1.8.2.

Extrae la lección: en cualquier cadena de "validar primero, parsear después", si los dos pasos usan implementaciones o configuraciones distintas, un atacante puede fabricar una entrada que el validador rechace y el parser acepte, colando un payload frente al control. La misma estructura se repite en la pasarela — el argumento de API7 para escribir el parseo estricto en el contrato de API es que la semántica de parseo forma parte del contrato, no un comportamiento privado de una implementación. Cuando la pasarela rechaza una petición bajo un conjunto de reglas y el servicio backend acepta el mismo cuerpo bajo otro parser, el contrato ya se ha roto.

Una autocomprobación cabe en un comando — confirma que todas las etapas usan la misma versión de jq, incluida esta corrección:

jq --version
# jq-1.7.1  ← vulnerable, actualizar
# jq-1.8.2  ← corregido

Claves duplicadas: el último valor se traga al primero en silencio

Las claves duplicadas merecen su propia sección porque son la única frontera que todos los parsers aceptan mientras casi todo desarrollador supone que da error.

import json

text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data)          # {'role': 'admin'}
print("guest" in data.values())  # False: el primer valor ha desaparecido

Si ese texto alimenta una comprobación de firma o una decisión de permisos, un atacante puede añadir un campo del mismo nombre para sobrescribir el privilegio, y tu código de validación solo ve el valor final. El JSON.parse de Node se comporta igual. Para detectar en lugar de sobrescribir en silencio, Python acepta un object_pairs_hook:

from collections import Counter

def reject_dup(pairs):
    counts = Counter(k for k, _ in pairs)
    dup = [k for k, c in counts.items() if c > 1]
    if dup:
        raise ValueError(f"duplicate keys: {dup}")
    return dict(pairs)

data = json.loads('{"a":1,"a":2}', object_pairs_hook=reject_dup)
# ValueError: duplicate keys: ['a']

La sección 4 del RFC 8259 lo dice sin rodeos: por interoperabilidad, los nombres DEBERÍAN ser únicos. Promover ese SHOULD a regla de validación cuesta un recorrido y elimina la fuente más común de "dos herramientas, dos veredictos".

La solución: un árbitro por cada frontera

La reparación no es "cambiar a un parser más estricto". Es dar a cada punto de frontera una política explícita y escrita — y hacer que validación y ejecución usen la misma. La tabla siguiente funciona como lista de revisión:

Frontera Valor laxo por defecto Veredicto recomendado Configuración representativa
claves duplicadas gana la última rechazar object_pairs_hook en Python; json/v2 de Go rechaza por defecto
NaN / Infinity Python acepta rechazar parse_constant en Python lanzando error
miembros desconocidos se ignoran en silencio decidir por contrato RejectUnknownMembers(true) en json/v2 de Go
UTF-8 inválido varía por implementación rechazar validación explícita del flujo de bytes en la capa de decodificación
BOM decide quien lo elimina eliminar una vez en la entrada utf-8-sig fijo o eliminar antes del parseo
validación y ejecución separadas cada uno lo suyo una implementación, una configuración los validadores reutilizan el parser de producción

En el lado de Python, desactivar los dos valores por defecto más peligrosos cuesta una llamada:

import json

def _reject(value):
    raise ValueError(f"non-standard constant: {value}")

data = json.loads(
    raw,
    parse_constant=_reject,          # bloquea NaN / Infinity
    object_pairs_hook=reject_dup,    # bloquea claves duplicadas
)

encoding/json/v2 en Go (con alias jsonv2) hace explícita toda la política: RejectUnknownMembers(true) rechaza los campos desconocidos, y los nombres duplicados junto al UTF-8 inválido se rechazan por defecto. La página de prácticas de GopherForge es precisa sobre el orden: acota los bytes de entrada, decodifica bajo una política explícita, valida el dominio y autoriza, y solo entonces permite efectos secundarios — y cada ruta de fallo debe ejercitarse con fixtures, no juzgarse por una cadena de error cambiada.

Lleva la política de parseo a contratos y corpus

La política necesita protección contra la deriva. Bastan dos acciones.

Primera, escribe "qué aceptamos, qué rechazamos" en la documentación de interfaz junto a las definiciones de campos. API7 recomienda un código de error estable para que los clientes distingan un error permanente de contrato de un fallo transitorio de infraestructura — una clave duplicada rechazada no debe parecer un timeout de pasarela, o invitas a una tormenta de reintentos. No vuelques el cuerpo completo de la petición en los logs: los payloads crudos pueden llevar credenciales, y algunas secuencias de bytes inválidas no son seguras de mostrar.

Segunda, construye un corpus de ambigüedad. Convierte cada fila de la tabla anterior en un fixture de prueba: claves duplicadas, claves con distinta capitalización, miembros desconocidos, UTF-8 inválido, BOM, un segundo valor final, entrada vacía. Asegura dos cosas en CI: las entradas inválidas fallan sin producir un valor parcial utilizable, y las aceptadas sobreviven intactas a un viaje de ida y vuelta de codificación y decodificación. Al actualizar un parser, reproduce muestras de forma productiva en entorno protegido en modo comparación, y revisa el cambio en el conjunto de aceptación como un cambio real de contrato en lugar de asumir que los fixtures antiguos cubren todo.

Estas acciones complementan Validación JSON en CI: pipelines con jsonlint, ajv y jq, que cubre cómo encajan la validación sintáctica y de esquema en el pipeline; este artículo cubre lo que viene antes del primer nodo — el propio parser. Los riesgos de inyección como la polución de prototipos y el XSS se tratan en la lista de riesgos de seguridad JSON; los problemas de cadena de confianza a nivel de parser, como claves duplicadas y bytes NUL, son exactamente la capa cero de esa lista. Para localizar errores de sintaxis sencillos, consulta Los límites de la gramática JSON según RFC 8259.

Lista de comprobación antes de salir a producción

  1. Alinea las versiones de parser en toda la cadena: jq, runtimes, pasarela, validadores offline — las correcciones del tipo CVE-2026-33948 deben llegar a todas partes;
  2. Rechaza explícitamente claves duplicadas y NaN: mete object_pairs_hook y parse_constant en envoltorios compartidos, nunca invoques json.loads desnudo en código de negocio;
  3. Decide los miembros desconocidos por ruta: los consumidores compatibles hacia adelante pueden ignorarlos, los endpoints de comandos deben activar RejectUnknownMembers;
  4. Corpus de ambigüedad en CI: al menos 8 fixtures, más una ejecución comparativa viejo contra nuevo antes de cualquier actualización de parser;
  5. Errores clasificables: códigos distintos para errores de contrato y de infraestructura, reintenta solo los segundos.

Volvamos a la frase inicial: pasar la validación significa "aceptado por algún parser bajo alguna política". Haz esa política explícita — en el contrato, en el corpus, en el pinning de versiones — y "un mismo JSON, dos veredictos" desaparece por fin.

FAQ

¿Las claves duplicadas son realmente un error en la especificación JSON?

No es un error de sintaxis. La sección 4 del RFC 8259 lo formula como nombres DEBERÍAN ser únicos — una recomendación, no un requisito — así que los parsers mayoritarios aceptan duplicados y conservan el último valor por defecto. La especificación sí recomienda la unicidad por interoperabilidad. Promoverlo a error de validación es una decisión de contrato; detectarlo cuesta un solo recorrido.

¿Por qué la biblioteca json de Python acepta NaN y la de JavaScript lanza error?

La biblioteca estándar de Python acepta NaN e Infinity deliberadamente para poder releer datos que históricamente emitió con pérdida. El JSON.parse de ECMAScript implementa la gramática de forma estricta y lanza SyntaxError. Pasando parse_constant en Python los rechaza, y una línea de configuración alinea ambos runtimes.

¿Qué versiones afecta CVE-2026-33948 y cómo se corrige?

jq antes de 1.8.2, al leer JSON de ficheros, acepta bytes NUL incrustados que hacen que la fase de validación y el parser real discrepen sobre la misma entrada, permitiendo una omisión de validación. La corrección del aviso de GitHub es actualizar a 1.8.2 o a una compilación que contenga el commit 6374ae0. Fija versiones en scripts y CI, y ejecuta el corpus de ambigüedad antes de actualizar.

Valido una vez en la entrada y reutilizo el resultado — ¿sigo expuesto?

Sí, pero el riesgo se concentra en ese único punto de entrada. Si el parser de entrada, su configuración y su versión están fijados, y el corpus de ambigüedad cubre claves duplicadas, bytes NUL y UTF-8, no hay un segundo árbitro dentro de la cadena. La topología peligrosa es una pasarela sobre una implementación y servicios sobre otra, o validación sobre un parser y ejecución sobre otro — eso entrega el veredicto a la propia discrepancia.