macro_toolset/
hash.rs

1//! Hash related macros
2
3// re-export const_hex
4pub use const_hex;
5
6#[macro_export]
7/// Calculate MD5 hash.
8///
9/// You should add `md-5 = "0.10"` to your `Cargo.toml`.
10///
11/// Just a shortcut for `calc_hash!(MD5: ...)`, see [`calc_hash`] for more
12/// details. Here are some examples:
13///
14/// ```rust
15/// # use macro_toolset::md5;
16/// // General usage, multiple params supported
17/// # assert_eq!(
18/// md5!("hello", "world")
19/// # .as_str(), "fc5e038d38a57032085441e7fe7010b0");
20/// // Iterator is supported
21/// # assert_eq!(
22/// md5!(ITER => ["hello", "world"])
23/// # .as_str(), "fc5e038d38a57032085441e7fe7010b0");
24/// // Uppercase
25/// # assert_eq!(
26/// md5!(UPPERCASE => "hello", "world")
27/// # .as_str(), "FC5E038D38A57032085441E7FE7010B0");
28/// // Combine them
29/// # assert_eq!(
30/// md5!(UPPERCASE; ITER => ["hello", "world"])
31/// # .as_str(), "FC5E038D38A57032085441E7FE7010B0");
32/// ```
33macro_rules! md5 {
34    ($($tt:tt)*) => {
35        $crate::calc_hash!(MD5: $($tt)*)
36    };
37}
38
39#[macro_export]
40/// Calc SHA256 hash.
41///
42/// You should add `sha2 = "0.10"` to your `Cargo.toml`.
43///
44/// Just a shortcut for `calc_hash!(SHA256: ...)`, see [`calc_hash`] for more
45/// details. Here are some examples:
46///
47/// ```rust
48/// # use macro_toolset::sha256;
49/// // General usage, multiple params supported
50/// # assert_eq!(
51/// sha256!("hello", "world")
52/// # .as_str(), "936a185caaa266bb9cbe981e9e05cb78cd732b0b3280eb944412bb6f8f8f07af");
53/// // Iterator is supported
54/// # assert_eq!(
55/// sha256!(ITER => ["hello", "world"])
56/// # .as_str(), "936a185caaa266bb9cbe981e9e05cb78cd732b0b3280eb944412bb6f8f8f07af");
57/// // Uppercase
58/// # assert_eq!(
59/// sha256!(UPPERCASE => "hello", "world")
60/// # .as_str(), "936A185CAAA266BB9CBE981E9E05CB78CD732B0B3280EB944412BB6F8F8F07AF");
61/// // Combine them
62/// # assert_eq!(
63/// sha256!(UPPERCASE; ITER => ["hello", "world"])
64/// # .as_str(), "936A185CAAA266BB9CBE981E9E05CB78CD732B0B3280EB944412BB6F8F8F07AF");
65/// ```
66macro_rules! sha256 {
67    ($($tt:tt)*) => {
68        $crate::calc_hash!(SHA256: $($tt)*)
69    };
70}
71
72#[macro_export]
73/// Calculate SHA384 hash.
74///
75/// You should add `sha2 = "0.10"` to your `Cargo.toml`.
76///
77/// Just a shortcut for `calc_hash!(SHA384: ...)`, see [`calc_hash`] for more
78/// details. Here are some examples:
79///
80/// ```rust
81/// # use macro_toolset::sha384;
82/// // General usage. Multiple params supported.
83/// # assert_eq!(
84/// sha384!("hello", "world")
85/// # .as_str(), "97982a5b1414b9078103a1c008c4e3526c27b41cdbcf80790560a40f2a9bf2ed4427ab1428789915ed4b3dc07c454bd9");
86/// // Iterator is supported
87/// # assert_eq!(
88/// sha384!(ITER => ["hello", "world"])
89/// # .as_str(), "97982a5b1414b9078103a1c008c4e3526c27b41cdbcf80790560a40f2a9bf2ed4427ab1428789915ed4b3dc07c454bd9");
90/// // Uppercase
91/// # assert_eq!(
92/// sha384!(UPPERCASE => "hello", "world")
93/// # .as_str(), "97982A5B1414B9078103A1C008C4E3526C27B41CDBCF80790560A40F2A9BF2ED4427AB1428789915ED4B3DC07C454BD9");
94/// // Combine them
95/// # assert_eq!(
96/// sha384!(UPPERCASE; ITER => ["hello", "world"])
97/// # .as_str(), "97982A5B1414B9078103A1C008C4E3526C27B41CDBCF80790560A40F2A9BF2ED4427AB1428789915ED4B3DC07C454BD9");
98/// ```
99macro_rules! sha384 {
100    ($($tt:tt)*) => {
101        $crate::calc_hash!(SHA384: $($tt)*)
102    };
103}
104
105#[macro_export]
106/// Calculate SHA512 hash.
107///
108/// You should add `sha2 = "0.10"` to your `Cargo.toml`.
109///
110/// Just a shortcut for `calc_hash!(SHA512: ...)`, see [`calc_hash`] for more
111/// details. Here are some examples:
112///
113/// ```rust
114/// # use macro_toolset::sha512;
115/// // General usage, ultiple params supported
116/// # assert_eq!(
117/// sha512!("hello", "world")
118/// # .as_str(), "1594244d52f2d8c12b142bb61f47bc2eaf503d6d9ca8480cae9fcf112f66e4967dc5e8fa98285e36db8af1b8ffa8b84cb15e0fbcf836c3deb803c13f37659a60");
119/// // Iterator is supported
120/// # assert_eq!(
121/// sha512!(ITER => ["hello", "world"])
122/// # .as_str(), "1594244d52f2d8c12b142bb61f47bc2eaf503d6d9ca8480cae9fcf112f66e4967dc5e8fa98285e36db8af1b8ffa8b84cb15e0fbcf836c3deb803c13f37659a60");
123/// // Uppercase
124/// # assert_eq!(
125/// sha512!(UPPERCASE => "hello", "world")
126/// # .as_str(), "1594244D52F2D8C12B142BB61F47BC2EAF503D6D9CA8480CAE9FCF112F66E4967DC5E8FA98285E36DB8AF1B8FFA8B84CB15E0FBCF836C3DEB803C13F37659A60");
127/// // Combine them
128/// # assert_eq!(
129/// sha512!(UPPERCASE; ITER => ["hello", "world"])
130/// # .as_str(), "1594244D52F2D8C12B142BB61F47BC2EAF503D6D9CA8480CAE9FCF112F66E4967DC5E8FA98285E36DB8AF1B8FFA8B84CB15E0FBCF836C3DEB803C13F37659A60");
131/// ```
132macro_rules! sha512 {
133    ($($tt:tt)*) => {
134        $crate::calc_hash!(SHA512: $($tt)*)
135    };
136}
137
138#[macro_export]
139/// A helper macro to get string from hash result
140///
141/// This is equivalent to `calc_hash!(...).as_str()`.
142///
143/// # Examples
144///
145/// ```
146/// # use macro_toolset::calc_hash_str;
147///
148/// // General usage. Multiple params supported.
149/// # assert_eq!(
150/// calc_hash_str!(SHA256: "hello", "world")
151/// # , "936a185caaa266bb9cbe981e9e05cb78cd732b0b3280eb944412bb6f8f8f07af");
152/// ```
153macro_rules! calc_hash_str {
154    ($($tt:tt)*) => {
155        $crate::calc_hash!($($tt)*).as_str()
156    };
157}
158
159#[macro_export]
160/// Calculate Hash.
161///
162/// Returns [`const_hex::Buffer`], you may use [`const_hex::Buffer::as_str`]
163/// to get the string, or just use with [`str_concat`](crate::str_concat).
164///
165/// # Examples
166///
167/// ```
168/// # use macro_toolset::calc_hash;
169///
170/// // General usage. Multiple params supported.
171/// # let example =
172/// calc_hash!(MD5: "hello", "world");
173/// # assert_eq!(example.as_str(), "fc5e038d38a57032085441e7fe7010b0");
174/// # let example =
175/// calc_hash!(SHA256: "hello", "world");
176/// # assert_eq!(example.as_str(), "936a185caaa266bb9cbe981e9e05cb78cd732b0b3280eb944412bb6f8f8f07af");
177/// # let example =
178/// calc_hash!(SHA384: "hello", "world");
179/// # assert_eq!(example.as_str(), "97982a5b1414b9078103a1c008c4e3526c27b41cdbcf80790560a40f2a9bf2ed4427ab1428789915ed4b3dc07c454bd9");
180/// # let example =
181/// calc_hash!(SHA512: "hello", "world");
182/// # assert_eq!(example.as_str(), "1594244d52f2d8c12b142bb61f47bc2eaf503d6d9ca8480cae9fcf112f66e4967dc5e8fa98285e36db8af1b8ffa8b84cb15e0fbcf836c3deb803c13f37659a60");
183/// // You may pass an iterator as input
184/// # let example =
185/// calc_hash!(MD5: ITER => ["hello", "world"]);
186/// # assert_eq!(example.as_str(), "fc5e038d38a57032085441e7fe7010b0");
187/// # let example =
188/// calc_hash!(SHA256: ITER => ["hello", "world"]);
189/// # assert_eq!(example.as_str(), "936a185caaa266bb9cbe981e9e05cb78cd732b0b3280eb944412bb6f8f8f07af");
190/// # let example =
191/// calc_hash!(SHA384: ITER => ["hello", "world"]);
192/// # assert_eq!(example.as_str(), "97982a5b1414b9078103a1c008c4e3526c27b41cdbcf80790560a40f2a9bf2ed4427ab1428789915ed4b3dc07c454bd9");
193/// # let example =
194/// calc_hash!(SHA512: ITER => ["hello", "world"]);
195/// # assert_eq!(example.as_str(), "1594244d52f2d8c12b142bb61f47bc2eaf503d6d9ca8480cae9fcf112f66e4967dc5e8fa98285e36db8af1b8ffa8b84cb15e0fbcf836c3deb803c13f37659a60");
196/// // Uppercase is supported
197/// # let example =
198/// calc_hash!(SHA256: UPPERCASE => "hello", "world");
199/// # assert_eq!(example.as_str(), "936A185CAAA266BB9CBE981E9E05CB78CD732B0B3280EB944412BB6F8F8F07AF");
200/// // Uppercase with iterator passed in is supported
201/// # let example =
202/// calc_hash!(SHA256: UPPERCASE; ITER => ["hello", "world"]);
203/// # assert_eq!(example.as_str(), "936A185CAAA266BB9CBE981E9E05CB78CD732B0B3280EB944412BB6F8F8F07AF");
204/// ```
205macro_rules! calc_hash {
206    (MD5: $($input_str:expr),+) => {{
207        use ::md5::Digest;
208        let mut hasher = ::md5::Md5::new();
209        $crate::calc_hash!(INTERNAL 16; hasher, $($input_str),+)
210    }};
211    (SHA256: $($input_str:expr),+) => {{
212        use ::sha2::Digest;
213        let mut hasher = ::sha2::Sha256::new();
214        $crate::calc_hash!(INTERNAL 32; hasher, $($input_str),+)
215    }};
216    (SHA384: $($input_str:expr),+) => {{
217        use ::sha2::Digest;
218        let mut hasher = ::sha2::Sha384::new();
219        $crate::calc_hash!(INTERNAL 48; hasher, $($input_str),+)
220    }};
221    (SHA512: $($input_str:expr),+) => {{
222        use ::sha2::Digest;
223        let mut hasher = ::sha2::Sha512::new();
224        $crate::calc_hash!(INTERNAL 64; hasher, $($input_str),+)
225    }};
226    (MD5: UPPERCASE => $($input_str:expr),+) => {{
227        use ::md5::Digest;
228        let mut hasher = ::md5::Md5::new();
229        $crate::calc_hash!(INTERNAL 16; UPPERCASE; hasher, $($input_str),+)
230    }};
231    (SHA256: UPPERCASE => $($input_str:expr),+) => {{
232        use ::sha2::Digest;
233        let mut hasher = ::sha2::Sha256::new();
234        $crate::calc_hash!(INTERNAL 32; UPPERCASE; hasher, $($input_str),+)
235    }};
236    (SHA384: UPPERCASE => $($input_str:expr),+) => {{
237        use ::sha2::Digest;
238        let mut hasher = ::sha2::Sha384::new();
239        $crate::calc_hash!(INTERNAL 48; UPPERCASE; hasher, $($input_str),+)
240    }};
241    (SHA512: UPPERCASE => $($input_str:expr),+) => {{
242        use ::sha2::Digest;
243        let mut hasher = ::sha2::Sha512::new();
244        $crate::calc_hash!(INTERNAL 64; UPPERCASE; hasher, $($input_str),+)
245    }};
246    (MD5: ITER => $($input_str:expr),+) => {{
247        use ::md5::Digest;
248        let mut hasher = ::md5::Md5::new();
249        $crate::calc_hash!(INTERNAL 16; ITER; hasher, $($input_str),+)
250    }};
251    (SHA256: ITER => $input_iter:expr) => {{
252        use ::sha2::Digest;
253        let mut hasher = ::sha2::Sha256::new();
254        $crate::calc_hash!(INTERNAL 32; ITER; hasher, $input_iter)
255    }};
256    (SHA384: ITER => $input_iter:expr) => {{
257        use ::sha2::Digest;
258        let mut hasher = ::sha2::Sha384::new();
259        $crate::calc_hash!(INTERNAL 48; ITER; hasher, $input_iter)
260    }};
261    (SHA512: ITER => $input_iter:expr) => {{
262        use ::sha2::Digest;
263        let mut hasher = ::sha2::Sha512::new();
264        $crate::calc_hash!(INTERNAL 64; ITER; hasher, $input_iter)
265    }};
266    (MD5: UPPERCASE; ITER => $($input_str:expr),+) => {{
267        use ::md5::Digest;
268        let mut hasher = ::md5::Md5::new();
269        $crate::calc_hash!(INTERNAL 16; UPPERCASE; ITER; hasher, $($input_str),+)
270    }};
271    (SHA256: UPPERCASE; ITER => $input_iter:expr) => {{
272        use ::sha2::Digest;
273        let mut hasher = ::sha2::Sha256::new();
274        $crate::calc_hash!(INTERNAL 32; UPPERCASE; ITER; hasher, $input_iter)
275    }};
276    (SHA384: UPPERCASE; ITER => $input_iter:expr) => {{
277        use ::sha2::Digest;
278        let mut hasher = ::sha2::Sha384::new();
279        $crate::calc_hash!(INTERNAL 48; UPPERCASE; ITER; hasher, $input_iter)
280    }};
281    (SHA512: UPPERCASE; ITER => $input_iter:expr) => {{
282        use ::sha2::Digest;
283        let mut hasher = ::sha2::Sha512::new();
284        $crate::calc_hash!(INTERNAL 64; UPPERCASE; ITER; hasher, $input_iter)
285    }};
286
287    // === INTERNAL ===
288
289    (INTERNAL $len:expr; $hasher: expr, $($input_str:expr),+) => {{
290        $($hasher.update(&($input_str));)+
291
292        let result = $hasher.finalize();
293
294        #[allow(unsafe_code)]
295        $crate::hash::const_hex::Buffer::<$len, false>::new().const_format(unsafe { &*{ (result).as_ptr() as *const [u8; $len] } })
296    }};
297    (INTERNAL $len:expr; UPPERCASE; $hasher: expr, $($input_str:expr),+) => {{
298        $($hasher.update(&($input_str));)+
299
300        let result = $hasher.finalize();
301
302        #[allow(unsafe_code)]
303        $crate::hash::const_hex::Buffer::<$len, false>::new().const_format_upper(unsafe { &*{ (result).as_ptr() as *const [u8; $len] } })
304    }};
305    (INTERNAL $len:expr; ITER; $hasher: expr, $input_iter:expr) => {{
306        for i in $input_iter {
307            $hasher.update(i);
308        }
309
310        let result = $hasher.finalize();
311        #[allow(unsafe_code)]
312        $crate::hash::const_hex::Buffer::<$len, false>::new().const_format(unsafe { &*{ (result).as_ptr() as *const [u8; $len] } })
313    }};
314    (INTERNAL $len:expr; UPPERCASE; ITER; $hasher: expr, $input_iter:expr) => {{
315        for i in $input_iter {
316            $hasher.update(i);
317        }
318
319        let result = $hasher.finalize();
320        #[allow(unsafe_code)]
321        $crate::hash::const_hex::Buffer::<$len, false>::new().const_format_upper(unsafe { &*{ (result).as_ptr() as *const [u8; $len] } })
322    }};
323}
macro_toolset/hash.rs

macro_toolset/
hash.rs
