Struct tuf::interchange::Json

pub struct Json {}

JSON data interchange.

Schema

This doesn't use JSON Schema because that specification language is rage inducing. Here's something else instead.

Common Entities

NATURAL_NUMBER is an integer in the range [1, 2**32).

EXPIRES is an ISO-8601 date time in format YYYY-MM-DD'T'hh:mm:ss'Z'.

KEY_ID is the base64url encoded value of sha256(spki(pub_key)).

PUB_KEY is the following:

{
  "type": KEY_TYPE,
  "scheme": SCHEME,
  "value": PUBLIC
}

PUBLIC is a base64url encoded SubjectPublicKeyInfo DER public key.

KEY_TYPE is a string (either rsa or ed25519).

SCHEME is a string (either ed25519, rsassa-pss-sha256, or rsassa-pss-sha512

HASH_VALUE is a base64url encoded hash value.

SIG_VALUE is a base64url encoded signature value.

METADATA_DESCRIPTION is the following:

{
  "version": NATURAL_NUMBER,
  "size": NATURAL_NUMBER,
  "hashes": {
    HASH_ALGORITHM: HASH_VALUE
    ...
  }
}

SignedMetadata

{
  "signatures": [SIGNATURE],
  "signed": SIGNED
}

SIGNATURE is:

{
  "key_id": KEY_ID,
  "signature": SIG_VALUE
}

SIGNED is one of:

• RootMetadata
• SnapshotMetadata
• TargetsMetadata
• TimestampMetadata

The the elements of signatures must have unique key_ids.

RootMetadata

{
  "type": "root",
  "version": NATURAL_NUMBER,
  "expires": EXPIRES,
  "keys": [PUB_KEY, ...]
  "root": ROLE_DESCRIPTION,
  "snapshot": ROLE_DESCRIPTION,
  "targets": ROLE_DESCRIPTION,
  "timestamp": ROLE_DESCRIPTION
}

ROLE_DESCRIPTION is the following:

{
  "threshold": NATURAL_NUMBER,
  "key_ids": [KEY_ID, ...]
}

SnapshotMetadata

{
  "type": "snapshot",
  "version": NATURAL_NUMBER,
  "expires": EXPIRES,
  "meta": {
    META_PATH: METADATA_DESCRIPTION
  }
}

META_PATH is a string.

TargetsMetadata

{
  "type": "timestamp",
  "version": NATURAL_NUMBER,
  "expires": EXPIRES,
  "targets": {
    TARGET_PATH: TARGET_DESCRIPTION
    ...
  },
  "delegations": DELEGATIONS
}

DELEGATIONS is optional and is described by the following:

{
  "keys": [PUB_KEY, ...]
  "roles": {
    ROLE: DELEGATION,
    ...
  }
}

DELEGATION is:

{
  "name": ROLE,
  "threshold": NATURAL_NUMBER,
  "terminating": BOOLEAN,
  "key_ids": [KEY_ID, ...],
  "paths": [PATH, ...]
}

ROLE is a string,

PATH is a string.

TimestampMetadata

{
  "type": "timestamp",
  "version": NATURAL_NUMBER,
  "expires": EXPIRES,
  "snapshot": METADATA_DESCRIPTION
}

Trait Implementations

impl Debug for Json

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Clone for Json

fn clone(&self) -> Json

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq for Json

fn eq(&self, __arg_0: &Json) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl DataInterchange for Json

type RawData = Value

The type of data that is contained in the signed portion of metadata.

fn extension() -> &'static str

assert_eq!(Json::extension(), "json");

fn canonicalize(raw_data: &Self::RawData) -> Result<Vec<u8>>

let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
let raw = Json::from_reader(jsn).unwrap();
let out = Json::canonicalize(&raw).unwrap();
assert_eq!(out, br#"{"baz":"quux","foo":"bar"}"#);

fn deserialize<T>(raw_data: &Self::RawData) -> Result<T> where
    T: DeserializeOwned, 

#[derive(Deserialize, Debug, PartialEq)]
struct Thing {
   foo: String,
   bar: String,
}

let jsn = json!({"foo": "wat", "bar": "lol"});
let thing = Thing { foo: "wat".into(), bar: "lol".into() };
let de: Thing = Json::deserialize(&jsn).unwrap();
assert_eq!(de, thing);

fn serialize<T>(data: &T) -> Result<Self::RawData> where
    T: Serialize, 

#[derive(Serialize)]
struct Thing {
   foo: String,
   bar: String,
}

let jsn = json!({"foo": "wat", "bar": "lol"});
let thing = Thing { foo: "wat".into(), bar: "lol".into() };
let se: serde_json::Value = Json::serialize(&thing).unwrap();
assert_eq!(se, jsn);

fn to_writer<W, T: Sized>(writer: W, value: &T) -> Result<()> where
    W: Write,
    T: Serialize, 

let arr = vec![1, 2, 3];
let mut buf = Vec::new();
Json::to_writer(&mut buf, &arr).unwrap();
assert!(&buf == b"[1, 2, 3]" || &buf == b"[1,2,3]");

fn from_reader<R, T>(rdr: R) -> Result<T> where
    R: Read,
    T: DeserializeOwned, 

let jsn: &[u8] = br#"{"foo": "bar", "baz": "quux"}"#;
let _: HashMap<String, String> = Json::from_reader(jsn).unwrap();