Skip to content

Add incremental BLAKE3 hasher #2

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
carry0987 wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Add incremental BLAKE3 hasher #2

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
46 changes: 32 additions & 14 deletions rs/webbuf_blake3/build/bundler/webbuf_blake3.d.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,18 +1,36 @@
/* tslint:disable */
/* eslint-disable */
/**
* @param {Uint8Array} data
* @returns {Uint8Array}
*/

export class Blake3Hasher {
free(): void;
[Symbol.dispose](): void;
/**
* Create a new incremental BLAKE3 hasher.
*/
constructor();
/**
* Reset the hasher to its initial state, allowing reuse.
*/
reset(): void;
/**
* Feed data into the hasher. Can be called multiple times.
*/
update(data: Uint8Array): void;
/**
* Finalize the hash and return the 32-byte digest.
* This does NOT consume the hasher — you can continue calling `update` and
* `finalize` again to get an extended hash of the data fed so far.
*/
finalize(): Uint8Array;
/**
* Create a new incremental BLAKE3 keyed hasher (for MAC).
* Key must be exactly 32 bytes.
*/
static new_keyed(key: Uint8Array): Blake3Hasher;
}

export function blake3_hash(data: Uint8Array): Uint8Array;
/**
* @param {Uint8Array} data
* @returns {Uint8Array}
*/
export function double_blake3_hash(data: Uint8Array): Uint8Array;
/**
* @param {Uint8Array} key
* @param {Uint8Array} data
* @returns {Uint8Array}
*/

export function blake3_mac(key: Uint8Array, data: Uint8Array): Uint8Array;

export function double_blake3_hash(data: Uint8Array): Uint8Array;
3 changes: 2 additions & 1 deletion rs/webbuf_blake3/build/bundler/webbuf_blake3.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
import * as wasm from "./webbuf_blake3_bg.wasm";
export * from "./webbuf_blake3_bg.js";
import { __wbg_set_wasm } from "./webbuf_blake3_bg.js";
__wbg_set_wasm(wasm);
__wbg_set_wasm(wasm);
wasm.__wbindgen_start();
251 changes: 146 additions & 105 deletions rs/webbuf_blake3/build/bundler/webbuf_blake3_bg.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,126 +3,146 @@ export function __wbg_set_wasm(val) {
wasm = val;
}

function getArrayU8FromWasm0(ptr, len) {
ptr = ptr >>> 0;
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
}

const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;

let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });

cachedTextDecoder.decode();
function getStringFromWasm0(ptr, len) {
ptr = ptr >>> 0;
return decodeText(ptr, len);
}

let cachedUint8ArrayMemory0 = null;

function getUint8ArrayMemory0() {
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
}
return cachedUint8ArrayMemory0;
}

function getStringFromWasm0(ptr, len) {
ptr = ptr >>> 0;
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}

const heap = new Array(128).fill(undefined);

heap.push(undefined, null, true, false);

let heap_next = heap.length;

function addHeapObject(obj) {
if (heap_next === heap.length) heap.push(heap.length + 1);
const idx = heap_next;
heap_next = heap[idx];

heap[idx] = obj;
return idx;
}

let WASM_VECTOR_LEN = 0;

function passArray8ToWasm0(arg, malloc) {
const ptr = malloc(arg.length * 1, 1) >>> 0;
getUint8ArrayMemory0().set(arg, ptr / 1);
WASM_VECTOR_LEN = arg.length;
return ptr;
}

let cachedDataViewMemory0 = null;
function takeFromExternrefTable0(idx) {
const value = wasm.__wbindgen_externrefs.get(idx);
wasm.__externref_table_dealloc(idx);
return value;
}

function getDataViewMemory0() {
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
cachedTextDecoder.decode();
const MAX_SAFARI_DECODE_BYTES = 2146435072;
let numBytesDecoded = 0;
function decodeText(ptr, len) {
numBytesDecoded += len;
if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
cachedTextDecoder.decode();
numBytesDecoded = len;
}
return cachedDataViewMemory0;
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}

function getObject(idx) { return heap[idx]; }

function dropObject(idx) {
if (idx < 132) return;
heap[idx] = heap_next;
heap_next = idx;
}
let WASM_VECTOR_LEN = 0;

function takeObject(idx) {
const ret = getObject(idx);
dropObject(idx);
return ret;
}
const Blake3HasherFinalization = (typeof FinalizationRegistry === 'undefined')
? { register: () => {}, unregister: () => {} }
: new FinalizationRegistry(ptr => wasm.__wbg_blake3hasher_free(ptr >>> 0, 1));

