fast-des 0.8.0

This crate implements DES encryption and NetNTLMv1 hashing in bitsliced form. a 10x-100x improvement in speed can be achieved depending on hardware.
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

use std::{
    arch::x86_64::{__m256i, __m512i, _mm256_setzero_si256, _mm512_setzero_si512},
    env,
    sync::Arc,
    thread,
};

use fast_des::{
    benchmark::{benchmark, benchmark_parallel},
    bitsliced_des_inline_simd, bitsliced_des_inline_simd_avx_512, bitsliced_des_simd,
    bitsliced_des_simd_avx_512, bitsliced_netntlmv1_inline_simd_avx_2,
    bitsliced_netntlmv1_inline_simd_avx_512, bitsliced_netntlmv1_simd, des,
};

const KEY: u64 = 0xABCDEF1234567890;
const PLAINTEXT: u64 = 0x8877665544332211;

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        println!("Usage: fast-des.exe <benchmark_name>");
    }
    let benchmark_name = &args[1];
    start_benchmark(benchmark_name.as_str());
}

fn start_benchmark(benchmark_name: &str) {
    match benchmark_name {
        "n" | "normal" | "normal_des" => {
            benchmark("normal_des", 100_000, 10000, 1, || {
                des(PLAINTEXT, KEY);
            });
        }
        "f" | "fast" | "fast_des_simd" => {
            let mut keys = [[0x133457799BBCDFF1u64; 64]; 8];

            benchmark("fast_des_simd", 1_000_000, 10000, 64 * 8, || {
                bitsliced_des_simd(PLAINTEXT, &mut keys);
            });
        }
        "davx512" | "des_avx_512" => unsafe {
            let keys = [[0; 64]; 8];

            benchmark("des_avx_512", 10_000_000, 1_000_000, 512, || {
                bitsliced_des_simd_avx_512(&keys);
            });
        },
        "davx512i" | "des_avx_512_inline" => unsafe {
            let mut keys: [__m512i; 64] = [_mm512_setzero_si512(); 64];

            benchmark("des_avx_512_inline", 10_000_000, 1_000_000, 512, || {
                bitsliced_des_inline_simd_avx_512(&mut keys);
            });
        },
        "davx512ip" | "des_avx_512_parallel" => unsafe {
            let keys: [__m512i; 64] = [_mm512_setzero_si512(); 64];
            benchmark_parallel("des_avx_512_parallel", 10_000_000, 512, 32, move || {
                let mut keys = keys.clone();
                bitsliced_des_inline_simd_avx_512(&mut keys);
            });
        },
        "navx512i" | "netntlmv1_avx_512_inline" => unsafe {
            let mut keys: [__m512i; 64] = [_mm512_setzero_si512(); 64];

            benchmark(
                "netntlmv1_avx_512_inline",
                10_000_000,
                1_000_000,
                512,
                || {
                    bitsliced_netntlmv1_inline_simd_avx_512(&mut keys);
                },
            );
        },
        "navxi512p" | "netntlmv1_avx_512_parallel" => unsafe {
            let keys: [__m512i; 64] = [_mm512_setzero_si512(); 64];
            benchmark_parallel(
                "netntlmv1_avx_512_parallel",
                10_000_000,
                512,
                32,
                move || {
                    let mut keys = keys.clone();
                    bitsliced_netntlmv1_inline_simd_avx_512(&mut keys);
                },
            );
        },
        "navx2i" | "netntlmv1_avx_2_inline" => unsafe {
            let mut keys: [__m256i; 64] = [_mm256_setzero_si256(); 64];

            benchmark("netntlmv1_avx_2_inline", 10_000_000, 1_000_000, 512, || {
                bitsliced_netntlmv1_inline_simd_avx_2(&mut keys);
            });
        },
        "navx2ip" | "netntlmv1_avx_2_parallel" => unsafe {
            let keys: [__m256i; 64] = [_mm256_setzero_si256(); 64];
            benchmark_parallel("netntlmv1_avx_2_parallel", 10_000_000, 512, 16, move || {
                let mut keys = keys.clone();
                bitsliced_netntlmv1_inline_simd_avx_2(&mut keys);
            });
        },

        _ => {
            println!("Invalid benchmark name")
        }
    }
}