TracNav menu
-
How To
- Setup An Experiment
-
GUI
- Overview
- Options
- Controls
- Topology
-
Agents and Variables
- Overview
- Functions
- Scripting
- Topology
- Traffic
- Attacks
- Analysis
-
Development/Extending
- Overview
- Adding GUI Panels
- Adding Agent Types
- Traffic Generation Basics
- Replay
- Harpoon
- Ping
- DNS
- HTTP
- FTP
- SSH
- IRC
- Constant Bit Rate
- Streaming Video
Traffic Generation Basics
Source and Destination Address Pools
For all traffic generators the source and destination addresses can be dynamically picked from fake ranges on each node. These fake ranges are specified in the routing? agent for the experiment. If no fake range is specified, the first IP address for the node is used.
Connection Spacing
Most traffic agents have a 'think' variable. This function will determine the time the agent will sleep before starting another network connection. Depending on the length of each connection, either specified by a data size or a time length, connections may or may not overlap. This is determined by the variables specified.
Replay
 |
The replay agent responds to object type 'REPLAY'.
| NODES(g) | set the nodes that will inject traffic from a dump file |
| file | the path to the dump file on the node |
| mult | the multiplier used by the injector to speed up or slow down replay relative to the original timestamps |
To use replay, a tcpdump file must be loaded on each node that will become the replay agent. This can be done in several ways including disk images or tarfiles. Once the file is present, the injector at each node will extract packets from the dump file based on their specified fake address ranges? or just their local address and inject them into the network. It will also install a filter to drop all traffic destined for these addresses so that the node does not reply with ICMP error messages.
An injector binary compiled under mingw does exist for the Windows image, however, there is no current firewall control to drop incoming traffic from the other injectors.
Harpoon
|
The harpoon agent responds to object type 'HARPOON'.
| NODES(g) | set the nodes that will become client and servers |
| cesssions | set the client sessions variable list |
| sesssions | set the server sessions variable list |
| port | set the port used by the harpoon connections |
| think | a function used to write the harpoon interconnection times list |
| sizes | a function used to write the harpoon file sizes list |
The harpoon agent groups sets up a number of nodes that use harpoon to generate TCP traffic. Each node is a client and a server using port as the server port. Harpoon uses configuration files to determine interconnection times and file sizes. These files are written dynamically using the functions provided via the think and sizes variables. Harpoon also tries to keep a certain number of sessions open on each client and on each server. These values are controlled via the csesssions and ssessions variables. These two variables can be a comma separated list of numbers. Every 60 seconds, harpoon will move to the next value in the array.
ToDo:
- destination port diversity
- separate client and server processes so nodes can be only one or the other
mytcp = scripts.Agent('HARPOON', 'h1') mytcp.Set({'NODES': 'net1 net2 net3', 'csessions': '30', 'ssessions': '4', 'port': '9090', 'think': 'expo(0.9, 1, 40)', 'sizes': 'pareto(1.4, 300, 500000)'}) mytcp.Start()
Ping
| Client |  |
| Server | |
The ping agent responds to object type 'PING'.
| NODES(g) | set the clients that are used by the agent group |
| servers(g) | set the destinations for the ping requests |
| think | a function to determine inter request times |
| sizes | not currently used |
The ping agent will periodically send an ICMP echo request to a set of servers, incrementing the ID as it goes.
myping = scripts.Agent('PING', 'ping1') myping.Set({'NODES': 'net1 net3 net4', 'servers': 'net2', 'think': 'expo(0.8, 2, 8)'}) myping.Start()
DNS
| Client | |
| Server | |
The DNS agent responds to the object type 'DNS'.
| NODES(g) | set the clients that are used by the agent group |
| servers(g) | set the destinations for the DNS requests |
| badrequests | a value of 0.0 to 1.0 that determine the change of issues a request for an unknown name |
| think | a function to determine inter request times |
| sizes | not currently used |
The DNS uses the local dig binary to make DNS requests to a set of BIND servers. It requests a single known address and a single unknown address to create valid and NXDOMAIN replies.
mydns = scripts.Agent('DNS', 'dns1') mydns.Set({'NODES': 'net2', 'servers': 'net1 net3', 'badrequests': '0.01', 'think': 'pareto(1.2, 1.2, 10)'}) mydns.Start()
HTTP
| Client | |
| Server | |
The HTTP agent responds to the object type 'HTTP'.
| NODES(g) | set the clients that are used by the agent group |
| servers(g) | set the location for the apache web servers |
| think | a function to determine inter connection times |
| sizes | a function to determine the sizes of the requested files |
The HTTP agent uses the local wget binary to make HTTP requests to a set of apache servers. The requested file is a script that allows the requester to specify the size of the returned file.
myweb = scripts.Agent('HTTP', 'http1') myweb.Set({'NODES':'net1 net2', 'servers':'net3', 'think':'minmax(0.4,0.8)', 'sizes':'pareto(1.4,2000)'}) myweb.Start()
FTP
| Client | |
| Server | |
The FTP agent responds to the object type 'FTP'.
| NODES(g) | set the clients that are used by the agent group |
| servers(g) | set the destinations for the FTP requests |
| think | a function to determine inter connection times |
| sizes | a function to determine the sizes of the requested files |
The FTP agent uses the local wget binary to make FTP requests to a set of vsftpd servers. The vsftpd binary is modified so that requests for a number (digits only, no characters) return a generated file of that size.
myftp = scripts.Agent('FTP', 'ftp1') myftp.Set({'NODES':'net1 net2', 'servers':'net3', 'think':'minmax(0.4,2)', 'sizes':'pareto(1.4,5000)'}) myftp.Start()
SSH
| Client | |
| Server | |
The SSH agent responds to the object type 'SSH'.
| NODES(g) | set the clients that are used by the agent group |
| servers(g) | set the destinations for the SSH sessions |
| think | a function to determine how long before the agent spawns another client |
| duration | a function to determine the length of each ssh session |
| typing | a function to determine the inter-key delay times for each command |
| msgtime | a function to determine time before starting another command |
| sizes | a function to determine the amount of data that is returned for each command |
The SSH agent utilizes the local OpenSSH client and daemon to open a connection from a client to a server. The agent will launch clients based on a expect script. This client will 'type' commands across the connection, each command requests a certain amount of data be returned. Once its duration is met, the client will disconnect.
myssh.Set({'NODES': 'net1 net4', 'servers': 'net3', 'think': 'minmax(350,400)', 'duration': 'minmax(300,300)', 'typing': 'minmax(0.1,0.2)', 'msgtime': 'pareto(2, 2, 20)', 'sizes': 'expo(0.9, 100, 16384)'}) myssh.Start()
IRC
| Client | |
| Server | |
The IRC agent responds to the object type 'IRC'.
| NODES(g) | set the clients for the agent group |
| servers(g) | set the nodes that will run an IRC daemon |
| think | a function to determine how long before the agent spawns another client |
| duration | a function to determine how long a client will connect for |
| msgtimes | a function to determine the amount of time a clients waiting before sending a message |
| sizes | a function to determine the amount of data that is sent in a message |
The IRC agent utilizes a python based IRC client and IRCd hybrid to create an IRC network. The servers are current single servers and do not connect to each other. The agent will launch clients that connect to one of the servers. This client will receive messages normally and periodically send messages of its own.
myirc = scripts.Agent('IRC', 'irc1') myirc.Set({'NODES': 'net1 net4', 'servers': 'net3', 'think': 'minmax(350,400)', 'duration': 'minmax(300,300)', 'msgtime': 'pareto(2, 2, 20)', 'sizes': 'expo(0.9, 100, 16384)'}) myirc.Start()
Constant Bit Rate
| Client | |
| Server | |
The constant bit rate agent responds to the object type 'CBR'.
| NODES(g) | set the clients for the agent group |
| servers(g) | set the nodes that will run a sink |
| think | a function to determine how long before the agent spawns another client |
| pktinterval | number of microseconds between packets |
| pktcount | number of packets to send in a connection |
| pktlength | size of each packet |
The constant bit rate client does as its name says, it sends a constant stream of UDP packets from one node to another.
mycbr = scripts.Agent('CBR', 'data1') mycbr.Set({'NODES': 'net1 net3 net4', 'servers': 'net2', 'think': 'minmax(240,250)', 'pktinterval': '20000', 'pktcount': '5000', 'pktlength': '100'}) mycbr.Start()
Streaming Video
| Client | |
| Server | |
The streaming video agent responds to the object type 'VIDEO'. As of version 1.2.1, you must also extract the tarfile /share/seer/seer-videodata.tgz onto any machine that you want to be a video server.
| NODES(g) | set the clients for the agent group |
| servers(g) | set the nodes that will run a video server |
| think | a function to determine how long before the agent spawns another client |
| file | one of (run1100, run660, run370) which represents the 'average' bit rate of the file |
| time | a function to determine how long the requests file will stream for |
| type | one of (rtp, udp, tcp) which represents the type of transmission to use |
The video client makes use of the Live555 video library to run a MPEG2 TS video server and clients. There are three short video clips that are run in loops to create the streamed data.
myvid = scripts.Agent('VIDEO', 'stream1') myvid.Set({'NODES': 'net2 net3 net4', 'servers': 'net1', 'think': 'minmax(100,150)', 'file': 'run1100', 'time': 'minmax(70,80)', 'type': 'rtp'}) myvid.Start()
