bash
$ cargo install anevicon
``` anevicon 1.1.0 Temirkhan Myrzamadi gymmasssorla@gmail.com An UDP-based server stress-testing tool, written in Rust.
USAGE:
anevicon [FLAGS] [OPTIONS] --receiver
FLAGS: -d, --debug Enable the debugging mode -h, --help Prints help information -V, --version Prints version information
OPTIONS:
--display-periodicity --test-duration option. [default:
18446744073709551615]
-r, --receiver --packet-length together.
--send-periodicity --packets-count option. [default: 64years
64hours 64secs]
-n, --test-name
For more information see https://github.com/Gymmasssorla/anevicon. ```
All you need is to provide the testing server address, which consists of an IP address and a port number, separated by the colon character. By default, all sending sockets will have your local address:
```bash
$ anevicon --receiver 93.184.216.34:80 ```
Using the IP spoofing technique, hackers can protect their bandwidth from server response messages and hide their real IP address. You can imitate it via the --sender command-line option, as described below:
```bash
$ anevicon --receiver 93.184.216.34:80 --sender 93.184.216.34:80 ```
Note that the command above might not work on your system due to the security reasons. To make your test deterministic, there are two end conditions called --duration and --packets (a test duration and a packets count, respectively):
```bash
$ anevicon --receiver 93.184.216.34:80 --test-duration 3min --packets-count 7000 ```
Note that the test below will end when, and only when one of two specified end conditions become true. And what is more, you can specify a global packet length in bytes:
```bash
$ anevicon --receiver 93.184.216.34:80 --packet-length 4092 ```
By default, Anevicon will generate a random set of bytes which will be used as a sending packet. In some kinds of UDP-based tests, packet content makes sense, and this is how you can specify it using the --file option:
```bash
$ anevicon --receiver 93.184.216.34:80 --send-file message.txt ```
To specify a custom output file for all notifications, warnings, and errors, there is one more option called --output. Note that all debugging information will still be written to a terminal.
```bash
$ anevicon --receiver 93.184.216.34:80 --output out.txt ```
Wait 7 seconds, and then start to test using the Axl Rose name, displaying summaries after every 400 packets, wait 270 macroseconds between sending two packets, and exit with an error if time to send a packet is longer than 200 milliseconds:
```bash
$ anevicon --receiver 93.184.216.34:80 --wait 7s --display-periodicity 400 --send-periodicity 270us --send-timeout 200ms --test-name "Axl Rose" ```
Enter this text to your Cargo.toml file:
toml
[dependencies]
anevicon_core = "*"
And this one to your src/main.rs source:
```rust
use std::net::UdpSocket;
use std::num::NonZeroUsize;
use aneviconcore::summary::TestSummary; use aneviconcore::testing::{execute, HandleErrorResult};
fn main() { // Setup the socket connected to the example.com domain let socket = UdpSocket::bind("0.0.0.0:0").expect("Cannot setup the socket"); socket .connect("93.184.216.34:80") .expect("Cannot connect the socket to example.com");
let mut summary = TestSummary::default();
// Finally, execute a test that will send 100000 packets
// each containing 32768 bytes.
execute(
&socket,
&vec![0; 32768],
NonZeroUsize::new(100000).unwrap(),
&mut summary,
|error| panic!("{}", error),
);
println!(
"The total minutes passed: {}",
summary.time_passed().as_secs() / 60
);
} ```
For more details see the documentation.
The goal of Anevicon is to produce the maximum possible (for the attacking system) load on the specified target address. Thereby, this DOES NOT MEAN that Anevicon will break ABSOLUTELY ANY SERVER while running on your computer.
Despite the fact that Anevicon is heavily tested both automatically and manually, does not mean that the author is responsible for any bug in his work. The program comes with ABSOLUTELY NO WARRANTY, see the license disclaimer.
Temirkhan Myrzamadi <gymmasssorla@gmail.com> (the author)