secure-json-parse 0.1.1

prototype-poisoning-safe JSON parsing of untrusted input
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! The protoAction x constructorAction truth table. The input holds both a
//! `constructor.prototype` nesting and a `__proto__` key.

mod common;

use common::*;
use secure_json_parse::{parse, Action, Error, Options};
use serde_json::json;

fn opts(proto: Action, ctor: Action) -> Options {
    Options::default()
        .proto_action(proto)
        .constructor_action(ctor)
}

#[test]
fn remove_remove_strips_both() {
    let v = parse(MIXED, &opts(Action::Remove, Action::Remove))
        .unwrap()
        .unwrap();
    assert_eq!(v, json!({"a": 5, "b": 6}));
}

#[test]
fn ignore_remove_keeps_proto() {
    let v = parse(MIXED, &opts(Action::Ignore, Action::Remove))
        .unwrap()
        .unwrap();
    let expected: serde_json::Value =
        serde_json::from_str(r#"{ "a": 5, "b": 6, "__proto__": { "x": 7 } }"#).unwrap();
    assert_eq!(v, expected);
}

#[test]
fn remove_ignore_keeps_constructor() {
    let v = parse(MIXED, &opts(Action::Remove, Action::Ignore))
        .unwrap()
        .unwrap();
    let expected: serde_json::Value =
        serde_json::from_str(r#"{ "a": 5, "b": 6, "constructor":{"prototype":{"bar":"baz"}} }"#)
            .unwrap();
    assert_eq!(v, expected);
}

#[test]
fn ignore_ignore_keeps_both() {
    let v = parse(MIXED, &opts(Action::Ignore, Action::Ignore))
        .unwrap()
        .unwrap();
    let raw: serde_json::Value = serde_json::from_str(MIXED).unwrap();
    assert_eq!(v, raw);
}

#[test]
fn error_ignore_throws() {
    assert!(matches!(
        parse(MIXED, &opts(Action::Error, Action::Ignore)),
        Err(Error::ForbiddenProperty)
    ));
}

#[test]
fn ignore_error_throws() {
    assert!(matches!(
        parse(MIXED, &opts(Action::Ignore, Action::Error)),
        Err(Error::ForbiddenProperty)
    ));
}

#[test]
fn error_error_throws() {
    assert!(matches!(
        parse(MIXED, &opts(Action::Error, Action::Error)),
        Err(Error::ForbiddenProperty)
    ));
}

#[test]
fn mixed_nested_constructor_then_proto_errors() {
    // A plain constructor key plus a nested __proto__ errors by default.
    assert!(matches!(
        parse(MIXED_NESTED, &Options::default()),
        Err(Error::ForbiddenProperty)
    ));
}