package core:crypto/ripemd

Source

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

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

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

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

DIGEST_SIZE_128 :: 16

DIGEST_SIZE_160 :: 20

DIGEST_SIZE_256 :: 32

DIGEST_SIZE_320 :: 40

RIPEMD_128_BLOCK_SIZE :: 64

RIPEMD_128_SIZE :: 16

RIPEMD_160_BLOCK_SIZE :: 64

RIPEMD_160_SIZE :: 20

RIPEMD_256_BLOCK_SIZE :: 64

RIPEMD_256_SIZE :: 32

RIPEMD_320_BLOCK_SIZE :: 64

RIPEMD_320_SIZE :: 40

S0 :: 0x67452301

S1 :: 0xefcdab89

S2 :: 0x98badcfe

S3 :: 0x10325476

S4 :: 0xc3d2e1f0

S5 :: 0x76543210

S6 :: 0xfedcba98

S7 :: 0x89abcdef

S8 :: 0x01234567

S9 :: 0x3c2d1e0f

RIPEMD_128_N0: [64]uint = …

RIPEMD_128_N1: [64]uint = …

RIPEMD_128_R0: [64]uint = …

RIPEMD_128_R1: [64]uint = …

RIPEMD_160_N0: [80]uint = …

RIPEMD_160_N1: [80]uint = …

RIPEMD_160_R0: [80]uint = …

RIPEMD_160_R1: [80]uint = …

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hash_128 :: proc{
	hash_stream_128,
	hash_file_128,
	hash_bytes_128,
	hash_string_128,
	hash_bytes_to_buffer_128,
	hash_string_to_buffer_128,
}

hash_160 :: proc{
	hash_stream_160,
	hash_file_160,
	hash_bytes_160,
	hash_string_160,
	hash_bytes_to_buffer_160,
	hash_string_to_buffer_160,
}

hash_256 :: proc{
	hash_stream_256,
	hash_file_256,
	hash_bytes_256,
	hash_string_256,
	hash_bytes_to_buffer_256,
	hash_string_to_buffer_256,
}

hash_320 :: proc{
	hash_stream_320,
	hash_file_320,
	hash_bytes_320,
	hash_string_320,
	hash_bytes_to_buffer_320,
	hash_string_to_buffer_320,
}