Struct in_toto::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 hex encoded value of sha256(cjson(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 hex encoded hash value.

SIG_VALUE is a hex encoded signature value.

METADATA_DESCRIPTION is the following:

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

SignedMetadata

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

SIGNATURE is:

{
  "keyid": 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, ...]
  "roles": {
    "root": ROLE_DESCRIPTION,
    "snapshot": ROLE_DESCRIPTION,
    "targets": ROLE_DESCRIPTION,
    "timestamp": ROLE_DESCRIPTION
  }
}

ROLE_DESCRIPTION is the following:

{
  "threshold": NATURAL_NUMBER,
  "keyids": [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
    ...
  },
}

ROLE is a string,

PATH is a string.

TimestampMetadata

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

Trait Implementations

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 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 json = json!({
    "o": {
        "a": [1, 2, 3],
        "s": "string",
        "n": 123,
        "t": true,
        "f": false,
        "0": null,
    },
});
let mut buf = Vec::new();
Json::to_writer(&mut buf, &json).unwrap();
assert_eq!(
    &String::from_utf8(buf).unwrap(),
    r#"{"o":{"0":null,"a":[1,2,3],"f":false,"n":123,"s":"string","t":true}}"#
);

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();

fn from_slice<T>(slice: &[u8]) -> Result<T> where
    T: DeserializeOwned, 

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

impl Debug for Json

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

Formats the value using the given formatter.

impl PartialEq<Json> for Json

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl StructuralPartialEq for Json