Struct MD4_Generic

Source

pub struct MD4_Generic<const N: usize = 4, const H0: u32 = 1732584193, const H1: u32 = 4023233417, const H2: u32 = 2562383102, const H3: u32 = 271733878, const ROUND: usize = 48, const K0: u32 = 0, const K1: u32 = 1518500249, const K2: u32 = 1859775393, const R00: u32 = 3, const R01: u32 = 7, const R02: u32 = 11, const R03: u32 = 19, const R10: u32 = 3, const R11: u32 = 5, const R12: u32 = 9, const R13: u32 = 13, const R20: u32 = 3, const R21: u32 = 9, const R22: u32 = 11, const R23: u32 = 15> { /* private fields */ }

Expand description

A MD4 message-digest algorithm that lossily compresses data of arbitrary length into a 128-bit hash value, and its flexible variants that allows you to develop your own MD4-based hash algorithms

§Introduction

MD4 was designed by Ronald Rivest who is one of the inventors of RSA asymmetric cryptographic algorithm. MD4 was invented in 1990. It was specified in 1992 as RFC 1320. This module provides not only the official MD4 but also its expanded versions which is implemented with the name MD4_Generic. MD4 uses the Merkle–Damgård construction.

§Vulnerability

The security of MD4 has been severely compromised. Today, MD4 is not recommended for serious cryptographic purposes anymore. So, NIST also does not include MD4 in their list of recommended hashes for password storage. DO NOT USE MD4 FOR SERIOUS CRYPTOGRAPHIC PURPOSES AT ALL! If you need to use a hash algorithm for serious cryptographic purposes, you are highly recommended to use SHA-2 or SHA-3 hash algorithm, for example, instead of MD4.

§Use of MD4 and their variants

Though MD4 and its variants are lack of cryptographic security, MD4 and its variants can be still used for non-cryptograpic purposes such as:

Generating small number of IDs
Integrity test in some collision-free situations
Storing passwords with limited security
Key generation
Study of hash algorithms
Cryptanalysis Research to find the weakness of MD4 and Merkle-Damgard construction which MD2, MD4, MD5, SHA0, SHA1, and all SHA2 family use

§Generic Parameters

You can create your own expanded version of MD4 by changing the generic parameters N, H0 ~ H3, ROUND, K0 ~ K2, R00 ~ R03, R10 ~ R13, and R20 ~ R23.

N : the size of output. N cannot be 0 or greater than 4. If N is 4, the output is 128 bits, while if N is 1, the output is 32 bits.
H0 ~ H3 : the initial hash values, four u32 values. The default values of H0, H1, H2, and H3 are 0x67452301, 0xefcdab89, 0x98badcfe, and 0x10325476, respectively (in little endian representation).
ROUND : the number of rounds. The default value of it is 48 (= 16 * 3).
K0 ~ K2 : the added values in hashing process, three u32 values. The default values of K0, K1, and K2 are 0x00000000, 0x5A827999, and 0x6ED9EBA1, respectively (in little endian representation). 0x5A827999 is a 32-bit constant of the square root of 2 in little endian prepresentation. 0x6ED9EBA1 is a 32-bit constant of the square root of 3 in little endian prepresentation.
R00 ~ R03, R10 ~ R13, and R20 ~ R23 : the amounts of rotate left in the hashing process. The default values of R00, R01, R02, and R03 are 3, 7, 11, and 19, respectively. The default values of R10, R11, R12, and R13 are 3, 5, 9, and 13, respectively. The default values of R20, R11, R12, and R23 are 3, 9, 11, and 15, respecively.

About the parameters and their default values, read more

§Security of your own expanded version

Your own algrorithm based on MD4 may be stronger or weaker than official MD4. Unless you seriously checked the cryptographic security of your own algorithms, it is hard to assume that your own alogrithms are stronger than the official MD4.

§Reference

§Quick Start

In order to use the module MD4, you don’t have to import (or use) cryptocol::hash::md4::* directly because the module cryptocol::hash::md4 is re-exported. All you have to do is only import MD4, MD4_Expanded, MD4_Generic_HR_fixed and/or MD4_Generic in the module cryptocol::hash. Example 1 shows how to import structs MD4, MD4_Expanded, MD4_Generic_HR_fixed and/or MD4_Generic. Plus, what you have to know is these. All the types (or structs) are the specific versions of MD4_Generic. Actually, MD4 is a specific version of MD4_Expanded. MD4_Expanded and MD4_Generic_HR_fixed are specific versions of MD4_Generic.

§Example 1

use cryptocol::hash::MD4;
use cryptocol::hash::MD4_Expanded;
use cryptocol::hash::MD4_Generic_HR_fixed;
use cryptocol::hash::MD4_Generic;

Then, you create MD4 object by the method MD4::new(). Now, you are ready to use all provided methods to hash any data. If you want to hash a string, for example, you can use the method digest_str(). Then, the MD4 object that you created will contain its hash value. You can use the macro println!(), for instance, to print on a commandline screen by println!("{}", hash) where hash is the MD4 object. Example 2 shows how to use MD4 struct quickly.

