BLAKE2 Hashing

BLAKE2 is the hashing family that sits at the top of the "fast and modern" pile: it's built on the same ideas as ChaCha20, it's faster than SHA-2 at equivalent security, and it's been in wide production use for years (it's even the hash behind a lot of password hashing). In the ARG Toolkit this node wraps it into a ComfyUI node so you can hash bytes inside a graph - handy for checksums, for turning a passphrase-adjacent string into a fixed-size fingerprint, and for any "hash this and compare it to that" step in a multi-stage puzzle. It lives in the pack's Modern > Hashing category alongside SHA2 and SHA3.

Here's the catch you need to know before you build anything on it: as shipped, this node is currently broken against the cryptography version the pack pins. The code asks BLAKE2b for a 32-byte digest and BLAKE2s for a 64-byte digest - exactly backwards from what cryptography accepts, which wants 64 for BLAKE2b and 32 for BLAKE2s. Run it today and you'll get a ValueError: Digest size must be 64 (or 32) the moment it executes. The author's intent is clear and the fix is a two-line swap; check the pack's issues/updates before you rely on this node, and if it still errors, grab the same hash from the pack's SHA3 or SHA2 node instead - or from the BLAKE2 entries in the ConcatKDF dropdown, which use the correct digest sizes.

How it works

When it works, the mechanism is straightforward. You feed the bytes you want hashed into key1 - the node calls it a "key," but for plain hashing that's just the data (the base Hash node feeds each provided key through digest.update() in order, so multiple keys just concatenate their bytes before finalizing). You pick BLAKE2b or BLAKE2s in the algorithm dropdown, and out the other side comes hash_bytes, a BYTESLIKE output you can pipe into ByteslikeDecode to view as hex or base64, or straight into a compare node.

Two notes for the curious: this is a plain hash - the "key" here is data to digest, not a BLAKE2 keyed-hash secret, so don't treat it as an authenticator. And while the info schema only advertises key1, the underlying Hash node accepts additional dynamic key2, key3, … inputs if you want to hash several byte chunks at once.

The inputs that matter

• key1 - the bytes to hash (mandatory, BYTESLIKE). Wire it from a ByteslikeEncode node or similar.
• algorithm - BLAKE2b (64-byte digest, typically what you want) or BLAKE2s (32-byte, smaller and faster on 8-bit hardware - irrelevant here, but harmless).

Output: hash_bytes, a BYTESLIKE blob of the raw digest.

Installing it

Part of the ComfyUI ARG Toolkit pack - install once, get the whole set. Via ComfyUI Manager search "ComfyUI ARG Toolkit", or:

cd ComfyUI/custom_nodes
git clone https://github.com/AzelusLightvale/ComfyUI-ARG-Toolkit

Restart ComfyUI. The pack's install pulls cryptography, secretpy, stegano, invisible-watermark, reedsolo and heavy transitive deps (torch, opencv-python), so the first install takes a minute. No models, no API keys.

Gotchas

The digest-size bug above is the headline - it errors deterministically on both algorithms with the pinned cryptography==50.0.0, so you can't dodge it by picking one option over the other. If you need BLAKE2 right now, the ConcatKDF nodes expose working BLAKE2b/BLAKE2s via their algorithm dropdown, and the SHA3 node is a fine stand-in for a strong modern hash. This is an honest "check for a fix before you build a workflow around it" node rather than a "plug in and go" one.