package core:crypto/haval
Source

⌘K
Ctrl+K
or
/

    Index

    Types (1)
    Variables (1)
    Procedures (112)

    Types

    Haval_Context ¶
    Source

    Haval_Context :: struct {
	count:       [2]u32,
	fingerprint: [8]u32,
	block:       [32]u32,
	remainder:   [128]u8,
	rounds:      u32,
	hashbitlen:  u32,
	str_len:     u32,
}
    Related Procedures With Parameters

    Constants

    DIGEST_SIZE_128 ¶
    Source

    DIGEST_SIZE_128 :: 16

    DIGEST_SIZE_160 ¶
    Source

    DIGEST_SIZE_160 :: 20

    DIGEST_SIZE_192 ¶
    Source

    DIGEST_SIZE_192 :: 24

    DIGEST_SIZE_224 ¶
    Source

    DIGEST_SIZE_224 :: 28

    DIGEST_SIZE_256 ¶
    Source

    DIGEST_SIZE_256 :: 32

    VERSION ¶
    Source

    VERSION :: 1

    Variables

    PADDING ¶
    Source

    PADDING: [128]u8 = …

    Procedures

    CH2UINT ¶
    Source

    CH2UINT :: proc "contextless" (str: []u8, word: []u32) {…}

    FF_1 ¶
    Source

    FF_1 :: proc(
	x7, x6, x5, x4, x3, x2, x1, x0, w, 
	rounds:                            u32, 
) -> u32 {…}

    FF_2 ¶
    Source

    FF_2 :: proc(
	x7, x6, x5, x4, x3, x2, x1, x0, w, c, 
	rounds:                               u32, 
) -> u32 {…}

    FF_3 ¶
    Source

    FF_3 :: proc(
	x7, x6, x5, x4, x3, x2, x1, x0, w, c, 
	rounds:                               u32, 
) -> u32 {…}

    FF_4 ¶
    Source

    FF_4 :: proc(
	x7, x6, x5, x4, x3, x2, x1, x0, w, c, 
	rounds:                               u32, 
) -> u32 {…}

    FF_5 ¶
    Source

    FF_5 :: proc(
	x7, x6, x5, x4, x3, x2, x1, x0, w, c, 
	rounds:                               u32, 
) -> u32 {…}

    FPHI_1 ¶
    Source

    FPHI_1 :: proc(
	x6, x5, x4, x3, x2, x1, x0, 
	rounds:                     u32, 
) -> u32 {…}

    FPHI_2 ¶
    Source

    FPHI_2 :: proc(
	x6, x5, x4, x3, x2, x1, x0, 
	rounds:                     u32, 
) -> u32 {…}

    FPHI_3 ¶
    Source

    FPHI_3 :: proc(
	x6, x5, x4, x3, x2, x1, x0, 
	rounds:                     u32, 
) -> u32 {…}

    FPHI_4 ¶
    Source

    FPHI_4 :: proc(
	x6, x5, x4, x3, x2, x1, x0, 
	rounds:                     u32, 
) -> u32 {…}

    FPHI_5 ¶
    Source

    FPHI_5 :: proc(
	x6, x5, x4, x3, x2, x1, x0, 
	rounds:                     u32, 
) -> u32 {…}

    F_1 ¶
    Source

    F_1 :: proc "contextless" (
	x6, x5, x4, x3, x2, x1, 
	x0:                     u32, 
) -> u32 {…}

    F_2 ¶
    Source

    F_2 :: proc "contextless" (
	x6, x5, x4, x3, x2, x1, 
	x0:                     u32, 
) -> u32 {…}

    F_3 ¶
    Source

    F_3 :: proc "contextless" (
	x6, x5, x4, x3, x2, x1, 
	x0:                     u32, 
) -> u32 {…}

    F_4 ¶
    Source

    F_4 :: proc "contextless" (
	x6, x5, x4, x3, x2, x1, 
	x0:                     u32, 
) -> u32 {…}

    F_5 ¶
    Source

    F_5 :: proc "contextless" (
	x6, x5, x4, x3, x2, x1, 
	x0:                     u32, 
) -> u32 {…}

    UINT2CH ¶
    Source

    UINT2CH :: proc "contextless" (word: []u32, str: []u8, wlen: u32) {…}

    block ¶
    Source

    block :: proc(ctx: ^Haval_Context, rounds: u32) {…}

    final ¶
    Source

    final :: proc(ctx: ^Haval_Context, hash: []u8) {…}

    hash_bytes_128_3 ¶
    Source

    hash_bytes_128_3 :: proc(data: []u8) -> [16]u8 {…}
     

    hash_bytes_128_3 will hash the given input and return the computed hash

    hash_bytes_128_4 ¶
    Source

    hash_bytes_128_4 :: proc(data: []u8) -> [16]u8 {…}
     

    hash_bytes_128_4 will hash the given input and return the computed hash

    hash_bytes_128_5 ¶
    Source

    hash_bytes_128_5 :: proc(data: []u8) -> [16]u8 {…}
     

    hash_bytes_128_5 will hash the given input and return the computed hash

    hash_bytes_160_3 ¶
    Source

    hash_bytes_160_3 :: proc(data: []u8) -> [20]u8 {…}
     

    hash_bytes_160_3 will hash the given input and return the computed hash

    hash_bytes_160_4 ¶
    Source

    hash_bytes_160_4 :: proc(data: []u8) -> [20]u8 {…}
     

    hash_bytes_160_4 will hash the given input and return the computed hash

    hash_bytes_160_5 ¶
    Source

    hash_bytes_160_5 :: proc(data: []u8) -> [20]u8 {…}
     

    hash_bytes_160_5 will hash the given input and return the computed hash

    hash_bytes_192_3 ¶
    Source

    hash_bytes_192_3 :: proc(data: []u8) -> [24]u8 {…}
     

    hash_bytes_192_3 will hash the given input and return the computed hash

    hash_bytes_192_4 ¶
    Source

    hash_bytes_192_4 :: proc(data: []u8) -> [24]u8 {…}
     

    hash_bytes_192_4 will hash the given input and return the computed hash

    hash_bytes_192_5 ¶
    Source

    hash_bytes_192_5 :: proc(data: []u8) -> [24]u8 {…}
     

    hash_bytes_2DIGEST_SIZE_192_5 will hash the given input and return the computed hash

    hash_bytes_224_3 ¶
    Source

    hash_bytes_224_3 :: proc(data: []u8) -> [28]u8 {…}
     

    hash_bytes_224_3 will hash the given input and return the computed hash

    hash_bytes_224_4 ¶
    Source

    hash_bytes_224_4 :: proc(data: []u8) -> [28]u8 {…}
     

    hash_bytes_224_4 will hash the given input and return the computed hash

    hash_bytes_224_5 ¶
    Source

    hash_bytes_224_5 :: proc(data: []u8) -> [28]u8 {…}
     

    hash_bytes_224_5 will hash the given input and return the computed hash

    hash_bytes_256_3 ¶
    Source

    hash_bytes_256_3 :: proc(data: []u8) -> [32]u8 {…}
     

    hash_bytes_256_3 will hash the given input and return the computed hash

    hash_bytes_256_4 ¶
    Source

    hash_bytes_256_4 :: proc(data: []u8) -> [32]u8 {…}
     

    hash_bytes_256_4 will hash the given input and return the computed hash

    hash_bytes_256_5 ¶
    Source

    hash_bytes_256_5 :: proc(data: []u8) -> [32]u8 {…}
     

    hash_bytes_256_5 will hash the given input and return the computed hash

    hash_bytes_to_buffer_128_3 ¶
    Source

    hash_bytes_to_buffer_128_3 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_128_3 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_128_4 ¶
    Source

    hash_bytes_to_buffer_128_4 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_128_4 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_128_5 ¶
    Source

    hash_bytes_to_buffer_128_5 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_128_5 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_160_3 ¶
    Source

    hash_bytes_to_buffer_160_3 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_160_3 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_160_4 ¶
    Source

    hash_bytes_to_buffer_160_4 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_160_4 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_160_5 ¶
    Source

    hash_bytes_to_buffer_160_5 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_160_5 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_192_3 ¶
    Source

    hash_bytes_to_buffer_192_3 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_192_3 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_192_4 ¶
    Source

    hash_bytes_to_buffer_192_4 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_192_4 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_192_5 ¶
    Source

    hash_bytes_to_buffer_192_5 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_192_5 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_224_3 ¶
    Source

    hash_bytes_to_buffer_224_3 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_224_3 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_224_4 ¶
    Source

    hash_bytes_to_buffer_224_4 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_224_4 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_224_5 ¶
    Source

    hash_bytes_to_buffer_224_5 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_224_5 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_256_3 ¶
    Source

    hash_bytes_to_buffer_256_3 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_256_3 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_256_4 ¶
    Source

    hash_bytes_to_buffer_256_4 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_256_4 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_bytes_to_buffer_256_5 ¶
    Source

    hash_bytes_to_buffer_256_5 :: proc(data, hash: []u8) {…}
     

    hash_bytes_to_buffer_256_5 will hash the given input and write the computed hash into the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_file_128_3 ¶
    Source

    hash_file_128_3 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([16]u8, bool) {…}
     

    hash_file_128_3 will read the file provided by the given handle and compute a hash

    hash_file_128_4 ¶
    Source

    hash_file_128_4 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([16]u8, bool) {…}
     

    hash_file_128_4 will read the file provided by the given handle and compute a hash

    hash_file_128_5 ¶
    Source

    hash_file_128_5 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([16]u8, bool) {…}
     

    hash_file_128_5 will read the file provided by the given handle and compute a hash

    hash_file_160_3 ¶
    Source

    hash_file_160_3 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([20]u8, bool) {…}
     

    hash_file_160_3 will read the file provided by the given handle and compute a hash

    hash_file_160_4 ¶
    Source

    hash_file_160_4 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([20]u8, bool) {…}
     

    hash_file_160_4 will read the file provided by the given handle and compute a hash

    hash_file_160_5 ¶
    Source

    hash_file_160_5 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([20]u8, bool) {…}
     

    hash_file_160_5 will read the file provided by the given handle and compute a hash

    hash_file_192_3 ¶
    Source

    hash_file_192_3 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([24]u8, bool) {…}
     

    hash_file_192_3 will read the file provided by the given handle and compute a hash

    hash_file_192_4 ¶
    Source

    hash_file_192_4 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([24]u8, bool) {…}
     

    hash_file_192_4 will read the file provided by the given handle and compute a hash

    hash_file_192_5 ¶
    Source

    hash_file_192_5 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([24]u8, bool) {…}
     

    hash_file_192_5 will read the file provided by the given handle and compute a hash

    hash_file_224_3 ¶
    Source

    hash_file_224_3 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([28]u8, bool) {…}
     

    hash_file_224_3 will read the file provided by the given handle and compute a hash

    hash_file_224_4 ¶
    Source

    hash_file_224_4 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([28]u8, bool) {…}
     

    hash_file_224_4 will read the file provided by the given handle and compute a hash

    hash_file_224_5 ¶
    Source

    hash_file_224_5 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([28]u8, bool) {…}
     

    hash_file_224_5 will read the file provided by the given handle and compute a hash

    hash_file_256_3 ¶
    Source

    hash_file_256_3 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([32]u8, bool) {…}
     

    hash_file_256_3 will read the file provided by the given handle and compute a hash

    hash_file_256_4 ¶
    Source

    hash_file_256_4 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([32]u8, bool) {…}
     

    hash_file_256_4 will read the file provided by the given handle and compute a hash

    hash_file_256_5 ¶
    Source

    hash_file_256_5 :: proc(hd: os.Handle, load_at_once: bool = false) -> ([32]u8, bool) {…}
     

    hash_file_256_5 will read the file provided by the given handle and compute a hash

    hash_stream_128_3 ¶
    Source

    hash_stream_128_3 :: proc(s: io.Stream) -> ([16]u8, bool) {…}
     

    hash_stream_128_3 will read the stream in chunks and compute a hash from its contents

    hash_stream_128_4 ¶
    Source

    hash_stream_128_4 :: proc(s: io.Stream) -> ([16]u8, bool) {…}
     

    hash_stream_128_4 will read the stream in chunks and compute a hash from its contents

    hash_stream_128_5 ¶
    Source

    hash_stream_128_5 :: proc(s: io.Stream) -> ([16]u8, bool) {…}
     

    hash_stream_128_5 will read the stream in chunks and compute a hash from its contents

    hash_stream_160_3 ¶
    Source

    hash_stream_160_3 :: proc(s: io.Stream) -> ([20]u8, bool) {…}
     

    hash_stream_160_3 will read the stream in chunks and compute a hash from its contents

    hash_stream_160_4 ¶
    Source

    hash_stream_160_4 :: proc(s: io.Stream) -> ([20]u8, bool) {…}
     

    hash_stream_160_4 will read the stream in chunks and compute a hash from its contents

    hash_stream_160_5 ¶
    Source

    hash_stream_160_5 :: proc(s: io.Stream) -> ([20]u8, bool) {…}
     

    hash_stream_160_5 will read the stream in chunks and compute a hash from its contents

    hash_stream_192_3 ¶
    Source

    hash_stream_192_3 :: proc(s: io.Stream) -> ([24]u8, bool) {…}
     

    hash_stream_192_3 will read the stream in chunks and compute a hash from its contents

    hash_stream_192_4 ¶
    Source

    hash_stream_192_4 :: proc(s: io.Stream) -> ([24]u8, bool) {…}
     

    hash_stream_192_4 will read the stream in chunks and compute a hash from its contents

    hash_stream_192_5 ¶
    Source

    hash_stream_192_5 :: proc(s: io.Stream) -> ([24]u8, bool) {…}
     

    hash_stream_192_5 will read the stream in chunks and compute a hash from its contents

    hash_stream_224_3 ¶
    Source

    hash_stream_224_3 :: proc(s: io.Stream) -> ([28]u8, bool) {…}
     

    hash_stream_224_3 will read the stream in chunks and compute a hash from its contents

    hash_stream_224_4 ¶
    Source

    hash_stream_224_4 :: proc(s: io.Stream) -> ([28]u8, bool) {…}
     

    hash_stream_224_4 will read the stream in chunks and compute a hash from its contents

    hash_stream_224_5 ¶
    Source

    hash_stream_224_5 :: proc(s: io.Stream) -> ([28]u8, bool) {…}
     

    hash_stream_224_5 will read the stream in chunks and compute a hash from its contents

    hash_stream_256_3 ¶
    Source

    hash_stream_256_3 :: proc(s: io.Stream) -> ([32]u8, bool) {…}
     

    hash_stream_256_3 will read the stream in chunks and compute a hash from its contents

    hash_stream_256_4 ¶
    Source

    hash_stream_256_4 :: proc(s: io.Stream) -> ([32]u8, bool) {…}
     

    hash_stream_256_4 will read the stream in chunks and compute a hash from its contents

    hash_stream_256_5 ¶
    Source

    hash_stream_256_5 :: proc(s: io.Stream) -> ([32]u8, bool) {…}
     

    hash_stream_256_5 will read the stream in chunks and compute a hash from its contents

    hash_string_128_3 ¶
    Source

    hash_string_128_3 :: proc(data: string) -> [16]u8 {…}
     

    hash_string_128_3 will hash the given input and return the computed hash

    hash_string_128_4 ¶
    Source

    hash_string_128_4 :: proc(data: string) -> [16]u8 {…}
     

    hash_string_128_4 will hash the given input and return the computed hash

    hash_string_128_5 ¶
    Source

    hash_string_128_5 :: proc(data: string) -> [16]u8 {…}
     

    hash_string_128_5 will hash the given input and return the computed hash

    hash_string_160_3 ¶
    Source

    hash_string_160_3 :: proc(data: string) -> [20]u8 {…}
     

    hash_string_160_3 will hash the given input and return the computed hash

    hash_string_160_4 ¶
    Source

    hash_string_160_4 :: proc(data: string) -> [20]u8 {…}
     

    hash_string_160_4 will hash the given input and return the computed hash

    hash_string_160_5 ¶
    Source

    hash_string_160_5 :: proc(data: string) -> [20]u8 {…}
     

    hash_string_160_5 will hash the given input and return the computed hash

    hash_string_192_3 ¶
    Source

    hash_string_192_3 :: proc(data: string) -> [24]u8 {…}
     

    hash_string_192_3 will hash the given input and return the computed hash

    hash_string_192_4 ¶
    Source

    hash_string_192_4 :: proc(data: string) -> [24]u8 {…}
     

    hash_string_192_4 will hash the given input and return the computed hash

    hash_string_192_5 ¶
    Source

    hash_string_192_5 :: proc(data: string) -> [24]u8 {…}
     

    hash_string_192_5 will hash the given input and return the computed hash

    hash_string_224_3 ¶
    Source

    hash_string_224_3 :: proc(data: string) -> [28]u8 {…}
     

    hash_string_224_3 will hash the given input and return the computed hash

    hash_string_224_4 ¶
    Source

    hash_string_224_4 :: proc(data: string) -> [28]u8 {…}
     

    hash_string_224_4 will hash the given input and return the computed hash

    hash_string_224_5 ¶
    Source

    hash_string_224_5 :: proc(data: string) -> [28]u8 {…}
     

    hash_string_224_5 will hash the given input and return the computed hash

    hash_string_256_3 ¶
    Source

    hash_string_256_3 :: proc(data: string) -> [32]u8 {…}
     

    hash_string_256_3 will hash the given input and return the computed hash

    hash_string_256_4 ¶
    Source

    hash_string_256_4 :: proc(data: string) -> [32]u8 {…}
     

    hash_string_256_4 will hash the given input and return the computed hash

    hash_string_256_5 ¶
    Source

    hash_string_256_5 :: proc(data: string) -> [32]u8 {…}
     

    hash_string_256_5 will hash the given input and return the computed hash

    hash_string_to_buffer_128_3 ¶
    Source

    hash_string_to_buffer_128_3 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_128_3 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_128_4 ¶
    Source

    hash_string_to_buffer_128_4 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_128_4 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_128_5 ¶
    Source

    hash_string_to_buffer_128_5 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_128_5 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_160_3 ¶
    Source

    hash_string_to_buffer_160_3 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_160_3 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_160_4 ¶
    Source

    hash_string_to_buffer_160_4 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_160_4 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_160_5 ¶
    Source

    hash_string_to_buffer_160_5 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_160_5 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_192_3 ¶
    Source

    hash_string_to_buffer_192_3 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_192_3 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_192_4 ¶
    Source

    hash_string_to_buffer_192_4 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_192_4 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_192_5 ¶
    Source

    hash_string_to_buffer_192_5 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_192_5 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_224_3 ¶
    Source

    hash_string_to_buffer_224_3 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_224_3 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_224_4 ¶
    Source

    hash_string_to_buffer_224_4 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_224_4 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_224_5 ¶
    Source

    hash_string_to_buffer_224_5 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_224_5 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_256_3 ¶
    Source

    hash_string_to_buffer_256_3 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_256_3 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_256_4 ¶
    Source

    hash_string_to_buffer_256_4 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_256_4 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    hash_string_to_buffer_256_5 ¶
    Source

    hash_string_to_buffer_256_5 :: proc(data: string, hash: []u8) {…}
     

    hash_string_to_buffer_256_5 will hash the given input and assign the computed hash to the second parameter. It requires that the destination buffer is at least as big as the digest size

    init ¶
    Source

    init :: proc(ctx: ^Haval_Context) {…}

    tailor ¶
    Source

    tailor :: proc(ctx: ^Haval_Context, size: u32) {…}

    update ¶
    Source

    update :: proc(ctx: ^Haval_Context, data: []u8) {…}
     

    @note(zh): Make sure to set ctx.str_len to the remaining buffer size before calling this proc - e.g. ctx.str_len = u32(len(data))

    Procedure Groups

    hash_128_3 ¶
    Source

    hash_128_4 ¶
    Source

    hash_128_5 ¶
    Source

    hash_160_3 ¶
    Source

    hash_160_4 ¶
    Source

    hash_160_5 ¶
    Source

    hash_192_3 ¶
    Source

    hash_192_4 ¶
    Source

    hash_192_5 ¶
    Source

    hash_224_3 ¶
    Source

    hash_224_4 ¶
    Source

    hash_224_5 ¶
    Source

    hash_256_3 ¶
    Source

    hash_256_4 ¶
    Source

    hash_256_5 ¶
    Source

    Source Files

    Generation Information

    Generated with odin version dev-2023-10 (vendor "odin") Windows_amd64 @ 2023-10-03 21:09:46.949167900 +0000 UTC