§Example 2 for MD4

use std::string::*;
use cryptocol::hash::MD4;
let mut hash = MD4::new();
 
let mut txt = "";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.get_hash_value_in_string(), "31D6CFE0D16AE931B73C59D7E0C089C0");
 
let txt_stirng = String::from("A");
hash.digest_string(&txt_stirng);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt_stirng, hash);
assert_eq!(hash.to_string(), "D5EF20EEB3F75679F86CF57F93ED0FFE");
 
let txt_array = ['W' as u8, 'o' as u8, 'w' as u8];
hash.digest_array(&txt_array);
println!("Msg =\t\"{:?}\"\nHash =\t{}\n", txt_array, hash);
assert_eq!(hash.get_hash_value_in_string(), "6407C0E728DA762A04924ADFE630974C");
 
txt = "This data is 26-byte long.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.to_string(), "4F4A24D124B996BEA395344419F9A06B");
 
txt = "The unit of data length is not byte but bit.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.get_hash_value_in_string(), "9DE35D8FCF68E74867FFB63F28625ABE");
 
txt = "I am testing MD4 for the data whose length is sixty-two bytes.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.to_string(), "3A9F1487472B3A4315E0C90DC5CB3A2E");
 
txt = "I am testing MD4 for the message which is sixty-four bytes long.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.get_hash_value_in_string(), "6CDB5B2BFF823A4A7B23675180EB7BEF");
 
txt = "I am testing MD4 for the case data whose length is more than sixty-four bytes is given.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}", txt, hash);
assert_eq!(hash.to_string(), "56771653687981390B0EB2A7D0A40DBB");

Example 3 shows how to use quickly MD4_Expanded which is the expanded version of MD4.

§Example 3 for MD4_Expanded

use std::string::*;
use cryptocol::hash::MD4_Expanded;
 
type MyMD4 = MD4_Expanded<4, 0x1111_1111, 0x4444_4444, 0x8888_8888, 0xffff_ffff, 96>;
let mut hash = MyMD4::new();
 
let mut txt = "";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.get_hash_value_in_string(), "13892AE087B903E5EC030A51E1BC720A");
 
let txt_stirng = String::from("A");
hash.digest_string(&txt_stirng);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt_stirng, hash);
assert_eq!(hash.to_string(), "0C0BE1B8893E47C005D95C69234141E9");
 
let txt_array = ['W' as u8, 'o' as u8, 'w' as u8];
hash.digest_array(&txt_array);
println!("Msg =\t\"{:?}\"\nHash =\t{}\n", txt_array, hash);
assert_eq!(hash.get_hash_value_in_string(), "17545CEB681C5B848234A557C5957AA7");
 
txt = "This data is 26-byte long.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.to_string(), "70F3EA1DCDE46C65868DC0937E374433");
 
txt = "The unit of data length is not byte but bit.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.get_hash_value_in_string(), "640B4635ED76F6574FC30AB233B74712");
 
txt = "I am testing MD4_Expanded for the data of the length 62 bytes.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.to_string(), "B0D18D969B99F4BF48365449AF82EAFB");
 
txt = "I am testing MD4_Expanded for the message which is 64 byte-long.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}\n", txt, hash);
assert_eq!(hash.get_hash_value_in_string(), "2D4ADABC3504B4A1B98FCCBFC48145AE");
 
txt = "I am testing MD4_Expanded for the case data whose length is more than 64 bytes is given.";
hash.digest_str(txt);
println!("Msg =\t\"{}\"\nHash =\t{}", txt, hash);
assert_eq!(hash.to_string(), "26E5336E4D863BBAD6347918CE6DBAF5");

§Big-endian issue

It is just experimental for Big Endian CPUs. So, you are not encouraged to use it for Big Endian CPUs for serious purpose. Only use this crate for Big-endian CPUs with your own full responsibility.

§A Simple but Useful Application using cryptocol

The following is the source code of the commandline MD4 hash value extractor using the struct MD4 of this module. You can get the hash value from a text or a file. The following source code assumes its executable file name will be “md4_app”. You can find all the examples including the following source code in the folder “examples” of this crate.

use std::{ io, env, fs };
use std::io::BufRead;
use std::convert::From;
use cryptocol::hash::MD4;
 
type HASH = MD4;
 
fn main()
{
    let args: Vec<String> = env::args().collect();
    if args.len() < 3
    {
        help();
        return;
    }
 
    let arg = &args[1][..];
    match arg
    {
        "--text" | "-t" =>  { get_hash_value_from_text(&args[2][..]); },
        "--file" | "-f" =>  { get_hash_value_from_file(&args[2][..]); },
        "--check" | "-c" => { check_files(&args[2][..]) },
        _ =>  { help(); },
    }
}
 
fn get_hash_value_from_text(txt: &str)
{
    let mut hash = HASH::new();
    hash.digest_str(txt);
    println!("Hash value:\t{}", hash.get_hash_value_in_string());
}
 
