tls_codec 0.4.2

A pure Rust implementation of the TLS (de)serialization
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

use tls_codec::{SerializeBytes, TlsByteVecU16, TlsByteVecU24, TlsByteVecU32, TlsByteVecU8, U24};

#[test]
fn serialize_primitives() {
    let mut v = Vec::new();
    v.append(&mut 77u8.tls_serialize().expect("Error encoding u8"));
    v.append(&mut 88u8.tls_serialize().expect("Error encoding u8"));
    v.append(&mut 355u16.tls_serialize().expect("Error encoding u16"));
    v.append(
        &mut U24::try_from(65609usize)
            .unwrap()
            .tls_serialize()
            .expect("Error encoding U24"),
    );
    let b = [77u8, 88, 1, 99, 1, 0, 73];
    assert_eq!(&b[..], &v[..]);
}

#[test]
fn serialize_var_len_vec() {
    let v = vec![9u8, 2, 98, 34, 55, 90, 54];
    let serialized = v.tls_serialize().expect("Error encoding vector");
    assert_eq!(serialized, vec![7, 9, 2, 98, 34, 55, 90, 54]);

    let serialized = Vec::<u8>::new()
        .tls_serialize()
        .expect("Error encoding vector");
    assert_eq!(serialized, vec![0x00]);
}

#[test]
fn serialize_var_len_boundaries() {
    let v = vec![99u8; 63];
    let serialized = v.tls_serialize().expect("Error encoding vector");
    assert_eq!(&serialized[0..5], &[63, 99, 99, 99, 99]);

    let v = vec![99u8; 64];
    let serialized = v.tls_serialize().expect("Error encoding vector");
    assert_eq!(&serialized[0..5], &[0x40, 64, 99, 99, 99]);

    let v = vec![99u8; 16383];
    let serialized = v.tls_serialize().expect("Error encoding vector");
    assert_eq!(&serialized[0..5], &[0x7f, 0xff, 99, 99, 99]);

    let v = vec![99u8; 16384];
    let serialized = v.tls_serialize().expect("Error encoding vector");
    assert_eq!(&serialized[0..5], &[0x80, 0, 0x40, 0, 99]);
}

#[test]
fn serialize_tls_byte_vec_u8() {
    let byte_vec = TlsByteVecU8::from_slice(&[1, 2, 3]);
    let actual_result = byte_vec
        .tls_serialize()
        .expect("Error encoding byte vector");
    assert_eq!(actual_result, vec![3, 1, 2, 3]);
}

#[test]
fn serialize_tls_byte_vec_u16() {
    let byte_vec = TlsByteVecU16::from_slice(&[1, 2, 3]);
    let actual_result = byte_vec
        .tls_serialize()
        .expect("Error encoding byte vector");
    assert_eq!(actual_result, vec![0, 3, 1, 2, 3]);
}

#[test]
fn serialize_tls_byte_vec_u24() {
    let byte_vec = TlsByteVecU24::from_slice(&[1, 2, 3]);
    let actual_result = byte_vec
        .tls_serialize()
        .expect("Error encoding byte vector");
    assert_eq!(actual_result, vec![0, 0, 3, 1, 2, 3]);
}

#[test]
fn serialize_tls_byte_vec_u32() {
    let byte_vec = TlsByteVecU32::from_slice(&[1, 2, 3]);
    let actual_result = byte_vec
        .tls_serialize()
        .expect("Error encoding byte vector");
    assert_eq!(actual_result, vec![0, 0, 0, 3, 1, 2, 3]);
}