oxicrypto-hash 0.1.0

Pure Rust hash implementations for OxiCrypto (SHA-2, SHA-3, BLAKE3)
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Large-input sanity tests for hash functions.
//!
//! These tests verify that hash functions handle 1 MiB inputs without
//! panicking and produce non-trivial (non-zero) output. They do not check
//! against a known digest value (which would require recomputing offline)
//! but confirm both correctness invariants:
//!   1. The output is non-zero.
//!   2. The streaming and one-shot APIs agree for large inputs.

use oxicrypto_core::{Hash, StreamingHash};
use oxicrypto_hash::{
    Blake3, Blake3Streaming, Sha256, Sha256Streaming, Sha384, Sha384Streaming, Sha512,
    Sha512Streaming,
};

const MIB: usize = 1024 * 1024;
const FILL_BYTE: u8 = 0x42;

#[test]
fn sha256_1mib_nonzero() {
    let data = vec![FILL_BYTE; MIB];
    let mut out = [0u8; 32];
    Sha256
        .hash(&data, &mut out)
        .expect("sha256 1MiB hash failed");
    assert_ne!(out, [0u8; 32], "SHA-256 of 1 MiB must be non-zero");
}

#[test]
fn sha256_1mib_streaming_matches_oneshot() {
    let data = vec![FILL_BYTE; MIB];

    let mut oneshot_out = [0u8; 32];
    Sha256
        .hash(&data, &mut oneshot_out)
        .expect("sha256 one-shot failed");

    // Feed as two 512 KiB chunks
    let half = MIB / 2;
    let mut streamer = Sha256Streaming::new();
    StreamingHash::update(&mut streamer, &data[..half]);
    StreamingHash::update(&mut streamer, &data[half..]);
    let mut stream_out = [0u8; 32];
    StreamingHash::finalize(streamer, &mut stream_out).expect("sha256 streaming finalize failed");

    assert_eq!(
        oneshot_out, stream_out,
        "SHA-256: streaming and one-shot must agree for 1 MiB input"
    );
}

#[test]
fn sha384_1mib_nonzero() {
    let data = vec![FILL_BYTE; MIB];
    let mut out = [0u8; 48];
    Sha384
        .hash(&data, &mut out)
        .expect("sha384 1MiB hash failed");
    assert_ne!(out, [0u8; 48], "SHA-384 of 1 MiB must be non-zero");
}

#[test]
fn sha384_1mib_streaming_matches_oneshot() {
    let data = vec![FILL_BYTE; MIB];

    let mut oneshot_out = [0u8; 48];
    Sha384
        .hash(&data, &mut oneshot_out)
        .expect("sha384 one-shot failed");

    let half = MIB / 2;
    let mut streamer = Sha384Streaming::new();
    StreamingHash::update(&mut streamer, &data[..half]);
    StreamingHash::update(&mut streamer, &data[half..]);
    let mut stream_out = [0u8; 48];
    StreamingHash::finalize(streamer, &mut stream_out).expect("sha384 streaming finalize failed");

    assert_eq!(
        oneshot_out, stream_out,
        "SHA-384: streaming and one-shot must agree for 1 MiB input"
    );
}

#[test]
fn sha512_1mib_nonzero() {
    let data = vec![FILL_BYTE; MIB];
    let mut out = [0u8; 64];
    Sha512
        .hash(&data, &mut out)
        .expect("sha512 1MiB hash failed");
    assert_ne!(out, [0u8; 64], "SHA-512 of 1 MiB must be non-zero");
}

#[test]
fn sha512_1mib_streaming_matches_oneshot() {
    let data = vec![FILL_BYTE; MIB];

    let mut oneshot_out = [0u8; 64];
    Sha512
        .hash(&data, &mut oneshot_out)
        .expect("sha512 one-shot failed");

    let half = MIB / 2;
    let mut streamer = Sha512Streaming::new();
    StreamingHash::update(&mut streamer, &data[..half]);
    StreamingHash::update(&mut streamer, &data[half..]);
    let mut stream_out = [0u8; 64];
    StreamingHash::finalize(streamer, &mut stream_out).expect("sha512 streaming finalize failed");

    assert_eq!(
        oneshot_out, stream_out,
        "SHA-512: streaming and one-shot must agree for 1 MiB input"
    );
}

#[test]
fn blake3_1mib_nonzero() {
    let data = vec![FILL_BYTE; MIB];
    let mut out = [0u8; 32];
    Blake3
        .hash(&data, &mut out)
        .expect("blake3 1MiB hash failed");
    assert_ne!(out, [0u8; 32], "BLAKE3 of 1 MiB must be non-zero");
}

#[test]
fn blake3_1mib_streaming_matches_oneshot() {
    let data = vec![FILL_BYTE; MIB];

    let mut oneshot_out = [0u8; 32];
    Blake3
        .hash(&data, &mut oneshot_out)
        .expect("blake3 one-shot failed");

    let half = MIB / 2;
    let mut streamer = Blake3Streaming::new();
    StreamingHash::update(&mut streamer, &data[..half]);
    StreamingHash::update(&mut streamer, &data[half..]);
    let mut stream_out = [0u8; 32];
    StreamingHash::finalize(streamer, &mut stream_out).expect("blake3 streaming finalize failed");

    assert_eq!(
        oneshot_out, stream_out,
        "BLAKE3: streaming and one-shot must agree for 1 MiB input"
    );
}