fn get_hash_value_from_file(file: &str)
{
    if let Ok(contents) = fs::read(file)
    {
        let mut hash = HASH::new();
        hash.digest_vec(&contents);
        println!("Hash value:\t{}", hash.get_hash_value_in_string());
    }
    else
    {
        println!("File Error!");
    }
}
 
fn check_files(file_list: &str)
{
    let mut reader;
    match fs::File::open(file_list)
    {
        Ok(file) => {
                reader = io::BufReader::new(file);
                let mut line = String::new();
                while let Ok(n) = reader.read_line(&mut line)
                {
                    if n == 0
                        { break; }
                    let txt = line.trim();
                    if txt.chars().nth(0).unwrap() == '#'
                    { 
                        line.clear();
                        continue;
                    }
                    let elem: Vec<&str> = txt.split_whitespace().collect();
                    let item = elem[0];
                    let h = String::from(elem[1]).to_uppercase();
                    if let Ok(contents) = fs::read(item)
                    {
                        let mut hash = HASH::new();
                        hash.digest_vec(&contents);
                        if hash.to_string() == h
                            { println!("{} ---> OK", item); }
                        else
                            { println!("{} ---> Corrupted", item); }
                    }
                    line.clear();
                }
            },
        _ => {
                println!("File open error");
                return;
            }
    }
}
 
fn help()
{
    println!("This is an MD4 hash value extractor from a text or a file, using cryptocol.");
    println!("Usage: md4_app <option> <source>");
    println!("options       description");
    println!("--text, -t    : <source> is a text to get a hash code.");
    println!("                The text should be enclosed by ' or \".");
    println!("--file, -f    : <source> is the name of the file to get a hash code.");
    println!("--check, -c   : <source> is the name of the file that contains pairs");
    println!("                of file and its hash code.");
    println!("--help, -h    : print this help message on screen\n");
    println!("Examples:");
    println!("\tmd4_app -t 'How are you doing?'");
    println!("\tmd4_app -f linuxmint-21.3-cinnamon-64bit.iso");
    println!("\tmd4_app -c CHECKSUM");
}

Struct MD4_Generic Copy item path

§Introduction

§Vulnerability

§Use of MD4 and their variants

§Generic Parameters

§Security of your own expanded version

§Reference

§Quick Start

§Example 1

§Example 2 for MD4

§Example 3 for MD4_Expanded

§Big-endian issue

§A Simple but Useful Application using cryptocol

Implementations§

pub fn new() -> Self

§Output

§Initialization

§Example 1 for MD4

§For more examples,

pub fn digest(&mut self, message: *const u8, length_in_bytes: u64)

§Features

§Arguments

§Counterpart Methods

§Example 1 for MD4

§For more examples,

pub fn digest_str(&mut self, message: &str)

§Features

§Argument

§Counterpart Methods

§Example 1 for MD4

§For more examples,

pub fn digest_string(&mut self, message: &String)

§Features

§Argument

§Counterpart Methods

§Example 1 for MD4

§For more examples,

pub fn digest_array<T, const M: usize>(&mut self, message: &[T; M])where T: SmallUInt + Copy + Clone + Display + Debug + ToString,

§Features

§Argument

§Counterpart Methods

§Example 1 for MD4

§For more examples,

pub fn digest_vec<T>(&mut self, message: &Vec<T>)where T: SmallUInt + Copy + Clone + Display + Debug + ToString,

§Features

§Argument

§Counterpart Methods

§Example 1 for MD4

§For more examples,

pub fn ruminate(&mut self, n: usize, message: *const u8, length_in_bytes: u64)

§Arguments

§Origin

§Features

§Security Issue

§For more examples,

pub fn ruminate_str(&mut self, n: usize, message: &str)

§Arguments

§Origin

§Features

§Security Issue

§For more examples,

pub fn ruminate_string(&mut self, n: usize, message: &String)

§Arguments

§Origin

§Features

§Security Issue

§For more examples,

pub fn ruminate_array<T, const M: usize>(&mut self, n: usize, message: &[T; M])where T: SmallUInt + Copy + Clone,

§Arguments

§Origin

§Features

§Security Issue

§For more examples,

pub fn ruminate_vec<T>(&mut self, n: usize, message: &Vec<T>)where T: SmallUInt + Copy + Clone,

§Arguments

§Origin

§Features

§Security Issue

§For more examples,

pub fn get_hash_value(&self, hash_value: *mut u8, length: usize)

Struct MD4_Generic

pub fn digest_array<T, const M: usize>(&mut self, message: &[T; M])
where T: SmallUInt + Copy + Clone + Display + Debug + ToString,

pub fn digest_vec<T>(&mut self, message: &Vec<T>)
where T: SmallUInt + Copy + Clone + Display + Debug + ToString,

pub fn ruminate_array<T, const M: usize>(&mut self, n: usize, message: &[T; M])
where T: SmallUInt + Copy + Clone,

pub fn ruminate_vec<T>(&mut self, n: usize, message: &Vec<T>)
where T: SmallUInt + Copy + Clone,

pub fn put_hash_value_in_array<T, const M: usize>(&self, out: &mut [T; M])
where T: SmallUInt + Copy + Clone + Display + Debug + ToString,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,