package core:crypto/ripemd
Source

⌘K
Ctrl+K
or
/

    Types

    Ripemd128_Context ¶
    Source

    Ripemd128_Context :: struct {
	s:  [4]u32,
	x:  [64]u8,
	nx: int,
	tc: u64,
}

    Ripemd160_Context ¶
    Source

    Ripemd160_Context :: struct {
	s:  [5]u32,
	x:  [64]u8,
	nx: int,
	tc: u64,
}

    Ripemd256_Context ¶
    Source

    Ripemd256_Context :: struct {
	s:  [8]u32,
	x:  [64]u8,
	nx: int,
	tc: u64,
}

    Ripemd320_Context ¶
    Source

    Ripemd320_Context :: struct {
	s:  [10]u32,
	x:  [64]u8,
	nx: int,
	tc: u64,
}

    Constants

    DIGEST_SIZE_128 ¶
    Source

    DIGEST_SIZE_128 :: 16

    DIGEST_SIZE_160 ¶
    Source

    DIGEST_SIZE_160 :: 20

    DIGEST_SIZE_256 ¶
    Source

    DIGEST_SIZE_256 :: 32

    DIGEST_SIZE_320 ¶
    Source

    DIGEST_SIZE_320 :: 40

    RIPEMD_128_BLOCK_SIZE ¶
    Source

    RIPEMD_128_BLOCK_SIZE :: 64

    RIPEMD_128_SIZE ¶
    Source

    RIPEMD_128_SIZE :: 16

    RIPEMD_160_BLOCK_SIZE ¶
    Source

    RIPEMD_160_BLOCK_SIZE :: 64

    RIPEMD_160_SIZE ¶
    Source

    RIPEMD_160_SIZE :: 20

    RIPEMD_256_BLOCK_SIZE ¶
    Source

    RIPEMD_256_BLOCK_SIZE :: 64

    RIPEMD_256_SIZE ¶
    Source

    RIPEMD_256_SIZE :: 32

    RIPEMD_320_BLOCK_SIZE ¶
    Source

    RIPEMD_320_BLOCK_SIZE :: 64

    RIPEMD_320_SIZE ¶
    Source

    RIPEMD_320_SIZE :: 40

    S0 ¶
    Source

    S0 :: 0x67452301

    S1 ¶
    Source

    S1 :: 0xefcdab89

    S2 ¶
    Source

    S2 :: 0x98badcfe

    S3 ¶
    Source

    S3 :: 0x10325476

    S4 ¶
    Source

    S4 :: 0xc3d2e1f0

    S5 ¶
    Source

    S5 :: 0x76543210

    S6 ¶
    Source

    S6 :: 0xfedcba98

    S7 ¶
    Source

    S7 :: 0x89abcdef

    S8 ¶
    Source

    S8 :: 0x01234567

    S9 ¶
    Source

    S9 :: 0x3c2d1e0f

    Variables

    RIPEMD_128_N0 ¶
    Source

    RIPEMD_128_N0: [64]uint = …

    RIPEMD_128_N1 ¶
    Source

    RIPEMD_128_N1: [64]uint = …

    RIPEMD_128_R0 ¶
    Source

    RIPEMD_128_R0: [64]uint = …

    RIPEMD_128_R1 ¶
    Source

    RIPEMD_128_R1: [64]uint = …

    RIPEMD_160_N0 ¶
    Source

    RIPEMD_160_N0: [80]uint = …

    RIPEMD_160_N1 ¶
    Source

    RIPEMD_160_N1: [80]uint = …

    RIPEMD_160_R0 ¶
    Source

    RIPEMD_160_R0: [80]uint = …

    RIPEMD_160_R1 ¶
    Source

    RIPEMD_160_R1: [80]uint = …

    Procedures

    block ¶
    Source

    block :: proc(ctx: ^$T, p: []u8) -> int {…}

    final ¶
    Source

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

    hash_bytes_128 ¶
    Source

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

    hash_bytes_128 will hash the given input and return the computed hash

    hash_bytes_160 ¶
    Source

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

    hash_bytes_160 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_320 ¶
    Source

    hash_bytes_320 :: proc(data: []u8) -> [40]u8 {…}
     

    hash_bytes_320 will hash the given input and return the computed hash

    hash_bytes_to_buffer_128 ¶
    Source

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

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

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

    hash_bytes_to_buffer_160 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_320 ¶
    Source

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

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

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

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

    hash_file_160 ¶
    Source

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

    hash_file_160 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_320 ¶
    Source

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

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

    hash_stream_128 ¶
    Source

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

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

    hash_stream_160 ¶
    Source

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

    hash_stream_160 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_320 ¶
    Source

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

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

    hash_string_128 ¶
    Source

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

    hash_string_128 will hash the given input and return the computed hash

    hash_string_160 ¶
    Source

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

    hash_string_160 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_320 ¶
    Source

    hash_string_320 :: proc(data: string) -> [40]u8 {…}
     

    hash_string_320 will hash the given input and return the computed hash

    hash_string_to_buffer_128 ¶
    Source

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

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

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

    hash_string_to_buffer_160 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_320 ¶
    Source

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

    hash_string_to_buffer_320 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: ^$T) {…}

    ripemd_128_block ¶
    Source

    ripemd_128_block :: proc(ctx: ^$T, p: []u8) -> int {…}

    ripemd_160_block ¶
    Source

    ripemd_160_block :: proc(ctx: ^$T, p: []u8) -> int {…}

    ripemd_256_block ¶
    Source

    ripemd_256_block :: proc(ctx: ^$T, p: []u8) -> int {…}

    ripemd_320_block ¶
    Source

    ripemd_320_block :: proc(ctx: ^$T, p: []u8) -> int {…}

    update ¶
    Source

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

    Procedure Groups

    hash_128 ¶
    Source

    hash_160 ¶
    Source

    hash_256 ¶
    Source

    hash_320 ¶
    Source

    Source Files

    Generation Information

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