core/crypto/blake2: API cleanup and bug fixes

- blake2s.Blake2s_Context -> blake2s.Context
- blake2b.Blake2b_Context -> blake2b.Context
- Fix the BLAKE2s low level API (context type was incorrect)
- Support the configurable output size

core/crypto/_blake2/blake2.odin

@@ -86,8 +86,14 @@ BLAKE2B_IV := [8]u64 {
 init :: proc(ctx: ^$T) {
 	when T == Blake2s_Context {
 		block_size :: BLAKE2S_BLOCK_SIZE
+		max_size :: BLAKE2S_SIZE
 	} else when T == Blake2b_Context {
 		block_size :: BLAKE2B_BLOCK_SIZE
+		max_size :: BLAKE2B_SIZE
+	}
+
+	if ctx.cfg.size > max_size {
+		panic("blake2: requested output size exceeeds algorithm max")
 	}
 
 	p := make([]byte, block_size)
@@ -192,13 +198,12 @@ final :: proc(ctx: ^$T, hash: []byte) {
 	assert(ctx.is_initialized)
 
 	when T == Blake2s_Context {
-		if len(hash) < BLAKE2S_SIZE {
+		if len(hash) < int(ctx.cfg.size) {
 			panic("crypto/blake2s: invalid destination digest size")
 		}
 		blake2s_final(ctx, hash)
-	}
+	} else when T == Blake2b_Context {
-	when T == Blake2b_Context {
+		if len(hash) < int(ctx.cfg.size) {
-		if len(hash) < BLAKE2B_SIZE {
 			panic("crypto/blake2b: invalid destination digest size")
 		}
 		blake2b_final(ctx, hash)
@@ -228,9 +233,11 @@ blake2s_final :: proc "contextless" (ctx: ^Blake2s_Context, hash: []byte) {
 
 	blocks(ctx, ctx.x[:])
 
+	dst: [BLAKE2S_SIZE]byte
 	for i := 0; i < BLAKE2S_SIZE / 4; i += 1 {
-		endian.unchecked_put_u32le(hash[i * 4:], ctx.h[i])
+		endian.unchecked_put_u32le(dst[i * 4:], ctx.h[i])
 	}
+	copy(hash, dst[:])
 }
 
 @(private)
@@ -254,17 +261,18 @@ blake2b_final :: proc "contextless" (ctx: ^Blake2b_Context, hash: []byte) {
 
 	blocks(ctx, ctx.x[:])
 
+	dst: [BLAKE2B_SIZE]byte
 	for i := 0; i < BLAKE2B_SIZE / 8; i += 1 {
-		endian.unchecked_put_u64le(hash[i * 8:], ctx.h[i])
+		endian.unchecked_put_u64le(dst[i * 8:], ctx.h[i])
 	}
+	copy(hash, dst[:])
 }
 
 @(private)
 blocks :: proc "contextless" (ctx: ^$T, p: []byte) {
 	when T == Blake2s_Context {
 		blake2s_blocks(ctx, p)
-	}
+	} else when T == Blake2b_Context {
-	when T == Blake2b_Context {
 		blake2b_blocks(ctx, p)
 	}
 }

core/crypto/blake2b/blake2b.odin

@@ -32,13 +32,13 @@ hash_string :: proc(data: string) -> [DIGEST_SIZE]byte {
 // computed hash
 hash_bytes :: proc(data: []byte) -> [DIGEST_SIZE]byte {
 	hash: [DIGEST_SIZE]byte
-	ctx: _blake2.Blake2b_Context
+	ctx: Context
 	cfg: _blake2.Blake2_Config
 	cfg.size = _blake2.BLAKE2B_SIZE
 	ctx.cfg = cfg
-	_blake2.init(&ctx)
+	init(&ctx)
-	_blake2.update(&ctx, data)
+	update(&ctx, data)
-	_blake2.final(&ctx, hash[:])
+	final(&ctx, hash[:])
 	return hash
 }
 
@@ -53,35 +53,36 @@ hash_string_to_buffer :: proc(data: string, hash: []byte) {
 // 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 :: proc(data, hash: []byte) {
-	ctx: _blake2.Blake2b_Context
+	ctx: Context
 	cfg: _blake2.Blake2_Config
 	cfg.size = _blake2.BLAKE2B_SIZE
 	ctx.cfg = cfg
-	_blake2.init(&ctx)
+	init(&ctx)
-	_blake2.update(&ctx, data)
+	update(&ctx, data)
-	_blake2.final(&ctx, hash)
+	final(&ctx, hash)
 }
 
-
 // hash_stream will read the stream in chunks and compute a
 // hash from its contents
 hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
 	hash: [DIGEST_SIZE]byte
-	ctx: _blake2.Blake2b_Context
+	ctx: Context
 	cfg: _blake2.Blake2_Config
 	cfg.size = _blake2.BLAKE2B_SIZE
 	ctx.cfg = cfg
-	_blake2.init(&ctx)
+	init(&ctx)
+
 	buf := make([]byte, 512)
 	defer delete(buf)
+
 	read := 1
 	for read > 0 {
 		read, _ = io.read(s, buf)
 		if read > 0 {
-			_blake2.update(&ctx, buf[:read])
+			update(&ctx, buf[:read])
 		}
 	}
-	_blake2.final(&ctx, hash[:])
+	final(&ctx, hash[:])
 	return hash, true
 }
 
@@ -111,16 +112,16 @@ hash :: proc {
     Low level API
 */
 
-Blake2b_Context :: _blake2.Blake2b_Context
+Context :: _blake2.Blake2b_Context
 
-init :: proc(ctx: ^_blake2.Blake2b_Context) {
+init :: proc(ctx: ^Context) {
 	_blake2.init(ctx)
 }
 
-update :: proc(ctx: ^_blake2.Blake2b_Context, data: []byte) {
+update :: proc(ctx: ^Context, data: []byte) {
 	_blake2.update(ctx, data)
 }
 
-final :: proc(ctx: ^_blake2.Blake2b_Context, hash: []byte) {
+final :: proc(ctx: ^Context, hash: []byte) {
 	_blake2.final(ctx, hash)
 }

core/crypto/blake2s/blake2s.odin

@@ -32,17 +32,16 @@ hash_string :: proc(data: string) -> [DIGEST_SIZE]byte {
 // computed hash
 hash_bytes :: proc(data: []byte) -> [DIGEST_SIZE]byte {
 	hash: [DIGEST_SIZE]byte
-	ctx: _blake2.Blake2s_Context
+	ctx: Context
 	cfg: _blake2.Blake2_Config
 	cfg.size = _blake2.BLAKE2S_SIZE
 	ctx.cfg = cfg
-	_blake2.init(&ctx)
+	init(&ctx)
-	_blake2.update(&ctx, data)
+	update(&ctx, data)
-	_blake2.final(&ctx, hash[:])
+	final(&ctx, hash[:])
 	return hash
 }
 
-
 // hash_string_to_buffer 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
@@ -54,34 +53,36 @@ hash_string_to_buffer :: proc(data: string, hash: []byte) {
 // 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 :: proc(data, hash: []byte) {
-	ctx: _blake2.Blake2s_Context
+	ctx: Context
 	cfg: _blake2.Blake2_Config
 	cfg.size = _blake2.BLAKE2S_SIZE
 	ctx.cfg = cfg
-	_blake2.init(&ctx)
+	init(&ctx)
-	_blake2.update(&ctx, data)
+	update(&ctx, data)
-	_blake2.final(&ctx, hash)
+	final(&ctx, hash)
 }
 
 // hash_stream will read the stream in chunks and compute a
 // hash from its contents
 hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
 	hash: [DIGEST_SIZE]byte
-	ctx: _blake2.Blake2s_Context
+	ctx: Context
 	cfg: _blake2.Blake2_Config
 	cfg.size = _blake2.BLAKE2S_SIZE
 	ctx.cfg = cfg
-	_blake2.init(&ctx)
+	init(&ctx)
+
 	buf := make([]byte, 512)
 	defer delete(buf)
+
 	read := 1
 	for read > 0 {
 		read, _ = io.read(s, buf)
 		if read > 0 {
-			_blake2.update(&ctx, buf[:read])
+			update(&ctx, buf[:read])
 		}
 	}
-	_blake2.final(&ctx, hash[:])
+	final(&ctx, hash[:])
 	return hash, true
 }
 
@@ -111,16 +112,16 @@ hash :: proc {
     Low level API
 */
 
-Blake2s_Context :: _blake2.Blake2b_Context
+Context :: _blake2.Blake2s_Context
 
-init :: proc(ctx: ^_blake2.Blake2s_Context) {
+init :: proc(ctx: ^Context) {
 	_blake2.init(ctx)
 }
 
-update :: proc(ctx: ^_blake2.Blake2s_Context, data: []byte) {
+update :: proc(ctx: ^Context, data: []byte) {
 	_blake2.update(ctx, data)
 }
 
-final :: proc(ctx: ^_blake2.Blake2s_Context, hash: []byte) {
+final :: proc(ctx: ^Context, hash: []byte) {
 	_blake2.final(ctx, hash)
 }

vendor/botan/blake2b/blake2b.odin

@@ -32,11 +32,10 @@ hash_string :: proc "contextless" (data: string) -> [DIGEST_SIZE]byte {
 // computed hash
 hash_bytes :: proc "contextless" (data: []byte) -> [DIGEST_SIZE]byte {
     hash: [DIGEST_SIZE]byte
-    ctx: botan.hash_t
+    ctx: Context
-    botan.hash_init(&ctx, botan.HASH_BLAKE2B, 0)
+    init(&ctx)
-    botan.hash_update(ctx, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    update(&ctx, data)
-    botan.hash_final(ctx, &hash[0])
+    final(&ctx, hash[:])
-    botan.hash_destroy(ctx)
     return hash
 }
 
@@ -52,31 +51,29 @@ hash_string_to_buffer :: proc(data: string, hash: []byte) {
 // It requires that the destination buffer is at least as big as the digest size
 hash_bytes_to_buffer :: proc(data, hash: []byte) {
     assert(len(hash) >= DIGEST_SIZE, "Size of destination buffer is smaller than the digest size")
-    ctx: botan.hash_t
+    ctx: Context
-    botan.hash_init(&ctx, botan.HASH_BLAKE2B, 0)
+    init(&ctx)
-    botan.hash_update(ctx, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    update(&ctx, data)
-    botan.hash_final(ctx, &hash[0])
+    final(&ctx, hash[:])
-    botan.hash_destroy(ctx)
 }
 
 // hash_stream will read the stream in chunks and compute a
 // hash from its contents
 hash_stream :: proc(s: io.Stream) -> ([DIGEST_SIZE]byte, bool) {
     hash: [DIGEST_SIZE]byte
-    ctx: botan.hash_t
+    ctx: Context
-    botan.hash_init(&ctx, botan.HASH_BLAKE2B, 0)
+    init(&ctx)
     buf := make([]byte, 512)
     defer delete(buf)
     i := 1
     for i > 0 {
         i, _ = io.read(s, buf)
         if i > 0 {
-            botan.hash_update(ctx, len(buf) == 0 ? nil : &buf[0], uint(i))
+		    update(&ctx, buf[:i])
-        } 
+        }
     }
-    botan.hash_final(ctx, &hash[0])
+    final(&ctx, hash[:])
-    botan.hash_destroy(ctx)
+    return hash, true
-    return hash, true 
 }
 
 // hash_file will read the file provided by the given handle
@@ -105,17 +102,17 @@ hash :: proc {
     Low level API
 */
 
-Blake2b_Context :: botan.hash_t
+Context :: botan.hash_t
 
-init :: proc "contextless" (ctx: ^botan.hash_t) {
+init :: proc "contextless" (ctx: ^Context) {
     botan.hash_init(ctx, botan.HASH_BLAKE2B, 0)
 }
 
-update :: proc "contextless" (ctx: ^botan.hash_t, data: []byte) {
+update :: proc "contextless" (ctx: ^Context, data: []byte) {
     botan.hash_update(ctx^, len(data) == 0 ? nil : &data[0], uint(len(data)))
 }
 
-final :: proc "contextless" (ctx: ^botan.hash_t, hash: []byte) {
+final :: proc "contextless" (ctx: ^Context, hash: []byte) {
     botan.hash_final(ctx^, &hash[0])
     botan.hash_destroy(ctx^)
 }