nimcypher/hash

Search:
Group by:

Types

Blake2b = object
Stateful BLAKE2b computation. Update with chunks, then finish. 
Md5Digest = array[Md5DigestSize, uint8]
Md5Hmac = array[Md5DigestSize, uint8]
Md5HmacState = object
Md5State = object
Sha1Hmac = array[Sha1DigestSize, uint8]
Sha256Digest = array[Sha256DigestSize, uint8]
Sha256Hmac = array[Sha256DigestSize, uint8]
Sha256HmacState = object
Sha256State = object
Sha384Digest = array[Sha384DigestSize, uint8]
Sha384Hmac = array[Sha384DigestSize, uint8]
Sha384HmacState = object
Sha384State = object
Sha512Digest = array[Sha512DigestSize, uint8]
Sha512Hmac = array[Sha512DigestSize, uint8]
Sha512HmacState = object
Stateful HMAC-SHA-512 computation. 
Sha512State = object
Stateful SHA-512 computation. 
Xxh3_64 = object
Xxh3_128 = object
Xxh32 = object
Xxh64 = object

Procs

proc blake(message: openArray[byte]; hashSize: int = Blake2bDefaultDigestSize): seq[
    byte] {....raises: [ValueError], tags: [], forbids: [].}
Compute the BLAKE2b hash of the message (default 32-byte digest). 
proc blake(message: string; hashSize: int = Blake2bDefaultDigestSize): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc blakeHex(message: openArray[byte]; hashSize: int = Blake2bDefaultDigestSize): string {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc blakeHex(message: string; hashSize: int = Blake2bDefaultDigestSize): string {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc blakeKeyed(message, key: string; hashSize: int = Blake2bDefaultDigestSize): seq[
    byte] {....raises: [ValueError], tags: [], forbids: [].}
proc blakeKeyed(message: openArray[byte]; key: openArray[byte];
                hashSize: int = Blake2bDefaultDigestSize): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
Compute a keyed BLAKE2b hash (MAC). 
proc blakeKeyedHex(message, key: string;
                   hashSize: int = Blake2bDefaultDigestSize): string {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc blakeKeyedHex(message: openArray[byte]; key: openArray[byte];
                   hashSize: int = Blake2bDefaultDigestSize): string {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc finish(state: var Blake2b): seq[byte] {....raises: [ValueError], tags: [],
    forbids: [].}
proc finish(state: var Md5HmacState): Md5Hmac {....raises: [ValueError], tags: [],
    forbids: [].}
proc finish(state: var Md5State): Md5Digest {....raises: [ValueError], tags: [],
    forbids: [].}
proc finish(state: var Sha256HmacState): Sha256Hmac {....raises: [ValueError],
    tags: [], forbids: [].}
proc finish(state: var Sha256State): Sha256Digest {....raises: [ValueError],
    tags: [], forbids: [].}
proc finish(state: var Sha384HmacState): Sha384Hmac {....raises: [ValueError],
    tags: [], forbids: [].}
proc finish(state: var Sha384State): Sha384Digest {....raises: [ValueError],
    tags: [], forbids: [].}
proc finish(state: var Sha512HmacState): Sha512Hmac {....raises: [ValueError],
    tags: [], forbids: [].}
proc finish(state: var Sha512State): Sha512Digest {....raises: [ValueError],
    tags: [], forbids: [].}
proc finish(state: var Xxh3_64): uint64 {....raises: [ValueError], tags: [],
    forbids: [].}
proc finish(state: var Xxh3_128): xxhAlgo.Xxh128 {....raises: [ValueError],
    tags: [], forbids: [].}
proc finish(state: var Xxh32): uint32 {....raises: [ValueError], tags: [],
                                        forbids: [].}
proc finish(state: var Xxh64): uint64 {....raises: [ValueError], tags: [],
                                        forbids: [].}
proc finishHex(state: var Blake2b): string {....raises: [ValueError], tags: [],
    forbids: [].}
proc finishHex(state: var Md5HmacState): string {....raises: [ValueError],
    tags: [], forbids: [].}
proc finishHex(state: var Md5State): string {....raises: [ValueError], tags: [],
    forbids: [].}
proc finishHex(state: var Sha256HmacState): string {....raises: [ValueError],
    tags: [], forbids: [].}
proc finishHex(state: var Sha256State): string {....raises: [ValueError], tags: [],
    forbids: [].}
proc finishHex(state: var Sha384HmacState): string {....raises: [ValueError],
    tags: [], forbids: [].}
proc finishHex(state: var Sha384State): string {....raises: [ValueError], tags: [],
    forbids: [].}
proc finishHex(state: var Sha512HmacState): string {....raises: [ValueError],
    tags: [], forbids: [].}
proc finishHex(state: var Sha512State): string {....raises: [ValueError], tags: [],
    forbids: [].}
proc finishHex(state: var Xxh3_64): string {....raises: [ValueError], tags: [],
    forbids: [].}
proc finishHex(state: var Xxh3_128): string {....raises: [ValueError], tags: [],
    forbids: [].}
proc finishHex(state: var Xxh32): string {....raises: [ValueError], tags: [],
    forbids: [].}
proc finishHex(state: var Xxh64): string {....raises: [ValueError], tags: [],
    forbids: [].}
proc hkdfExpandSha256(prk, info: openArray[byte]; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc hkdfExpandSha256(prk, info: string; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc hkdfExpandSha256[N: static[int]](prk, info: openArray[byte]): array[N,
    uint8]
proc hkdfExpandSha384(prk, info: openArray[byte]; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
Expand a pseudo-random key with HKDF-SHA-384. 
proc hkdfExpandSha384(prk, info: string; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc hkdfExpandSha384[N: static[int]](prk, info: openArray[byte]): array[N,
    uint8]
proc hkdfExpandSha512(prk, info: openArray[byte]; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
Expand a pseudo-random key with HKDF-SHA-512. 
proc hkdfExpandSha512(prk, info: string; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc hkdfExpandSha512[N: static[int]](prk, info: openArray[byte]): array[N,
    uint8]
proc hkdfSha256(ikm, salt, info: openArray[byte]; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
Derive output keying material of okmLen bytes with HKDF-SHA-256. 
proc hkdfSha256(ikm, salt, info: string; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc hkdfSha256[N: static[int]](ikm, salt, info: openArray[byte]): array[N,
    uint8]
proc hkdfSha384(ikm, salt, info: openArray[byte]; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
Derive output keying material of okmLen bytes with HKDF-SHA-384. 
proc hkdfSha384(ikm, salt, info: string; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc hkdfSha384[N: static[int]](ikm, salt, info: openArray[byte]): array[N,
    uint8]
proc hkdfSha512(ikm, salt, info: openArray[byte]; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
Derive output keying material of okmLen bytes with HKDF-SHA-512. 
proc hkdfSha512(ikm, salt, info: string; okmLen: Natural): seq[byte] {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc hkdfSha512[N: static[int]](ikm, salt, info: openArray[byte]): array[N,
    uint8]
Derive a fixed-size output key of N bytes with HKDF-SHA-512. 
proc initBlake2b(hashSize: int = Blake2bDefaultDigestSize): Blake2b {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc initBlake2bKeyed(key: openArray[byte];
                      hashSize: int = Blake2bDefaultDigestSize): Blake2b {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc initBlake2bKeyed(key: string; hashSize: int = Blake2bDefaultDigestSize): Blake2b {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc initMd5(): Md5State {....raises: [], tags: [], forbids: [].}
proc initMd5Hmac(key: openArray[byte]): Md5HmacState {....raises: [], tags: [],
    forbids: [].}
proc initMd5Hmac(key: string): Md5HmacState {....raises: [], tags: [], forbids: [].}
proc initSha256(): Sha256State {....raises: [], tags: [], forbids: [].}
proc initSha256Hmac(key: openArray[byte]): Sha256HmacState {....raises: [],
    tags: [], forbids: [].}
proc initSha256Hmac(key: string): Sha256HmacState {....raises: [], tags: [],
    forbids: [].}
proc initSha384(): Sha384State {....raises: [], tags: [], forbids: [].}
proc initSha384Hmac(key: openArray[byte]): Sha384HmacState {....raises: [],
    tags: [], forbids: [].}
proc initSha384Hmac(key: string): Sha384HmacState {....raises: [], tags: [],
    forbids: [].}
proc initSha512(): Sha512State {....raises: [], tags: [], forbids: [].}
proc initSha512Hmac(key: openArray[byte]): Sha512HmacState {....raises: [],
    tags: [], forbids: [].}
proc initSha512Hmac(key: string): Sha512HmacState {....raises: [], tags: [],
    forbids: [].}
proc initXxh3_64(seed: uint64 = 0): Xxh3_64 {....raises: [], tags: [], forbids: [].}
proc initXxh3_128(seed: uint64 = 0): Xxh3_128 {....raises: [], tags: [],
    forbids: [].}
proc initXxh32(seed: uint32 = 0): Xxh32 {....raises: [], tags: [], forbids: [].}
proc initXxh64(seed: uint64 = 0): Xxh64 {....raises: [], tags: [], forbids: [].}
proc md5(message: openArray[byte]): Md5Digest {....raises: [], tags: [],
    forbids: [].}
proc md5(message: string): Md5Digest {....raises: [], tags: [], forbids: [].}
proc md5Hex(message: openArray[byte]): string {....raises: [], tags: [],
    forbids: [].}
proc md5Hex(message: string): string {....raises: [], tags: [], forbids: [].}
proc md5Hmac(key, message: openArray[byte]): Md5Hmac {....raises: [], tags: [],
    forbids: [].}
proc md5Hmac(key, message: string): Md5Hmac {....raises: [], tags: [], forbids: [].}
proc md5HmacHex(key, message: openArray[byte]): string {....raises: [], tags: [],
    forbids: [].}
proc md5HmacHex(key, message: string): string {....raises: [], tags: [],
    forbids: [].}
proc sha1Hmac(key, message: openArray[byte]): Sha1Hmac {....raises: [], tags: [],
    forbids: [].}
proc sha1Hmac(key, message: string): Sha1Hmac {....raises: [], tags: [],
    forbids: [].}
proc sha1HmacHex(key, message: openArray[byte]): string {....raises: [], tags: [],
    forbids: [].}
proc sha1HmacHex(key, message: string): string {....raises: [], tags: [],
    forbids: [].}
proc sha256(message: openArray[byte]): Sha256Digest {....raises: [], tags: [],
    forbids: [].}
proc sha256(message: string): Sha256Digest {....raises: [], tags: [], forbids: [].}
proc sha256Hex(message: openArray[byte]): string {....raises: [], tags: [],
    forbids: [].}
proc sha256Hex(message: string): string {....raises: [], tags: [], forbids: [].}
proc sha256Hmac(key, message: openArray[byte]): Sha256Hmac {....raises: [],
    tags: [], forbids: [].}
proc sha256Hmac(key, message: string): Sha256Hmac {....raises: [], tags: [],
    forbids: [].}
proc sha256HmacHex(key, message: openArray[byte]): string {....raises: [],
    tags: [], forbids: [].}
proc sha256HmacHex(key, message: string): string {....raises: [], tags: [],
    forbids: [].}
proc sha384(message: openArray[byte]): Sha384Digest {....raises: [], tags: [],
    forbids: [].}
proc sha384(message: string): Sha384Digest {....raises: [], tags: [], forbids: [].}
proc sha384Hex(message: openArray[byte]): string {....raises: [], tags: [],
    forbids: [].}
proc sha384Hex(message: string): string {....raises: [], tags: [], forbids: [].}
proc sha384Hmac(key, message: openArray[byte]): Sha384Hmac {....raises: [],
    tags: [], forbids: [].}
proc sha384Hmac(key, message: string): Sha384Hmac {....raises: [], tags: [],
    forbids: [].}
proc sha384HmacHex(key, message: openArray[byte]): string {....raises: [],
    tags: [], forbids: [].}
proc sha384HmacHex(key, message: string): string {....raises: [], tags: [],
    forbids: [].}
proc sha512(message: openArray[byte]): Sha512Digest {....raises: [], tags: [],
    forbids: [].}
proc sha512(message: string): Sha512Digest {....raises: [], tags: [], forbids: [].}
proc sha512Hex(message: openArray[byte]): string {....raises: [], tags: [],
    forbids: [].}
proc sha512Hex(message: string): string {....raises: [], tags: [], forbids: [].}
proc sha512Hmac(key, message: openArray[byte]): Sha512Hmac {....raises: [],
    tags: [], forbids: [].}
proc sha512Hmac(key, message: string): Sha512Hmac {....raises: [], tags: [],
    forbids: [].}
proc sha512HmacHex(key, message: openArray[byte]): string {....raises: [],
    tags: [], forbids: [].}
proc sha512HmacHex(key, message: string): string {....raises: [], tags: [],
    forbids: [].}
proc update(state: var Blake2b; chunk: openArray[byte]) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Blake2b; chunk: string) {....raises: [ValueError], tags: [],
    forbids: [].}
proc update(state: var Md5HmacState; message: openArray[byte]) {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc update(state: var Md5HmacState; message: string) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Md5State; message: openArray[byte]) {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc update(state: var Md5State; message: string) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Sha256HmacState; message: openArray[byte]) {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc update(state: var Sha256HmacState; message: string) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Sha256State; message: openArray[byte]) {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc update(state: var Sha256State; message: string) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Sha384HmacState; message: openArray[byte]) {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc update(state: var Sha384HmacState; message: string) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Sha384State; message: openArray[byte]) {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc update(state: var Sha384State; message: string) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Sha512HmacState; message: openArray[byte]) {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc update(state: var Sha512HmacState; message: string) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Sha512State; message: openArray[byte]) {.
    ...raises: [ValueError], tags: [], forbids: [].}
proc update(state: var Sha512State; message: string) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Xxh3_64; chunk: openArray[byte]) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Xxh3_64; chunk: string) {....raises: [ValueError], tags: [],
    forbids: [].}
proc update(state: var Xxh3_128; chunk: openArray[byte]) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Xxh3_128; chunk: string) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Xxh32; chunk: openArray[byte]) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Xxh32; chunk: string) {....raises: [ValueError], tags: [],
    forbids: [].}
proc update(state: var Xxh64; chunk: openArray[byte]) {....raises: [ValueError],
    tags: [], forbids: [].}
proc update(state: var Xxh64; chunk: string) {....raises: [ValueError], tags: [],
    forbids: [].}
proc verifyDigest(a, b: openArray[byte]): bool {....raises: [], tags: [],
    forbids: [].}
Constant-time comparison of two digests. 
proc xxh3_64bits(data: openArray[byte]; seed: uint64 = 0): uint64 {....raises: [],
    tags: [], forbids: [].}
proc xxh3_64bits(data: string; seed: uint64 = 0): uint64 {....raises: [], tags: [],
    forbids: [].}
proc xxh3_64bitsHex(data: openArray[byte]; seed: uint64 = 0): string {.
    ...raises: [], tags: [], forbids: [].}
proc xxh3_64bitsHex(data: string; seed: uint64 = 0): string {....raises: [],
    tags: [], forbids: [].}
proc xxh32(data: openArray[byte]; seed: uint32 = 0): uint32 {....raises: [],
    tags: [], forbids: [].}
proc xxh32(data: string; seed: uint32 = 0): uint32 {....raises: [], tags: [],
    forbids: [].}
proc xxh32Hex(data: openArray[byte]; seed: uint32 = 0): string {....raises: [],
    tags: [], forbids: [].}
proc xxh32Hex(data: string; seed: uint32 = 0): string {....raises: [], tags: [],
    forbids: [].}
proc xxh64(data: openArray[byte]; seed: uint64 = 0): uint64 {....raises: [],
    tags: [], forbids: [].}
proc xxh64(data: string; seed: uint64 = 0): uint64 {....raises: [], tags: [],
    forbids: [].}
proc xxh64Hex(data: openArray[byte]; seed: uint64 = 0): string {....raises: [],
    tags: [], forbids: [].}
proc xxh64Hex(data: string; seed: uint64 = 0): string {....raises: [], tags: [],
    forbids: [].}
proc xxh128(data: openArray[byte]; seed: uint64 = 0): xxhAlgo.Xxh128 {.
    ...raises: [], tags: [], forbids: [].}
proc xxh128(data: string; seed: uint64 = 0): xxhAlgo.Xxh128 {....raises: [],
    tags: [], forbids: [].}
proc xxh128Hex(data: openArray[byte]; seed: uint64 = 0): string {....raises: [],
    tags: [], forbids: [].}
proc xxh128Hex(data: string; seed: uint64 = 0): string {....raises: [], tags: [],
    forbids: [].}

Made with Nim. Generated: 2026-09-28 19:45:57 UTC