tropy 0.1.3

Entropy viewer for the command line
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
115

extern crate structopt;

use structopt::StructOpt;

use std::fs::File;
use std::io;
use std::io::{BufRead, BufReader, Read, Write};
use std::process::exit;
use tropy::colour::{Hsl, Rgb};
use tropy::Calculator;

/// Read bytes from file or stdin and calculate the Shannon entropy for chunks of a fixed size.
/// Then display it colour-coded in the terminal or write it to stdout as csv.
#[derive(Debug, StructOpt)]
struct Tropy {
    #[structopt(
        name = "input",
        help = "File to be read for input or \'-\' to use open stdin"
    )]
    file: String,
    #[structopt(
        long = "bytes",
        default_value = "1024",
        help = "The number of bytes to be read for each entropy calculation"
    )]
    bytes: u32,
    #[structopt(
        long = "csv",
        help = "Output as csv to stdout instead of using color-coding on the terminal.\nFormats as: <startbyte>;<entropy>"
    )]
    csv: bool,
}

fn main() {
    let cfg = Tropy::from_args();
    let mut r: Box<dyn BufRead> = {
        if cfg.file.eq("-") {
            let s = io::stdin();
            eprintln!("* Using stdin for input");
            let r = BufReader::with_capacity(2048usize, s);
            Box::new(r)
        } else {
            let s = match File::open(&cfg.file) {
                Ok(s) => s,
                Err(e) => {
                    eprintln!("Opening file failed with: {}", e);
                    exit(e.raw_os_error().unwrap_or(1))
                }
            };
            eprintln!("* Using {} for input", cfg.file);
            let r = BufReader::with_capacity(2048usize, s);
            Box::new(r)
        }
    };

    let chunksize = cfg.bytes as usize;
    let mut buf = vec![0u8; chunksize];
    let mut c = Calculator::new();
    let mut chunknum = 0usize;

    eprintln!("* Using chunks of {}bytes", chunksize);

    if !cfg.csv {
        // show colormap
        eprint!("* Color Scale: Entropy 0 "); // 25 chars

        let colormap_hue_start = 2.0 / 3.0;
        let colormap_hue_end = 1.0;
        let colormap_width = 80 - (25 + 2);
        let step = (colormap_hue_end - colormap_hue_start) / colormap_width as f64;

        (0..colormap_width)
            .map(|i| i as f64 * step + colormap_hue_start)
            .for_each(|hue| {
                eprint!(
                    "{}",
                    Rgb::from(Hsl {
                        h: hue * 360.0,
                        s: 1.0,
                        l: 0.5
                    })
                    .fg("█")
                )
            });

        eprint!(" 1"); // 2 chars
    } else {
        // use raw data
        eprintln!("Outputting raw data as csv in the format <startbyte>;<entropy/byte>");
        println!("\"start\";\"entropy\"");
    }

    while r
        .read_exact(&mut buf[..])
        .and_then(|_| c.write(&buf[..]))
        .is_ok()
    {
        let e = c.entropy();

        if !cfg.csv {
            if chunknum % 80 == 0 {
                println!();
            }
            // scale entropy to bits (i.e. value/8)
            // i.e. perfectly uniform data would have an entropy of 1 (i.e. 8bits/byte)
            let h = 240.0 + e / 8.0 * 120.0;
            print!("{}", Rgb::from(Hsl { h, s: 1.0, l: 0.5 }).fg("█"));
        } else {
            // output as csv
            println!("{};{:.6}", chunknum * chunksize, e);
        }

        chunknum += 1;
    }
}