Coroutines-driven. Finshir uses coroutines (also called lightweight threads) instead of ordinary threads, which lets you open many more connections with fewer system resources.
Generic. Unlike other Low & Slow utilities, Finshir lets you transmit arbitrary data sets over the TCP protocol. It may be partial HTTP headers, empty spaces, and so on.
Written in Rust. How you can see, all the logic is written completely in Rust, which means that it leverages bare-metal performance and high-level safety (no SIGSEGV, SIGILL, and other "funny" stuff).
bash
$ cargo install finshir
bash
$ git clone https://github.com/Gymmasssorla/finshir.git
$ cd finshir
$ cargo build --release
The easiest way to run Finshir on your system is to download the pre-compiled binaries from the existing releases, which doesn't require any external software (unlike the two previous approaches).
If you care about performance, please consider using the RUSTFLAGS="-C target_cpu=native" environmental variable which tells the compiler to use accelerated instructions which are specific to your CPU.
``` finshir 1.0.0 Temirkhan Myrzamadi gymmasssorla@gmail.com A coroutines-driven Low & Slow traffic sender, written in Rust
USAGE:
finshir [FLAGS] [OPTIONS] --receiver
FLAGS: -h, --help Prints help information --use-tls Use a TLS connection instead of the ordinary TCP protocol. It might be used to test HTTPS-based services. -V, --version Prints version information
OPTIONS:
--connect-periodicity man
strftime to see the format specification [default: %X]
--failed-count
When a coroutine finished sending all portions, it reconnects its socket
and starts sending them again.
-r, --receiver <SOCKET-ADDRESS> A receiver of generator traffic, specified as an IP address (or a domain
name) and a port number, separated by a colon
-d, --test-duration <TIME-SPAN> A whole test duration, after which all spawned coroutines will stop their
work [default: 64years 64hours 64secs]
--text-report <FILENAME> A file to which the program will generate a human-readable report (also
called a "total summary") before exiting
-v, --verbosity <LEVEL> Enable one of the possible verbosity levels. The zero level doesn't print
anything, and the last level prints everything.
Note that specifying the 4 and 5 verbosity levels might decrease
performance, do it only for debugging. [default: 3] [possible values: 0,
1, 2, 3, 4, 5]
-w, --wait <TIME-SPAN> A waiting time span before test execution used to prevent a launch of an
erroneous (unwanted) test [default: 5secs]
--write-periodicity <TIME-SPAN> A time interval between writing data portions. This option can be used to
modify test intensity [default: 30secs]
--write-timeout <TIME-SPAN> If a timeout is reached and a data portion wasn't sent, the program will
retry the operation later [default: 10secs]
--xml-report <FILENAME> A file to which an XML report (also called a "total summary") will be
generated before exiting
By default, Finshir generates 100 empty spaces as data portions. If you want to override this behaviour, consider using
the --portions-file option.
After test execution, you always receive a report (statistics about connections, transmissions, etc). If none of --xml-
report, --text-report, --json-report is specified, your terminal will be used.
For more information see https://github.com/Gymmasssorla/finshir. ```
The following command spawns 1000 coroutines, each trying to establish a new TCP connection. When connections are established, it sends empty spaces every 30 seconds, thereby order a server to wait as long as it can:
```bash
$ finshir --receiver=google.com:80 ```
Low & Slow techniques assume to be VERY SLOW, which means that you typically send a couple of bytes every N seconds. For instance, Finshir uses the 30 seconds interval by default, but it's modifiable as well:
```bash
$ finshir --receiver=google.com:80 --write-periodicity=1min ```
The default number of parallel connections is 1000. However, you can modify this limit using the --connections option, but be sure that you system is able to handle such amount of file descriptors:
```bash
$ sudo ulimit -n 17015
$ finshir --receiver=google.com:80 --connections=17000 ```
By default, Finshir generates 100 empty spaces as data portions to send. You can override this behaviour by specifying your custom messages as a file, consisting of a single JSON array. This example is focused on Google:
```bash
--portions-file$ finshir --receiver=google.com:80 --portions-file=files/google.json ```
Consider specifying a custom verbosity level from 0 to 5 (inclusively), which is done by the --verbosity option. There is also the --date-time-format option which tells Finshir to use your custom date-time format.
```bash
$ finshir --receiver=google.com:80 --date-time-format="%F" --verbosity=5 ```
Most of web servers today use the HTTPS protocol instead of HTTP, which is based on TLS. Since v0.2.0, Finshir has functionality to connect through TLS using the --use-tls flag.
```bash
$ finshir --receiver=google.com:443 --use-tls ```
Report is a set of statistics variables like a total number of connections established, a total number of failed transmissions and so on. There is three options for this: --xml-report, --json-report, and --text-report:
```bash
$ finshir --receiver=google.com:80 --json-report=report.json ```
What means "at the end"? Well, Finshir will generate a report for you either if allotted time expires or if you cancel the process by Ctrl-C. You can look at the report examples in the /files folder:
(files/report.json)
json
{
"connections": {
"failed": "0",
"successful": "683",
"total": "683"
},
"time": {
"test-duration": "9s 897ms 561us 209ns",
"test-start": "Mon, 27 May 2019 10:20:27 -0000"
},
"total-bytes-sent": "683",
"total-errors": "0",
"transmissions": {
"failed": "0",
"successful": "683",
"total": "683"
}
}
(files/report.xml)
xml
<?xml version="1.0" encoding="UTF-8"?>
<finshir-report>
<total-bytes-sent>1534</total-bytes-sent>
<total-errors>0</total-errors>
<time>
<test-start>Mon, 27 May 2019 10:18:57 -0000</test-start>
<test-duration>38s 807ms 453us 842ns</test-duration>
</time>
<connections>
<successful>1000</successful>
<failed>0</failed>
<total>1000</total>
</connections>
<transmissions>
<successful>1534</successful>
<failed>0</failed>
<total>1534</total>
</transmissions>
</finshir-report>
(files/report.txt)
```
****** FINSHIR REPORT ******
Total bytes sent: 2000
Total errors: 0
Test start: Mon, 27 May 2019 10:21:02 -0000 Test duration: 56s 29ms 777us 950ns
Successful connections: 1000 Failed connections: 0 Total connections: 1000
Successful transmissions: 2000 Failed transmissions: 0 Total transmissions: 2000
```
If none of the options above has been specified, Finshir prints a report right to your terminal. That is, you can just run a test, cancel it later, and see the results which you can easily save. Perfect!
You are always welcome for any contribution to this project! But before you start, you should read the appropriate document to know about the preferred development process and the basic communication rules.
Finshir was developed as a means of testing stress resistance of web servers, and not for hacking, that is, the author of the project IS NOT RESPONSIBLE for any damage caused by your use of his program.
Temirkhan Myrzamadi <gymmasssorla@gmail.com> (the author)