La Representación Concisa de Objetos Binarios ( CBOR ) es un formato de serialización de datos binarios basado libremente en JSON . Al igual que JSON, permite la transmisión de objetos de datos que contienen pares nombre-valor , pero de una manera más concisa. Esto aumenta las velocidades de procesamiento y transferencia a costa de la legibilidad humana . Está definido en IETF RFC 8949 . [1]
Extensión de nombre de archivo | .cbor |
---|---|
Tipo de medio de Internet | aplicación / cbor |
Tipo de formato | Intercambio de datos |
Estándar | RFC 8949 |
¿ Formato abierto ? | sí |
Sitio web | cbor |
Entre otros usos, es la capa de serialización de datos recomendada para el conjunto de protocolos CoAP Internet of Things [2] [ verificación fallida ] y el formato de datos en el que se basan los mensajes COSE . También se utiliza en el Protocolo de cliente a autenticador (CTAP) dentro del alcance del proyecto FIDO2. [3]
Especificación de la codificación CBOR
Los datos codificados con CBOR se ven como un flujo de elementos de datos. Cada elemento de datos consta de un byte de encabezado que contiene un tipo de 3 bits y un recuento corto de 5 bits. A esto le sigue un recuento extendido opcional (si el recuento corto está en el rango 24-27) y una carga útil opcional.
Para los tipos 0, 1 y 7, no hay carga útil; la cuenta es el valor. Para los tipos 2 (cadena de bytes) y 3 (cadena de texto), el recuento es la longitud de la carga útil. Para los tipos 4 (matriz) y 5 (mapa), el recuento es el número de elementos (pares) en la carga útil. Para el tipo 6 (etiqueta), la carga útil es un solo artículo y el recuento es un número de etiqueta numérico que describe el artículo adjunto.
Datos CBOR | Elemento de datos 1 | Elemento de datos 2 | Elemento de dato 3 ... | ||||||
---|---|---|---|---|---|---|---|---|---|
Recuento de bytes | 1 byte (encabezado del elemento de datos CBOR) | Variable | Variable | 1 byte (encabezado del elemento de datos CBOR) | Variable | Variable | etc ... | ||
Estructura | Tipo mayor | Conteo corto | Cuenta extendida (opcional) | Carga útil de datos (opcional) | Tipo mayor | Conteo corto | Cuenta extendida (opcional) | Carga útil de datos (opcional) | etc ... |
Recuento de bits | 3 bits | 5 bits | 8 bits × variable | 8 bits × variable | 3 bits | 5 bits | 8 bits × variable | 8 bits × variable | etc. |
Manejo principal de tipos y recuentos en cada elemento de datos
El comportamiento de cada elemento de datos se define por el tipo principal y el recuento. El tipo principal se utiliza para seleccionar el comportamiento principal o el tipo de cada elemento de datos.
El campo de conteo corto de 5 bits codifica directamente los conteos 0-23. Los recuentos cortos de 24 a 27 indican que el valor del recuento está en un campo de recuento extendido de 8, 16, 32 o 64 bits siguiente. Los valores 28-30 no están asignados y no deben utilizarse.
Los tipos se dividen en tipos "atómicos" 0–1 y 6–7, para los cuales el campo de recuento codifica el valor directamente, y los tipos no atómicos 2-5, para los cuales el campo de recuento codifica el tamaño del siguiente campo de carga útil.
Se utiliza un recuento corto de 31 con los tipos no atómicos 2-5 para indicar una longitud indefinida; la carga útil son los siguientes elementos hasta un byte de marcador de "interrupción" de 255 (tipo = 7, recuento corto = 31). No se permite una cuenta corta de 31 con los otros tipos atómicos 0, 1 o 6.
El tipo 6 (etiqueta) es inusual porque su campo de recuento codifica un valor directamente, pero también tiene un campo de carga útil (que siempre consta de un solo elemento).
Los recuentos extendidos y todos los valores de varios bytes se codifican en el orden de bytes de la red (big-endian) .
Codificación de campo de elemento de datos CBOR
Codificación de campo diminuto
Recuento de bytes | 1 byte (encabezado del elemento de datos CBOR) | |
---|---|---|
Estructura | Tipo mayor | Cuenta corta (valor) |
Recuento de bits | 3 bits | 5 bits |
Átomo | 0-1, 7 | 0-23 |
Marcador de rotura | 7 | 31 |
Codificación de campo corto
Recuento de bytes | 1 byte (encabezado del elemento de datos CBOR) | Variable | |
---|---|---|---|
Estructura | Tipo mayor | Conteo corto | Valor |
Recuento de bits | 3 bits | 5 bits | 8 bits × variable |
Átomo | 0-1, 7 | 24-27 | 8, 16, 32 o 64 bits |
Cuerda | 2-3 | 0-23 | contar × 8 bits |
Artículos | 4-5 | 0-23 | contar × artículos / pares |
Etiqueta | 6 | 0-23 | un item |
Codificación de campo largo
Recuento de bytes | 1 byte (encabezado del elemento de datos CBOR) | 1, 2, 4 u 8 bytes | Variable | |
---|---|---|---|---|
Estructura | Tipo mayor | Conteo corto (24-27) | Recuento extendido (longitud de la carga útil) | Valor |
Recuento de bits | 3 bits | 5 bits | 8, 16, 32 o 64 bits | 8 bits × variable |
Cuerda | 2-3 | 24-27 | Hasta 2 64 −1 | contar × 8 bits |
Artículos | 4-5 | 24-27 | Hasta 2 64 −1 | contar × artículos / pares |
Etiqueta | 6 | 24-27 | Etiqueta, hasta 2 64 −1 | un item |
Enteros (tipos 0 y 1)
Para enteros, el campo de recuento es el valor; no hay carga útil. El tipo 0 codifica enteros positivos o sin signo, con valores de hasta 2 64 −1. El tipo 1 codifica enteros negativos, con un valor de −1 − count, para valores de −2 64 a −1.
Cadenas (tipos 2 y 3)
Los tipos 2 y 3 tienen un campo de recuento que codifica la longitud en bytes de la carga útil. El tipo 2 es una cadena de bytes no estructurada. El tipo 3 es una cadena de texto UTF-8 .
Una cuenta corta de 31 indica una cadena de longitud indefinida. A esto le siguen cero o más cadenas de longitud definida del mismo tipo, terminadas por un byte de marcador de "ruptura". El valor del artículo es la concatenación de los valores de los artículos adjuntos. No se permiten elementos de un tipo diferente o cadenas de longitud indefinida anidadas. Las cadenas de texto deben estar bien formadas individualmente; Los caracteres UTF-8 no se pueden dividir en elementos.
Matrices y mapas (tipos 4 y 5)
El tipo 4 tiene un campo de recuento que codifica el número de elementos siguientes, seguido de esa cantidad de elementos. No es necesario que todos los elementos sean del mismo tipo; algunos lenguajes de programación llaman a esto una "tupla" en lugar de una "matriz".
Alternativamente, se puede usar una codificación de longitud indefinida con un conteo corto de 31. Esto continúa hasta un byte de marcador de "ruptura" de 255. Debido a que los elementos anidados también pueden usar la codificación indefinida, el analizador debe emparejar los marcadores de ruptura con los bytes de encabezado de longitud indefinida correspondientes.
El tipo 5 es similar pero codifica un mapa (también llamado diccionario o matriz asociativa) de pares clave / valor. En este caso, el recuento codifica el número de pares de elementos. Si se utiliza la codificación de longitud indefinida, debe haber un número par de elementos antes del byte de marcador de "interrupción".
Etiqueta semántica (tipo 6)
Una etiqueta semántica es otro tipo atómico para el que el recuento es el valor, pero también tiene una carga útil (un solo elemento siguiente), y los dos se consideran un elemento en, por ejemplo, una matriz o un mapa.
El número de etiqueta proporciona información de tipo adicional para el siguiente elemento, más allá de lo que puede proporcionar el tipo principal de 3 bits. Por ejemplo, una etiqueta de 1 indica que el siguiente número es un valor de tiempo de Unix . Una etiqueta de 2 indica que la siguiente cadena de bytes codifica un bignum sin firmar . Una etiqueta de 32 indica que la siguiente cadena de texto es un URI como se define en RFC 3986 . RFC 8746 define las etiquetas 64–87 para codificar matrices homogéneas de valores enteros o de punto flotante de tamaño fijo como cadenas de bytes.
La etiqueta 55799 está asignada para significar "Siguen datos CBOR". Esta es una no-d9 d9 f7
operación semántica , pero permite que los bytes de etiqueta correspondientes se antepongan a un archivo CBOR sin afectar su significado. Estos bytes pueden usarse como un " número mágico " para distinguir el comienzo de los datos CBOR.
Los valores de etiqueta todos unos 0xffff, 0xffffffff y 0xffffffffffffffff están reservados para indicar la ausencia de una etiqueta en una biblioteca de decodificación CBOR; nunca deberían aparecer en un flujo de datos.
El pseudoelemento de marcador de rotura puede no ser la carga útil de una etiqueta.
Especial / flotante (tipo 7)
Este tipo principal se utiliza para codificar varios valores especiales que no encajan en las otras categorías. Sigue las mismas reglas de tamaño de codificación que los otros tipos atómicos (0, 1 y 6), pero el campo de recuento se interpreta de manera diferente.
Los valores 20-23 se utilizan para codificar los valores especiales falso, verdadero, nulo e indefinido . Los valores 0-19 no están definidos actualmente.
Un conteo corto de 24 indica que sigue un conteo extendido de 1 byte que se puede usar en el futuro para codificar valores especiales adicionales. Para simplificar la decodificación, es posible que los valores 0–31 no se codifiquen de esta forma. Ninguno de los valores 32-255 está definido actualmente.
Los recuentos cortos de 25, 26 o 27 indican que un siguiente campo de recuento extendido debe interpretarse como un valor de punto flotante IEEE (big-endian) de 16, 32 o 64 bits . Estos son los mismos tamaños que un recuento extendido, pero se interpretan de manera diferente. En particular, para todos los demás tipos principales, un recuento extendido de 2 bytes de 0x1234 y un recuento extendido de 4 bytes de 0x00001234 son exactamente equivalentes. Este no es el caso de los valores de coma flotante.
Los conteos cortos 28-30 están reservados, como para todos los demás tipos principales.
Una cuenta corta de 31 codifica el marcador especial de "interrupción" que termina una codificación de longitud indefinida. Esto está relacionado, pero es diferente, al uso con otros tipos principales donde un conteo corto de 31 comienza una codificación de longitud indefinida. Esto no es un elemento y puede que no aparezca en una carga útil de longitud definida.
Registro de etiquetas semánticas
IANA ha creado el registro de etiquetas CBOR, ubicado en https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml . El registro debe contener esta plantilla.
Tipo de etiqueta semántica | Distancia | Plantilla | |||
---|---|---|---|---|---|
Elemento de datos | Descripción semántica (forma corta) | Punto de contacto | Descripción de semántica (URL) | ||
Acciones estándar | 0-23 | Requerido | Requerido | N / A | N / A |
Se requiere especificación | 24-255 | Requerido | Requerido | N / A | N / A |
Primero en llegar, primero en ser servido | 256–18446744073709551615 | Requerido | Requerido | Requerido | La descripción es opcional. La URL puede apuntar a un borrador de Internet o una página web. |
https://www.rfc-editor.org/rfc/rfc8949.html#name-cbor-tags-registry
Implementaciones
Nombre | Autor principal | Idioma | Licencia | Fuente | Observaciones | |
---|---|---|---|---|---|---|
QCBOR | Laurence Lundblade | C | MIT | https://github.com/laurencelundblade/QCBOR | ||
cbor-js | Patrick Gansterer | JavaScript | MIT | https://github.com/paroga/cbor-js | ||
nodo-cbor | Joe Hildebrand | JavaScript | MIT | https://github.com/hildjj/node-cbor | ||
CBOREncode | Pavel Gulbin | PHP | PHP | https://github.com/2tvenom/CBOREncode | ||
cbor-php | Florent Morselli | PHP | MIT | https://github.com/Spomky-Labs/cbor-php | ||
cbor | Faye Amacker | Ir | MIT | https://github.com/fxamacker/cbor | Seguro y rápido, etiquetas CBOR, float64 / 32/16, detección de clave de mapa duplicado, API es codificación / json + toarray & keyasint struct tags, Canonical CBOR, CTAP2, fuzz probado. | |
cbor | Pavel Gulbin | Ir | WTFPL | https://github.com/2tvenom/cbor | ||
cbor_go | Brian Olson | Ir | APL 2.0 | https://github.com/brianolson/cbor_go | ||
go-codec | Ugorji Nwoke | Ir | MIT | https://godoc.org/github.com/ugorji/go/codec | También maneja JSON, MsgPack y BinC. | |
serde_cbor | Pyfisch | Oxido | MIT o APL 2.0 | https://github.com/pyfisch/cbor | ||
cbor-codec | Toralf Wittner | Oxido | MPL 2.0 | https://twittner.gitlab.io/cbor-codec/cbor/ | ||
SwiftCBOR | [email protected] | Rápido | Deslicencia | https://github.com/myfreeweb/SwiftCBOR | ||
CBOR.jl | Saurav Sachidanand | Julia | MIT | https://github.com/saurvs/CBOR.jl | ||
Lua-CBOR | Kim Alvefur | Lua | MIT | https://www.zash.se/lua-cbor.html | ||
org.conman.cbor | Sean Conner | Lua | LGPL-3 | https://github.com/spc476/CBOR | ||
cbor_py | Brian Olson | Pitón | APL 2.0 | https://github.com/brianolson/cbor_py | ||
flynn | Fritz Conrad Grimpen | Pitón | MIT | https://github.com/fritz0705/flynn | ||
cbor2 | Alex Grönholm | Pitón | MIT | https://github.com/agronholm/cbor2 | ||
CBOR :: Gratis | Felipe Gasper | Perl | Artístico y GPL | https://metacpan.org/pod/CBOR::Free | ||
CBOR :: PP | Felipe Gasper | Perl | Artístico y GPL | https://metacpan.org/pod/CBOR::PP | ||
CBOR :: XS | Marc Lehmann | Perl | GPL-3 | https://metacpan.org/pod/CBOR::XS | ||
cbor-ruby | Sadayuki Furuhashi Carsten Bormann | Rubí | APL 2.0 | https://github.com/cabo/cbor-ruby | ||
libcbor-ruby | Pavel Kalvoda | Rubí | MIT | https://github.com/PJK/libcbor-ruby | Vinculante a libcbor. | |
cbor-erlang | Jihyun Yu | Erlang | Cláusula BSD-3 | https://github.com/yjh0502/cbor-erlang | ||
excbor | Carsten Bormann | Elixir | No especificado, pregúntale al autor | https://github.com/cabo/excbor | ||
CBOR | R. Kyle Murphy | Haskell | LGPL-3 | https://github.com/orclev/CBOR | ||
borc | Joe Hildebrand Friedel Ziegelmayer | JavaScript | MIT | https://github.com/dignifiedquire/borc | Bifurcación de nodo-cbor. | |
borc-refs | Joe Hildebrand Friedel Ziegelmayer Sandro Hawke | JavaScript | MIT | https://github.com/sandhawke/borc-refs | Horquilla de borc. | |
CBOR | Peter Occil | C# | Software de dominio público | https://github.com/peteroupc/CBOR | También maneja JSON. | |
Dahomey.Cbor | Michaël Catanzariti | C# | Licencia MIT | https://github.com/dahomey-technologies/Dahomey.Cbor | ||
Jackson | Tatu Saloranta | Java | APL-2.0 | https://github.com/FasterXML/jackson-dataformats-binary/tree/master/cbor | También maneja otros formatos. | |
cbor-java | Constantin Rack | Java | APL-2.0 | https://github.com/c-rack/cbor-java | ||
jacob | JW Janssen | Java | APL-2.0 | https://github.com/jawi/jacob | ||
kotlinx.serialization | JetBrains | Kotlin | APL-2.0 | https://github.com/Kotlin/kotlinx.serialization | Soporta multiplataforma | |
cn-cbor | Joe Hildebrand Carsten Bormann | C | MIT | https://github.com/cabo/cn-cbor | ||
cbor-cpp | Stanislav Ovsyannikov | C ++ | APL-2.0 | https://github.com/naphaso/cbor-cpp | ||
cppbor | David Preece | C ++ | BSD | https://github.com/rantydave/cppbor | Utiliza variantes de C ++ 17. | |
libcbor | Pavel Kalvoda | C | MIT | https://github.com/PJK/libcbor | ||
tinycbor | Intel | C | MIT | https://github.com/01org/tinycbor | ||
NanoCBOR | Koen Zandberg | C | LGPL | https://github.com/bergzand/NanoCBOR | Utilizado por RIOT-OS | |
cbor-d | Andrey Penechko | D | Impulsar 1.0 | https://github.com/MrSmith33/cbor-d | ||
clj-cbor | Greg mira | Clojure | Deslicencia | https://github.com/greglook/clj-cbor | ||
JSON para C ++ moderno | Niels Lohmann | C ++ | MIT | https://github.com/nlohmann/json | También maneja JSON y MsgPack. | |
borabora | Christoph Engelbert | Java | APL-2.0 | https://github.com/noctarius/borabora | ||
lua-ConciseSerialization | François Perrad | Lua | MIT | https://web.archive.org/web/20170322112326/https://fperrad.github.io/lua-ConciseSerialization/ | ||
flunn | Fritz Conrad Grimpen Sokolov Yura | Pitón | MIT | https://pypi.python.org/pypi/flunn | ||
cbor-qt | Anton Dutov | C ++ | Dominio publico | https://github.com/anton-dutov/cbor-qt | ||
QCborValue | Proyecto Qt | C ++ | LGPL | https://doc.qt.io/qt-5/qcborvalue.html | Parte del marco Qt desde la versión 5.12 | |
cbor11 | Jakob Varmose Bentzen | C ++ | Dominio publico | https://github.com/jakobvarmose/cbor11 | ||
cborcpp | Alex Nekipelov | C ++ | MIT | https://github.com/nekipelov/cborcpp | ||
Pez de colores | Vincent Lascaux | C ++ | MIT | https://github.com/OneNoteDev/GoldFish | ||
Biblioteca-Arduino-Cbor | Juanjo Tara | C ++ | APL-2.0 | https://github.com/jjtara/Library-Arduino-Cbor | ||
cborg | Duncan Coutts | Haskell | Cláusula BSD-3 | https://github.com/well-typed/cborg | ||
cbor | Steve Hamblett | Dardo | MIT | https://github.com/shamblett/cbor | ||
taladrador | Mathias Doenitz | Scala | MPL 2.0 | https://github.com/sirthias/borer | También maneja JSON. | |
nim_cbor | Emery Hemingway | Nim | MIT | https://git.sr.ht/~ehmry/nim_cbor | ||
copón | Nathaniel McCallum Mark Bestavros Equipo Enarx | Oxido | Apache 2.0 | https://github.com/enarx/ciborium | ||
cbor | Paulo Moura | Logtalk | Apache 2.0 | https://github.com/LogtalkDotOrg/logtalk3/tree/master/library/cbor | Parte de la distribución de Logtalk; también se puede utilizar desde Prolog |
Ver también
- Comparación de formatos de serialización de datos binarios
Referencias
- ^ "CBOR - Representación concisa de objetos binarios | Descripción general" .
- ^ "CoAP - Protocolo de aplicación restringido | Descripción general" .
- ^ "Proyecto FIDO2" . Alianza FIDO . Consultado el 11 de mayo de 2018 .
enlaces externos
- Herramienta en línea para convertir de CBOR binario a representación textual y viceversa.