wolfcose 0.1.0

Safe Rust API for wolfSSL wolfCOSE.
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#![allow(missing_docs)]

use wolfcose::{
    Algorithm, AlgorithmClass, AlgorithmUse, CoseKeyBuilder, CoseKeyView, Curve, KeyType,
    SymmetricKey,
};

#[test]
fn key_builder_and_symmetric_accessors_are_covered() {
    let symmetric = SymmetricKey::new([1u8; 16])
        .with_algorithm(Algorithm::A128GCM)
        .with_kid(b"sym");
    assert_eq!(symmetric.material(), &[1u8; 16]);
    assert_eq!(symmetric.algorithm(), Some(Algorithm::A128GCM));
    assert_eq!(symmetric.kid(), Some(&b"sym"[..]));
    let key = symmetric.into_cose_key().unwrap();
    let view = CoseKeyView::from_key(&key);
    assert_eq!(view.key_type, KeyType::SYMMETRIC);
    assert_eq!(view.curve, Curve::from_id(0));
    assert_eq!(view.symmetric_len, Some(16));

    let key = CoseKeyBuilder::new()
        .key_type(KeyType::EC2)
        .algorithm(Algorithm::ES256)
        .curve(Curve::P256)
        .kid(b"ec2")
        .has_private(false)
        .build()
        .unwrap();
    let view = CoseKeyView::from_key(&key);
    assert_eq!(view.key_type, KeyType::EC2);
    assert_eq!(view.algorithm, Algorithm::ES256);
    assert_eq!(view.curve, Curve::P256);
    assert_eq!(view.kid, b"ec2");
    assert!(!view.has_private);
}

#[test]
fn algorithm_and_key_type_metadata_cover_remaining_variants() {
    for algorithm in [
        Algorithm::ES256,
        Algorithm::ES384,
        Algorithm::ES512,
        Algorithm::EDDSA,
        Algorithm::PS256,
        Algorithm::PS384,
        Algorithm::PS512,
        Algorithm::ML_DSA_44,
        Algorithm::ML_DSA_65,
        Algorithm::ML_DSA_87,
    ] {
        assert_eq!(algorithm.class(), AlgorithmClass::Signature);
        assert!(algorithm.is_signing());
        assert_eq!(algorithm.key_bits_hint(), None);
    }

    for (algorithm, bits) in [
        (Algorithm::A192GCM, 192),
        (Algorithm::A256GCM, 256),
        (Algorithm::CHACHA20_POLY1305, 256),
        (Algorithm::AES_CCM_16_64_128, 128),
        (Algorithm::AES_CCM_16_64_256, 256),
        (Algorithm::AES_CCM_64_64_128, 128),
        (Algorithm::AES_CCM_64_64_256, 256),
        (Algorithm::AES_CCM_16_128_128, 128),
        (Algorithm::AES_CCM_16_128_256, 256),
        (Algorithm::AES_CCM_64_128_128, 128),
        (Algorithm::AES_CCM_64_128_256, 256),
    ] {
        assert!(algorithm.is_encryption());
        assert_eq!(algorithm.key_bits_hint(), Some(bits));
    }

    for (algorithm, bits) in [
        (Algorithm::HMAC384, 384),
        (Algorithm::HMAC512, 512),
        (Algorithm::AES_MAC_128_64, 128),
        (Algorithm::AES_MAC_256_64, 256),
        (Algorithm::AES_MAC_128_128, 128),
        (Algorithm::AES_MAC_256_128, 256),
    ] {
        assert!(algorithm.is_mac());
        assert_eq!(algorithm.key_bits_hint(), Some(bits));
    }

    for algorithm in [
        Algorithm::A128KW,
        Algorithm::A192KW,
        Algorithm::A256KW,
        Algorithm::DIRECT,
        Algorithm::ECDH_ES_HKDF_256,
        Algorithm::ECDH_ES_HKDF_512,
        Algorithm::ECDH_SS_HKDF_256,
        Algorithm::ECDH_SS_HKDF_512,
        Algorithm::ECDH_ES_A128KW,
        Algorithm::ECDH_ES_A192KW,
        Algorithm::ECDH_ES_A256KW,
    ] {
        assert!(algorithm.is_key_management());
    }

    assert_eq!(Algorithm::UNSET.class(), AlgorithmClass::Unknown);
    assert_eq!(Algorithm::A128GCM.iv_len_hint(), Some(12));
    assert_eq!(Algorithm::HMAC256.iv_len_hint(), None);
    assert_eq!(AlgorithmUse::Encrypt, AlgorithmUse::Encrypt);
    assert_eq!(
        KeyType::from_id(KeyType::SYMMETRIC.id()),
        KeyType::SYMMETRIC
    );
    assert_eq!(KeyType::OKP.id(), wolfcose::raw::WOLFCOSE_KTY_OKP as i32);
    assert_eq!(KeyType::EC2.id(), wolfcose::raw::WOLFCOSE_KTY_EC2 as i32);
    assert_eq!(KeyType::RSA.id(), wolfcose::raw::WOLFCOSE_KTY_RSA as i32);
    assert_eq!(Curve::from_id(Curve::P256.id()), Curve::P256);
    assert_eq!(Curve::P384.id(), wolfcose::raw::WOLFCOSE_CRV_P384 as i32);
    assert_eq!(Curve::P521.id(), wolfcose::raw::WOLFCOSE_CRV_P521 as i32);
    assert_eq!(
        Curve::ED25519.id(),
        wolfcose::raw::WOLFCOSE_CRV_ED25519 as i32
    );
    assert_eq!(Curve::ED448.id(), wolfcose::raw::WOLFCOSE_CRV_ED448 as i32);
}