frameassembly 0.9.0

A Domain-Specific Language (DSL) for writing deterministic network traffic to .pcap files.
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
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

use alloc::vec::Vec;
use core::net::IpAddr;

/// A host definition with an IP and optional MAC address.
///
/// Syntax mapping:
/// ```frameassembly
/// HOST name { IP 1.2.3.4 MAC 00:11:22:33:44:55 }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HostDef<'a> {
    pub name: &'a str,
    pub ip: IpAddr,
    pub mac: Option<[u8; 6]>,
}

/// The direction of the packet in a template statement.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Direction {
    LeftToRight, // ->
    RightToLeft, // <-
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TcpFlag {
    Syn,
    Ack,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Protocol {
    Tcp,
    Udp,
    Snmp1,
    Snmp2,
    Snmp3,
}

/// A single frame statement inside a flow.
///
/// Syntax mapping:
/// ```frameassembly
/// client -> server TCP SYN ACK PAYLOAD "World" WAIT 10ms
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FrameStatement<'a> {
    pub caller: &'a str,
    pub dir: Direction,
    pub callee: &'a str,
    pub protocol: Protocol,
    pub src_port: Option<u16>,
    pub dst_port: Option<u16>,

    // TCP specific
    pub flags: Vec<TcpFlag>,
    pub seq: Option<u32>,
    pub ack_num: Option<u32>,
    pub win: Option<u16>,
    pub payload: Option<&'a str>,

    // SNMP specific
    pub community: Option<&'a str>,
    pub user: Option<&'a str>,
    pub oid: Option<&'a str>,
    pub sys_up_time: Option<u32>,

    pub wait: Option<u64>,
}

/// A flow definition in the form `FLOW name(arg1, arg2) { statements }`
///
/// Syntax mapping:
/// ```frameassembly
/// FLOW name(arg1, arg2) { 
///     arg1 -> arg2 TCP SYN
/// }
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FlowDef<'a> {
    pub name: &'a str,
    pub params: Vec<&'a str>,
    pub statements: Vec<FrameStatement<'a>>,
}

/// An argument passed to a flow invocation.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Argument<'a> {
    /// A simple variable reference, e.g., `my_client`
    Variable(&'a str),
}

/// A flow invocation, e.g., `tcp_handshake(my_client, google_dns)`
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TemplateInvocation<'a> {
    pub name: &'a str,
    pub args: Vec<Argument<'a>>,
}

/// A statement in the run/compile block, can be a loop or a single invocation
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RunStatement<'a> {
    /// A single template invocation directly in the block
    Invocation(TemplateInvocation<'a>),
    /// A loop block containing a count and inner invocations
    Loop(u32, Vec<TemplateInvocation<'a>>),
}

/// The root of the AST containing all assignments, flows, and the compile block.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Program<'a> {
    pub hosts: Vec<HostDef<'a>>,
    pub flows: Vec<FlowDef<'a>>,
    pub compile_block: Vec<RunStatement<'a>>,
}