hashstream 0.1.0

A simple utility to hash stdin and return results on stdout
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

# hashstream

A combined streaming hasher.

Hashstream is designed for needing multiple different hash types from a single stream / file simultaneously.

Hashstream does not perform any file IO on its own, it only reads and writes to stdio. You must pipe `|` or `<` redirect input to hashstream for processing.

Useful for coordinating systems that provide different hashtypes for stored blobs.

All hash types and library usage has associated tests, verify operation with `cargo test`

# Usage

` dd if=/dev/zero bs=4M count=250 status=progress | hashstream --sha256 `

` hashstream --all < /home/user/somefile.dat `

```
Usage: hashstream [OPTIONS]

Options:
      --all          Enable all hash types, can not be used with any other hash type flag [DEFAULT]
      --sha256       SHA2-256
      --sha3-256     SHA3-256
      --sha1         SHA1
      --crc32-iso    CRC_32_ISO_HDLC
      --crc32-posix  CRC_32_CKSUM
      --crc32-xfer   CRC_32_XFER
      --blake256     Blake2b256
      --blake512     Blake2b512
      --blake3       Blake3
      --md5          MD5
  -h, --help         Print help
  -V, --version      Print version

```


Or, as a library within your own code (see main.rs)

```rust

use hashstream::{CRC32TYPE, HashType, Hashes};

~~~

        let hash_types = [
            HashType::CRC32(CRC32TYPE::CKSUM),
            HashType::CRC32(CRC32TYPE::ISO),
            HashType::CRC32(CRC32TYPE::XFER),
            HashType::SHA256,
            HashType::SHA3_256,
            HashType::BLAKE256,
            HashType::BLAKE512,
            HashType::BLAKE3,
            HashType::SHA1,
            HashType::MD5,
        ];
        // Also accepts a vec of HashType for runtime determination
        let mut hashes = Hashes::new(&hash_types);

        // Anything impl AsRef<[u8]>
        hashes.digest("HashStream2025");

        // Returns a Vec of HashReturn, which can each convert into
        //   an Arc<[u8]> with .into_bytes()
        //   or to lowercase hex with .as_hex()
        //   Optionally use hashstream::u8_array_to_upper_hex_string(&hashreturn.into_bytes())
        //   if uppercase hex is preferred
        let ret = hashes.complete();

~~~

```

# TODO:

 - Multithreading? Maybe higher performance for multiple hashes at same time? 
 - More hash types? idk what else may be useful
 - Passthrough processing? Maybe output hashes to stderr or socket / named pipe?
 - More perf tuning? Is faster than `*sum` utils on Arch for me, but slower under Alma and MacOS...
 - Polynym binary? i.e. like busybox, selects set of hashes based on binary / link name?
 - Other output encoding options? Uppercase hex, base64, etc?
 - Binary release?