function getArrayU8FromWasm0(ptr, len) {
ptr = ptr >>> 0;
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
}
/**
* @param {Uint8Array} data
* @returns {Uint8Array}
* Incremental BLAKE3 hasher that maintains state across multiple `update` calls.
*/
export function blake3_hash(data) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
export class Blake3Hasher {
static __wrap(ptr) {
ptr = ptr >>> 0;
const obj = Object.create(Blake3Hasher.prototype);
obj.__wbg_ptr = ptr;
Blake3HasherFinalization.register(obj, obj.__wbg_ptr, obj);
return obj;
}
__destroy_into_raw() {
const ptr = this.__wbg_ptr;
this.__wbg_ptr = 0;
Blake3HasherFinalization.unregister(this);
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_blake3hasher_free(ptr, 0);
}
/**
* Create a new incremental BLAKE3 hasher.
*/
constructor() {
const ret = wasm.blake3hasher_new();
this.__wbg_ptr = ret >>> 0;
Blake3HasherFinalization.register(this, this.__wbg_ptr, this);
return this;
}
/**
* Reset the hasher to its initial state, allowing reuse.
*/
reset() {
wasm.blake3hasher_reset(this.__wbg_ptr);
}
/**
* Feed data into the hasher. Can be called multiple times.
* @param {Uint8Array} data
*/
update(data) {
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.blake3_hash(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
if (r3) {
throw takeObject(r2);
wasm.blake3hasher_update(this.__wbg_ptr, ptr0, len0);
}
/**
* Finalize the hash and return the 32-byte digest.
* This does NOT consume the hasher — you can continue calling `update` and
* `finalize` again to get an extended hash of the data fed so far.
* @returns {Uint8Array}
*/
finalize() {
const ret = wasm.blake3hasher_finalize(this.__wbg_ptr);
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
return v1;
}
/**
* Create a new incremental BLAKE3 keyed hasher (for MAC).
* Key must be exactly 32 bytes.
* @param {Uint8Array} key
* @returns {Blake3Hasher}
*/
static new_keyed(key) {
const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.blake3hasher_new_keyed(ptr0, len0);
if (ret[2]) {
throw takeFromExternrefTable0(ret[1]);
}
var v2 = getArrayU8FromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
return v2;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
return Blake3Hasher.__wrap(ret[0]);
}
}
if (Symbol.dispose) Blake3Hasher.prototype[Symbol.dispose] = Blake3Hasher.prototype.free;

/**
* @param {Uint8Array} data
* @returns {Uint8Array}
*/
export function double_blake3_hash(data) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.double_blake3_hash(retptr, ptr0, len0);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
if (r3) {
throw takeObject(r2);
}
var v2 = getArrayU8FromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
return v2;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
export function blake3_hash(data) {
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.blake3_hash(ptr0, len0);
if (ret[3]) {
throw takeFromExternrefTable0(ret[2]);
}
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
return v2;
}

/**
Expand All @@ -131,30 +151,51 @@ export function double_blake3_hash(data) {
* @returns {Uint8Array}
*/
export function blake3_mac(key, data) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
const len1 = WASM_VECTOR_LEN;
wasm.blake3_mac(retptr, ptr0, len0, ptr1, len1);
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
if (r3) {
throw takeObject(r2);
}
var v3 = getArrayU8FromWasm0(r0, r1).slice();
wasm.__wbindgen_free(r0, r1 * 1, 1);
return v3;
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
const len1 = WASM_VECTOR_LEN;
const ret = wasm.blake3_mac(ptr0, len0, ptr1, len1);
if (ret[3]) {
throw takeFromExternrefTable0(ret[2]);
}
var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
return v3;
}

export function __wbindgen_string_new(arg0, arg1) {
/**
* @param {Uint8Array} data
* @returns {Uint8Array}
*/
export function double_blake3_hash(data) {
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
const ret = wasm.double_blake3_hash(ptr0, len0);
if (ret[3]) {
throw takeFromExternrefTable0(ret[2]);
}
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
return v2;
}

export function __wbg___wbindgen_throw_dd24417ed36fc46e(arg0, arg1) {
throw new Error(getStringFromWasm0(arg0, arg1));
};

export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
// Cast intrinsic for `Ref(String) -> Externref`.
const ret = getStringFromWasm0(arg0, arg1);
return addHeapObject(ret);
return ret;
};

export function __wbindgen_init_externref_table() {
const table = wasm.__wbindgen_externrefs;
const offset = table.grow(4);
table.set(0, undefined);
table.set(offset + 0, undefined);
table.set(offset + 1, null);
table.set(offset + 2, true);
table.set(offset + 3, false);
};
Binary file modified rs/webbuf_blake3/build/bundler/webbuf_blake3_bg.wasm
View file
Open in desktop
Binary file not shown.
20 changes: 14 additions & 6 deletions rs/webbuf_blake3/build/bundler/webbuf_blake3_bg.wasm.d.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,9 +1,17 @@
/* tslint:disable */
/* eslint-disable */
export const memory: WebAssembly.Memory;
export function blake3_hash(a: number, b: number, c: number): void;
export function double_blake3_hash(a: number, b: number, c: number): void;
export function blake3_mac(a: number, b: number, c: number, d: number, e: number): void;
export function __wbindgen_add_to_stack_pointer(a: number): number;
export function __wbindgen_malloc(a: number, b: number): number;
export function __wbindgen_free(a: number, b: number, c: number): void;
export const __wbg_blake3hasher_free: (a: number, b: number) => void;
export const blake3_hash: (a: number, b: number) => [number, number, number, number];
export const blake3_mac: (a: number, b: number, c: number, d: number) => [number, number, number, number];
export const blake3hasher_finalize: (a: number) => [number, number];
export const blake3hasher_new: () => number;
export const blake3hasher_new_keyed: (a: number, b: number) => [number, number, number];
export const blake3hasher_reset: (a: number) => void;
export const blake3hasher_update: (a: number, b: number, c: number) => void;
export const double_blake3_hash: (a: number, b: number) => [number, number, number, number];
export const __wbindgen_externrefs: WebAssembly.Table;
export const __wbindgen_malloc: (a: number, b: number) => number;
export const __wbindgen_free: (a: number, b: number, c: number) => void;
export const __externref_table_dealloc: (a: number) => void;
export const __wbindgen_start: () => void;
Loading