package core:crypto/ripemd

Types

Ripemd128_Context ¶

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

Ripemd160_Context ¶

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

Ripemd256_Context ¶

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

Ripemd320_Context ¶

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

Constants

DIGEST_SIZE_128 ¶

DIGEST_SIZE_128 :: 16

DIGEST_SIZE_160 ¶

DIGEST_SIZE_160 :: 20

DIGEST_SIZE_256 ¶

DIGEST_SIZE_256 :: 32

DIGEST_SIZE_320 ¶

DIGEST_SIZE_320 :: 40

RIPEMD_128_BLOCK_SIZE ¶

RIPEMD_128_BLOCK_SIZE :: 64

RIPEMD_128_SIZE ¶

RIPEMD_128_SIZE :: 16

RIPEMD_160_BLOCK_SIZE ¶

RIPEMD_160_BLOCK_SIZE :: 64

RIPEMD_160_SIZE ¶

RIPEMD_160_SIZE :: 20

RIPEMD_256_BLOCK_SIZE ¶

RIPEMD_256_BLOCK_SIZE :: 64

RIPEMD_256_SIZE ¶

RIPEMD_256_SIZE :: 32

RIPEMD_320_BLOCK_SIZE ¶

RIPEMD_320_BLOCK_SIZE :: 64

RIPEMD_320_SIZE ¶

RIPEMD_320_SIZE :: 40

S0 ¶

S0 :: 0x67452301

S1 ¶

S1 :: 0xefcdab89

S2 ¶

S2 :: 0x98badcfe

S3 ¶

S3 :: 0x10325476

S4 ¶

S4 :: 0xc3d2e1f0

S5 ¶

S5 :: 0x76543210

S6 ¶

S6 :: 0xfedcba98

S7 ¶

S7 :: 0x89abcdef

S8 ¶

S8 :: 0x01234567

S9 ¶

S9 :: 0x3c2d1e0f

Variables

RIPEMD_128_N0 ¶

RIPEMD_128_N0: [64]uint = …

RIPEMD_128_N1 ¶

RIPEMD_128_N1: [64]uint = …

RIPEMD_128_R0 ¶

RIPEMD_128_R0: [64]uint = …

RIPEMD_128_R1 ¶

RIPEMD_128_R1: [64]uint = …

RIPEMD_160_N0 ¶

RIPEMD_160_N0: [80]uint = …

RIPEMD_160_N1 ¶

RIPEMD_160_N1: [80]uint = …

RIPEMD_160_R0 ¶

RIPEMD_160_R0: [80]uint = …

RIPEMD_160_R1 ¶

RIPEMD_160_R1: [80]uint = …

Procedures

block ¶

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

final ¶

final :: proc "odin" (ctx: ^$, data: []u8) {…}

hash_bytes_128 ¶

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

hash_bytes_128 will hash the given input and return the computed hash

hash_bytes_160 ¶

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

hash_bytes_160 will hash the given input and return the computed hash

hash_bytes_256 ¶

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

hash_bytes_256 will hash the given input and return the computed hash

hash_bytes_320 ¶

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

hash_bytes_320 will hash the given input and return the computed hash

hash_bytes_to_buffer_128 ¶

hash_bytes_to_buffer_128 :: proc "odin" (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 ¶

hash_bytes_to_buffer_160 :: proc "odin" (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 ¶

hash_bytes_to_buffer_256 :: proc "odin" (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 ¶

hash_bytes_to_buffer_320 :: proc "odin" (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 ¶

hash_file_128 :: proc "odin" (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 ¶

hash_file_160 :: proc "odin" (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 ¶

hash_file_256 :: proc "odin" (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 ¶

hash_file_320 :: proc "odin" (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 ¶

hash_stream_128 :: proc "odin" (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 ¶

hash_stream_160 :: proc "odin" (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 ¶

hash_stream_256 :: proc "odin" (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 ¶

hash_stream_320 :: proc "odin" (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 ¶

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

hash_string_128 will hash the given input and return the computed hash

hash_string_160 ¶

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

hash_string_160 will hash the given input and return the computed hash

hash_string_256 ¶

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

hash_string_256 will hash the given input and return the computed hash

hash_string_320 ¶

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

hash_string_320 will hash the given input and return the computed hash

hash_string_to_buffer_128 ¶

hash_string_to_buffer_128 :: proc "odin" (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 ¶

hash_string_to_buffer_160 :: proc "odin" (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 ¶

hash_string_to_buffer_256 :: proc "odin" (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 ¶

hash_string_to_buffer_320 :: proc "odin" (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 ¶

init :: proc "odin" (ctx: ^$) {…}

ripemd_128_block ¶

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

ripemd_160_block ¶

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

ripemd_256_block ¶

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

ripemd_320_block ¶

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

update ¶

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

Procedure Groups

Source Files

Generation Information

Generated with odin version dev-2022-12 (vendor "odin") Windows_amd64 @ 2022-12-06 21:08:55.164747300 +0000 UTC