package core:crypto/groestl
Source

⌘K
Ctrl+K
or
/

    Types

    Groestl_Context ¶
    Source

    Groestl_Context :: struct {
	chaining:          [8][16]u8,
	block_counter:     u64,
	hashbitlen:        int,
	buffer:            [128]u8,
	buf_ptr:           int,
	bits_in_last_byte: int,
	columns:           int,
	rounds:            int,
	statesize:         int,
}
    Related Procedures With Parameters

    Groestl_Variant ¶
    Source

    Groestl_Variant :: enum int {
	P512  = 0, 
	Q512  = 1, 
	P1024 = 2, 
	Q1024 = 3, 
}
    Related Procedures With Parameters

    Constants

    DIGEST_SIZE_224 ¶
    Source

    DIGEST_SIZE_224 :: 28

    DIGEST_SIZE_256 ¶
    Source

    DIGEST_SIZE_256 :: 32

    DIGEST_SIZE_384 ¶
    Source

    DIGEST_SIZE_384 :: 48

    DIGEST_SIZE_512 ¶
    Source

    DIGEST_SIZE_512 :: 64

    Variables

    SBOX ¶
    Source

    SBOX: [256]u8 = …

    SHIFT ¶
    Source

    SHIFT: [2][2][8]int = …

    Procedures

    MUL2 ¶
    Source

    MUL2 :: proc "contextless" (b: u8) -> u8 {…}

    MUL3 ¶
    Source

    MUL3 :: proc "contextless" (b: u8) -> u8 {…}

    MUL4 ¶
    Source

    MUL4 :: proc "contextless" (b: u8) -> u8 {…}

    MUL5 ¶
    Source

    MUL5 :: proc "contextless" (b: u8) -> u8 {…}

    MUL6 ¶
    Source

    MUL6 :: proc "contextless" (b: u8) -> u8 {…}

    MUL7 ¶
    Source

    MUL7 :: proc "contextless" (b: u8) -> u8 {…}

    add_roundconstant ¶
    Source

    add_roundconstant :: proc(x: [][16]u8, columns: int, round: u8, v: Groestl_Variant) {…}

    final ¶
    Source

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

    hash_bytes_224 ¶
    Source

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

    hash_bytes_224 will hash the given input and return the computed hash

    hash_bytes_256 ¶
    Source

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

    hash_bytes_256 will hash the given input and return the computed hash

    hash_bytes_384 ¶
    Source

    hash_bytes_384 :: proc(data: []u8) -> [48]u8 {…}
     

    hash_bytes_384 will hash the given input and return the computed hash

    hash_bytes_512 ¶
    Source

    hash_bytes_512 :: proc(data: []u8) -> [64]u8 {…}
     

    hash_bytes_512 will hash the given input and return the computed hash

    hash_bytes_to_buffer_224 ¶
    Source

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

    hash_bytes_to_buffer_224 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 ¶
    Source

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

    hash_bytes_to_buffer_256 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_384 ¶
    Source

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

    hash_bytes_to_buffer_384 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_512 ¶
    Source

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

    hash_bytes_to_buffer_512 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_224 ¶
    Source

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

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

    hash_file_256 ¶
    Source

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

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

    hash_file_384 ¶
    Source

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

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

    hash_file_512 ¶
    Source

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

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

    hash_stream_224 ¶
    Source

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

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

    hash_stream_256 ¶
    Source

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

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

    hash_stream_384 ¶
    Source

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

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

    hash_stream_512 ¶
    Source

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

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

    hash_string_224 ¶
    Source

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

    hash_string_224 will hash the given input and return the computed hash

    hash_string_256 ¶
    Source

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

    hash_string_256 will hash the given input and return the computed hash

    hash_string_384 ¶
    Source

    hash_string_384 :: proc(data: string) -> [48]u8 {…}
     

    hash_string_384 will hash the given input and return the computed hash

    hash_string_512 ¶
    Source

    hash_string_512 :: proc(data: string) -> [64]u8 {…}
     

    hash_string_512 will hash the given input and return the computed hash

    hash_string_to_buffer_224 ¶
    Source

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

    hash_string_to_buffer_224 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 ¶
    Source

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

    hash_string_to_buffer_256 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_384 ¶
    Source

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

    hash_string_to_buffer_384 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_512 ¶
    Source

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

    hash_string_to_buffer_512 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: ^Groestl_Context) {…}

    mix_bytes ¶
    Source

    mix_bytes :: proc(x: [][16]u8, columns: int) {…}

    output_transformation ¶
    Source

    output_transformation :: proc(ctx: ^Groestl_Context) {…}

    p ¶
    Source

    p :: proc(ctx: ^Groestl_Context, x: [][16]u8) {…}

    q ¶
    Source

    q :: proc(ctx: ^Groestl_Context, x: [][16]u8) {…}

    shift_bytes ¶
    Source

    shift_bytes :: proc(x: [][16]u8, columns: int, v: Groestl_Variant) {…}

    sub_bytes ¶
    Source

    sub_bytes :: proc(x: [][16]u8, columns: int) {…}

    transform ¶
    Source

    transform :: proc(ctx: ^Groestl_Context, input: []u8, msglen: u32) {…}

    update ¶
    Source

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

    Procedure Groups

    hash_224 ¶
    Source

    hash_256 ¶
    Source

    hash_384 ¶
    Source

    hash_512 ¶
    Source

    Source Files

    Generation Information

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