8. 源代码 (The Source Code)
以下小节提供 FNV-1a 的参考 C 源代码 [C], 以及带命令行接口的测试驱动程序.
第 8.2 节提供 FNV 函数的 C 头文件和源代码文件. 第 8.3 节提供测试驱动程序. 第 8.4 节提供一个简单的 makefile, 用于构建测试驱动程序, 或构建包含所有 FNV 长度函数的库文件.
32-bit 和 64-bit FNV 的替代源代码可在 [LCN2] 获取. 其他替代源代码, 包括 x86 汇编版本, 当前可在 [FNV] 获取. 在某些情况下, 这些额外源代码已经进一步优化.
8.1. 源代码细节 (Source Code Details)
8.1.1. 可用的 FNV 函数 (FNV Functions Available)
提供的函数如下所列. 函数名中的 "xxx" 根据 FNV 长度分别为 "32", "64", "128", "256", "512" 或 "1024". 所有 FNV 哈希函数的返回值都是一个整数, 其含义在 FNVErrorCodes.h 中规定.
所有长度都提供字节向量哈希函数. 对于 FNV-32, 还提供返回 32-bit 整数的版本, 通过将 "xxx" 替换为 "32INT" 来标识. 例如, FNV32string 提供 4-byte 向量, 而 FNV32INTstring 提供 32-bit 整数. 对于 FNV-64, 如果编译时启用了 64-bit 整数 (即定义了 FNV_64bitIntegers; 见 FNVconfig.h), 也提供返回 64-bit 整数的版本, 通过将 "xxx" 替换为 "64INT" 来标识. 提供整数哈希的版本在不同字节序系统之间不兼容 (见第 2.3 节).
如果要从本文档复制源代码, 请注意在 ".txt" 版本中代码缩进了三个空格. 从本文档的 ".html" 版本复制可能最简单.
FNVxxxstring, FNVxxxblock, FNVxxxfile:
FNVxxxstringBasis, FNVxxxblockBasis, FNVxxxfileBasis:
FNVxxxINTstring, FNVxxxINTblock, FNVxxxINTfile:
FNVxxxINTstringBasis, FNVxxxINTblockBasis, FNVxxxINTfileBasis: 这些是简单函数, 分别直接返回零终止字节字符串 (不包括该零字节) 的 FNV 哈希, 字节计数块的 FNV 哈希, 以及文件的 FNV 哈希. 名称带有 "Basis" 后缀的函数接受一个额外参数, 用于指定 offset_basis. 注意, 对于支持相应大小整数且整数数据类型输出可接受的 FNV-32 和 FNV-64 应用, 代码足够简单. 为了最大化性能, 使用开放编码或宏可能比调用子例程更合适.
FNVxxxinit, FNVxxxinitBasis:
FNVxxxINTinitBasis: 这些函数以及下面两组函数提供增量计算 FNV 哈希的能力. 它们都假定有一个 FNVxxxcontext 类型的数据结构, 用于保存哈希的当前状态. FNVxxxinit 将该上下文初始化为标准 offset_basis. FNVxxxinitBasis 接受一个 offset_basis 值作为参数, 可用于第 4 节所述的串接哈希, 也可用于简单地使用非标准 offset_basis.
FNVxxxblockin, FNVxxxstringin, FNVxxxfilein: 这些函数将一串字节哈希进最初由 FNVxxxinit 或 FNVxxxinitBasis 初始化的 FNVxxxcontext. FNVxxxblockin 对一个计数字节块进行哈希. FNVxxxstringin 对零终止字节字符串进行哈希, 不包括最后的零字节. FNVxxxfilein 对文件内容进行哈希.
FNVxxxresult, FNVxxxINTresult: 该函数从 FNVxxxcontext 中提取最终 FNV 哈希结果.
8.1.2. 源文件和 64-bit 支持 (Source Files and 64-Bit Support)
根据是否定义 FNV_64bitIntegers 符号, 提供针对 64-bit 整数支持优化的代码, 即支持 64-bit 整数加法, 以及产生 64-bit 乘积的 32-bit x 32-bit 乘法. 默认情况下, 该设置会在 FNVconfig.h 中根据编译目标设置. 但也可以通过编辑该文件, 或在调用编译的命令行中定义某些符号来覆盖此设置.
对于应用程序中支持单一 FNV 长度, 例如 "xxx" (如 FNV64), 应用程序本身需要包含适当的 FNVxxx.h 文件 (该文件又会包含 FNVconfig.h 和 FNVErrorCodes.h). 要构建特定的 FNVxxx 代码本身, 需在编译器可用以下文件的情况下编译 FNVxxx.c: FNVconfig.h, fnv-private.h, FNVErrorCodes.h 和 FNVxxx.h. 见第 8.2 节. 由于第 8.3 节提供的测试程序使用所有 FNV 长度, 因此编译它需要所有 .c 和 .h 文件.
8.1.3. 命令行接口 (Command Line Interface)
第 8.3 节提供的测试程序具有命令行接口. 默认情况下, 在没有命令行参数时, 它会运行所有 FNV 长度的测试. 命令行选项如下:
FNVhash [-a] [-h] [-t nnn] [-u nnn] [-v] [-f filename] [token ...]
选项字母的含义如下:
-a: 运行所有长度的测试.
-h: 打印有关命令行的帮助消息.
-v: 反转 Verbose 标志, 该标志初始为关闭. 标志打开时, 程序会在测试等过程中打印更多信息.
-t nnn: 运行长度 nnn 的测试, nnn 必须是 32, 64, 128, 256, 512 或 1024 之一.
-u nnn: 使用哈希大小 nnn, nnn 必须是 32, 64, 128, 256, 512 或 1024 之一. 这对于设置 -f 选项使用的哈希大小, 或设置选项之后命令行 token 哈希所用的哈希大小很有用.
-f filename: 对名为 filename 的文件内容进行哈希. 哈希大小必须已经由命令行中先前的 -t 或 -u 选项设置.
token: 出现在选项之后的命令行 token 将使用当前哈希大小进行哈希, 该哈希大小必须已经由命令行中先前的 -t 或 -u 选项设置.
例如:
FNVhash -t 128 -h -v -t 64 -v -u 256 -f foobar.txt RabOof 1234
该命令会先运行 FNV128 测试, 然后打印命令行帮助消息, 然后打开 Verbose, 然后运行 FNV64 测试, 然后关闭 Verbose, 然后将哈希大小设置为 256, 然后对文件 foobar.txt 的内容进行哈希, 然后对 token "RabOof" 进行哈希, 最后对 token "1234" 进行哈希.
8.2. FNV-1a C 代码 (FNV-1a C Code)
本节提供本文档指定的每种长度的直接 FNV-1a 函数.
以下是配置头文件, 用于设置是否支持 64-bit 整数, 并建立用于返回值的枚举.
<CODE BEGINS> file "FNVconfig.h"
//************************ FNVconfig.h **************************//
//**************** See RFC 9923 for details. ********************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
#ifndef _FNVconfig_H_
#define _FNVconfig_H_
/*
* Description:
* This file provides configuration ifdefs for the
* FNV-1a non-cryptographic hash algorithms. */
/* FNV_64bitIntegers - Define this if your system supports
* 64-bit arithmetic including 32-bit x 32-bit
* multiplication producing a 64-bit product. If
* undefined, it will be assumed that 32-bit arithmetic
* is supported including 16-bit x 16-bit multiplication
* producing a 32-bit result.
*/
#include <stdint.h>
/* Check if 64-bit integers are supported in the target */
#ifdef UINT64_MAX
#define FNV_64bitIntegers
#else
#undef FNV_64bitIntegers
#endif
/* The following allows overriding the
* above configuration setting.
*/
#ifdef FNV_TEST_PROGRAM
# ifdef TEST_FNV_64bitIntegers
# ifndef FNV_64bitIntegers
# define FNV_64bitIntegers
# endif
# else
# undef FNV_64bitIntegers
# endif
# ifndef FNV_64bitIntegers /* causes an error if uint64_t is used */
# undef uint64_t
# define uint64_t no_64_bit_integers
# endif
#endif
#endif /* _FNVconfig_H_ */
<CODE ENDS>
The following code is a simple header file to define the return value
error codes for the FNV routines.
<CODE BEGINS> file "FNVErrorCodes.h"
//********************** FNVErrorCodes.h **************************//
//**************** See RFC 9923 for details. **********************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
#ifndef _FNV_ErrCodes_
#define _FNV_ErrCodes_
//****************************************************************//
//
// All FNV functions, except the FNVxxxfile functions,
// return an integer as follows:
// 0 -> success
// >0 -> error as listed below
//
enum { /* success and errors */
fnvSuccess = 0,
fnvNull, // 1 Null pointer parameter
fnvStateError, // 2 called Input after Result or before Init
fnvBadParam // 3 passed a bad parameter
};
#endif /* _FNV_ErrCodes_ */
<CODE ENDS>
The following code is a private header file that is used by all the
FNV functions further below and that states the terms for use and
redistribution of all of this source code.
<CODE BEGINS> file "fnv-private.h"
//************************ fnv-private.h **************************//
//****************** See RFC 9923 for details. ********************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* * Neither the name of Internet Society, IETF or IETF Trust, nor
* the names of specific contributors, may be used to endorse or
* promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef _FNV_PRIVATE_H_
#define _FNV_PRIVATE_H_
/*
* Six FNV-1a hashes are defined with these sizes:
* FNV32 32 bits, 4 bytes
* FNV64 64 bits, 8 bytes
* FNV128 128 bits, 16 bytes
* FNV256 256 bits, 32 bytes
* FNV512 512 bits, 64 bytes
* FNV1024 1024 bits, 128 bytes
*/
/* Private stuff used by this implementation of the FNV
* (Fowler/Noll/Vo) non-cryptographic hash function FNV-1a.
* External callers don't need to know any of this. */
enum { /* State value bases for context->Computed */
FNVinited = 22,
FNVcomputed = 76,
FNVemptied = 220,
FNVclobber = 122 /* known bad value for testing */
};
/* Deltas to assure distinct state values for different lengths */
enum {
FNV32state = 1,
FNV64state = 3,
FNV128state = 5,
FNV256state = 7,
FNV512state = 11,
FNV1024state = 13
};
#endif /* _FNV_PRIVATE_H_ */
<CODE ENDS>
8.2.1. FNV32 Code
The following code is the header and C source for 32-bit FNV-1a
providing a 32-bit integer or 4-byte vector hash.
<CODE BEGINS> file "FNV32.h"
//*************************** FNV32.h ****************************//
//****************** See RFC 9923 for details. *******************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
#ifndef _FNV32_H_
#define _FNV32_H_
/*
* Description:
* This file provides headers for the 32-bit version of
* the FNV-1a non-cryptographic hash algorithm.
*/
#include "FNVconfig.h"
#include "FNVErrorCodes.h"
#include <stdint.h>
#define FNV32size (32/8)
#define FNV32basis 0x811C9DC5
/* If you do not have the ISO standard stdint.h header file, then
* you must typedef the following types:
*
* type meaning
* uint32_t unsigned 32-bit integer
* uint8_t unsigned 8-bit integer (i.e., unsigned char)
*/
/*
* This structure holds context information for an FNV32 hash
*/
typedef struct FNV32context_s {
int Computed; /* state */
uint32_t Hash;
} FNV32context;
/* Function Prototypes:
*
* FNV32string: hash a zero-terminated string not including
* the terminating zero
* FNV32stringBasis: also takes an offset_basis parameter
*
* FNV32block: hash a byte vector of a specified length
* FNV32blockBasis: also takes an offset_basis parameter
*
* FNV32file: hash the contents of a file
* FNV32fileBasis: also takes an offset_basis parameter
*
* FNV32init: initializes an FNV32 context
* FNV32initBasis: initializes an FNV32 context with a
* provided 4-byte vector basis
* FNV32blockin: hash in a byte vector of a specified length
* FNV32stringin: hash in a zero-terminated string not
* including the terminating zero
* FNV32filein: hash in the contents of a file
* FNV32result: returns the hash value
*
* Hash is returned as a 4-byte vector by the functions above,
* and the following return a 32-bit unsigned integer:
*
* FNV32INTstring: hash a zero-terminated string not including
* the terminating zero
* FNV32INTstringBasis: also takes an offset_basis parameter
*
* FNV32INTblock: hash a byte vector of a specified length
* FNV32INTblockBasis: also takes an offset_basis parameter
*
* FNV32INTfile: hash the contents of a file
* FNV32INTfileBasis: also takes an offset_basis parameter
*
* FNV32INTinitBasis: initializes an FNV32 context with a
* provided 32-bit integer basis
* FNV32INTresult: returns the hash value
*/
#ifdef __cplusplus
extern "C" {
#endif
/* FNV32 */
extern int FNV32INTstring ( const char *in,
uint32_t * const out );
extern int FNV32INTstringBasis ( const char *in,
uint32_t * const out,
uint32_t basis );
extern int FNV32string ( const char *in,
uint8_t out[FNV32size] );
extern int FNV32stringBasis ( const char *in,
uint8_t out[FNV32size],
const uint8_t basis[FNV32size] );
extern int FNV32INTblock ( const void *vin,
long int length,
uint32_t * const out );
extern int FNV32INTblockBasis ( const void *vin,
long int length,
uint32_t * const out,
uint32_t basis );
extern int FNV32block ( const void *vin,
long int length,
uint8_t out[FNV32size] );
extern int FNV32blockBasis ( const void *vin,
long int length,
uint8_t out[FNV32size],
const uint8_t basis[FNV32size] );
extern int FNV32INTfile ( const char *fname,
uint32_t * const out );
extern int FNV32INTfileBasis ( const char *fname,
uint32_t * const out,
uint32_t basis );
extern int FNV32file ( const char *fname,
uint8_t out[FNV32size] );
extern int FNV32fileBasis ( const char *fname,
uint8_t out[FNV32size],
const uint8_t basis[FNV32size] );
extern int FNV32init ( FNV32context * const );
extern int FNV32INTinitBasis ( FNV32context * const,
uint32_t basis );
extern int FNV32initBasis ( FNV32context * const,
const uint8_t basis[FNV32size] );
extern int FNV32blockin ( FNV32context * const,
const void *vin,
long int length );
extern int FNV32stringin ( FNV32context * const,
const char *in );
extern int FNV32filein ( FNV32context * const,
const char *fname );
extern int FNV32INTresult ( FNV32context * const,
uint32_t * const out );
extern int FNV32result ( FNV32context * const,
uint8_t out[FNV32size] );
#ifdef __cplusplus
}
#endif
#endif /* _FNV32_H_ */
<CODE ENDS>
<CODE BEGINS> file "FNV32.c"
//************************** FNV32.c **************************//
//**************** See RFC 9923 for details. ******************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
/* This code implements the FNV (Fowler/Noll/Vo) non-cryptographic
* hash function FNV-1a for 32-bit hashes.
*/
#include <stdio.h>
#include "fnv-private.h"
#include "FNV32.h"
/* 32-bit FNV_prime = 2^24 + 2^8 + 0x93 */
#define FNV32prime 0x01000193
/* FNV32: hash a zero-terminated string not including the zero
*****************************************************************/
int FNV32INTstring ( const char *in, uint32_t * const out ) {
return FNV32INTstringBasis ( in, out, FNV32basis );
} /* end FNV32INTstring */
/* FNV32: hash a zero-terminated string not including the zero
* with a non-standard basis
*****************************************************************/
int FNV32INTstringBasis ( const char *in,
uint32_t * const out,
uint32_t basis ) {
uint8_t ch;
if ( !in || !out )
return fnvNull; /* Null input pointer */
while ( (ch = *in++) )
basis = FNV32prime * ( basis ^ ch );
*out = basis;
return fnvSuccess;
} /* end FNV32INTstringBasis */
/* FNV32: hash a zero-terminated string not including the zero
*****************************************************************/
int FNV32string ( const char *in, uint8_t out[FNV32size] ) {
uint32_t temp;
uint8_t ch;
if ( !in || !out )
return fnvNull; /* Null input pointer */
temp = FNV32basis;
while ( (ch = *in++) )
temp = FNV32prime * ( temp ^ ch );
for ( int i=0; i<FNV32size; ++i )
out[i] = ((uint8_t *)&temp)[i];
return fnvSuccess;
} /* end FNV32string */
/* FNV32: hash a zero-terminated string not including the zero
* with a non-standard basis
*****************************************************************/
int FNV32stringBasis ( const char *in,
uint8_t out[FNV32size],
const uint8_t basis[FNV32size] ) {
uint32_t temp;
int i;
uint8_t ch;
if ( !in || !out || !basis )
return fnvNull; /* Null input pointer */
temp = basis[0]+(basis[1]<<8)+(basis[2]<<16)+(basis[3]<<24);
while ( (ch = *in++) )
temp = FNV32prime * ( temp ^ ch );
out[0] = temp & 0xFF;
for ( i=1; i<FNV32size; ++i ) {
temp >>= 8;
out[i] = temp & 0xFF;
}
return fnvSuccess;
} /* end FNV32stringBasis */
/* FNV32: hash a counted block returning an integer
****************************************************************/
int FNV32INTblock ( const void *vin,
long int length,
uint32_t * const out ) {
return FNV32INTblockBasis ( vin, length, out, FNV32basis );
} /* end FNV32INTblock */
/* FNV32: hash a counted block with a non-standard basis
****************************************************************/
int FNV32INTblockBasis ( const void *vin,
long int length,
uint32_t * const out,
uint32_t basis ) {
const uint8_t *in = (const uint8_t*)vin;
uint32_t temp;
if ( !in || !out )
return fnvNull; /* Null input pointer */
if ( length < 0 )
return fnvBadParam;
for ( temp = basis; length > 0; length-- )
temp = FNV32prime * ( temp ^ *in++ );
*out = temp;
return fnvSuccess;
} /* end FNV32INTblockBasis */
/* FNV32: hash a counted block returning a 4-byte vector
****************************************************************/
int FNV32block ( const void *vin,
long int length,
uint8_t out[FNV32size] ) {
const uint8_t *in = (const uint8_t*)vin;
uint32_t temp;
if ( !in || !out )
return fnvNull; /* Null input pointer */
if ( length < 0 )
return fnvBadParam;
for ( temp = FNV32basis; length > 0; length-- )
temp = FNV32prime * ( temp ^ *in++ );
for ( int i=0; i<FNV32size; ++i )
out[i] = ((uint8_t *)&temp)[i];
return fnvSuccess;
} /* end FNV32block */
/* FNV32: hash a counted block with a non-standard basis
****************************************************************/
int FNV32blockBasis ( const void *vin,
long int length,
uint8_t out[FNV32size],
const uint8_t basis[FNV32size] ) {
const uint8_t *in = (const uint8_t*)vin;
uint32_t temp;
if ( !in || !out || !basis )
return fnvNull; /* Null input pointer */
if ( length < 0 )
return fnvBadParam;
temp = basis[0]+(basis[1]<<8)+(basis[2]<<16)+(basis[3]<<24);
for ( ; length > 0; length-- )
temp = FNV32prime * ( temp ^ *in++ );
for ( int i=0; i<FNV32size; ++i )
out[i] = ((uint8_t *)&temp)[i];
return fnvSuccess;
} /* end FNV32blockBasis */
/* hash the contents of a file, return 32-bit integer
******************************************************************/
int FNV32INTfile ( const char *fname,
uint32_t * const out ) {
return FNV32INTfileBasis ( fname, out, FNV32basis );
} /* end FNV32INTfile */
/* hash the contents of a file, return 32-bit integer
* with a non-standard basis
******************************************************************/
int FNV32INTfileBasis ( const char *fname,
uint32_t * const out,
uint32_t basis ) {
FNV32context e32Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV32INTinitBasis ( &e32Context, basis )) )
return error;
if ( (error = FNV32filein ( &e32Context, fname )) )
return error;
return FNV32INTresult ( &e32Context, out );
} /* end FNV32INTfileBasis */
/* hash the contents of a file, return 4-byte vector
******************************************************************/
int FNV32file ( const char *fname,
uint8_t out[FNV32size] ) {
FNV32context e32Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV32init (&e32Context)) )
return error;
if ( (error = FNV32filein ( &e32Context, fname)) )
return error;
return FNV32result ( &e32Context, out );
} /* end FNV32file */
/* hash the contents of a file, return 4-byte vector
* with a non-standard basis
******************************************************************/
int FNV32fileBasis ( const char *fname,
uint8_t out[FNV32size],
const uint8_t basis[FNV32size] ) {
FNV32context e32Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV32initBasis (&e32Context, basis)) )
return error;
if ( (error = FNV32filein ( &e32Context, fname)) )
return error;
return FNV32result ( &e32Context, out );
} /* end FNV32fileBasis */
//**************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV32
//**************************************************************
/* initialize context
***************************************************************/
int FNV32init ( FNV32context * const ctx ) {
return FNV32INTinitBasis ( ctx, FNV32basis );
} /* end FNV32init */
/* initialize context with a provided 32-bit integer basis
***************************************************************/
int FNV32INTinitBasis ( FNV32context * const ctx,
uint32_t basis ) {
if ( !ctx )
return fnvNull;
ctx->Hash = basis;
ctx->Computed = FNVinited+FNV32state;
return fnvSuccess;
} /* end FNV32INTinitBasis */
/* initialize context with a provided 4-byte vector basis
***************************************************************/
int FNV32initBasis ( FNV32context * const ctx,
const uint8_t basis[FNV32size] ) {
if ( !ctx || !basis )
return fnvNull;
ctx->Hash =
basis[0]+(basis[1]<<8)+(basis[2]<<16)+(basis[3]<<24);
ctx->Computed = FNVinited+FNV32state;
return fnvSuccess;
} /* end FNV32initBasis */
/* hash in a counted block
***************************************************************/
int FNV32blockin ( FNV32context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint32_t temp;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV32state:
ctx->Computed = FNVcomputed+FNV32state;
break;
case FNVcomputed+FNV32state:
break;
default:
return fnvStateError;
}
for ( temp = ctx->Hash; length > 0; length-- )
temp = FNV32prime * ( temp ^ *in++ );
ctx->Hash = temp;
return fnvSuccess;
} /* end FNV32blockin */
/* hash in a zero-terminated string not including the zero
***************************************************************/
int FNV32stringin ( FNV32context * const ctx, const char *in ) {
uint32_t temp;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV32state:
ctx->Computed = FNVcomputed+FNV32state;
break;
case FNVcomputed+FNV32state:
break;
default:
return fnvStateError;
}
temp = ctx->Hash;
while ( (ch = (uint8_t)*in++) )
temp = FNV32prime * ( temp ^ ch );
ctx->Hash = temp;
return fnvSuccess;
} /* end FNV32stringin */
/* hash in the contents of a file
******************************************************************/
int FNV32filein ( FNV32context * const e32Context,
const char *fname ) {
FILE *fp;
long int i;
char buf[1024];
int error;
if ( !e32Context || !fname )
return fnvNull;
switch ( e32Context->Computed ) {
case FNVinited+FNV32state:
e32Context->Computed = FNVcomputed+FNV32state;
break;
case FNVcomputed+FNV32state:
break;
default:
return fnvStateError;
}
if ( ( fp = fopen ( fname, "rb") ) == NULL )
return fnvBadParam;
if ( (error = FNV32blockin ( e32Context, "", 0)) ) {
fclose(fp);
return error;
}
while ( ( i = fread ( buf, 1, sizeof(buf), fp ) ) > 0 )
if ( (error = FNV32blockin ( e32Context, buf, i)) ) {
fclose(fp);
return error;
}
error = ferror(fp);
fclose(fp);
if (error) return fnvBadParam;
return fnvSuccess;
} /* end FNV32filein */
/* return hash as an integer
***************************************************************/
int FNV32INTresult ( FNV32context * const ctx,
uint32_t * const out ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV32state )
return fnvStateError;
ctx->Computed = FNVemptied+FNV32state;
*out = ctx->Hash;
ctx->Hash = 0;
return fnvSuccess;
} /* end FNV32INTresult */
/* return hash as a 4-byte vector
***************************************************************/
int FNV32result ( FNV32context * const ctx,
uint8_t out[FNV32size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV32state )
return fnvStateError;
ctx->Computed = FNVemptied+FNV32state;
for ( int i=0; i<FNV32size; ++i )
out[i] = ((uint8_t *)&ctx->Hash)[i];
ctx->Hash = 0;
return fnvSuccess;
} /* end FNV32result */
<CODE ENDS>
8.2.2. FNV64 Code
The following code is the header and C source for 64-bit FNV-1a
providing an 8-byte vector or, optionally, if 64-bit integers are
supported, a 64-bit integer hash.
<CODE BEGINS> file "FNV64.h"
//*************************** FNV64.h ****************************//
//***************** See RFC 9923 for details. ********************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
#ifndef _FNV64_H_
#define _FNV64_H_
/*
* Description:
* This file provides headers for the 64-bit version of
* the FNV-1a non-cryptographic hash algorithm.
*/
#include "FNVconfig.h"
#include "FNVErrorCodes.h"
#include <stdint.h>
#define FNV64size (64/8)
#ifdef FNV_64bitIntegers
#define FNV64basis 0xCBF29CE484222325
#endif
/* If you do not have the ISO standard stdint.h header file, then
* you must typedef the following types:
*
* type meaning
* uint64_t unsigned 64-bit integer (ifdef FNV_64bitIntegers)
* uint32_t unsigned 32-bit integer
* uint16_t unsigned 16-bit integer
* uint8_t unsigned 8-bit integer (i.e., unsigned char)
*/
/*
* This structure holds context information for an FNV64 hash
*/
#ifdef FNV_64bitIntegers
/* version if 64-bit integers supported */
typedef struct FNV64context_s {
int Computed; /* state */
uint64_t Hash;
} FNV64context;
#else
/* version if 64-bit integers NOT supported */
typedef struct FNV64context_s {
int Computed; /* state */
uint16_t Hash[FNV64size/2];
} FNV64context;
#endif /* FNV_64bitIntegers */
/* Function Prototypes:
*
* FNV64string: hash a zero-terminated string not including
* the terminating zero
* FNV64stringBasis: also takes an offset_basis parameter
*
* FNV64block: hash a byte vector of a specified length
* FNV64blockBasis: also takes an offset_basis parameter
*
* FNV64file: hash the contents of a file
* FNV64fileBasis: also takes an offset_basis parameter
*
* FNV64init: initializes an FNV64 context
* FNV64initBasis: initializes an FNV64 context with a
* provided 8-byte vector basis
* FNV64blockin: hash in a byte vector of a specified length
* FNV64stringin: hash in a zero-terminated string not
* including the terminating zero
* FNV64filein: hash in the contents of a file
* FNV64result: returns the hash value
*
* Hash is returned as an 8-byte vector by the functions above.
* If 64-bit integers are supported, the following return
* a 64-bit integer.
*
* FNV64INTstring: hash a zero-terminated string not including
* the terminating zero
* FNV64INTstringBasis: also takes an offset_basis parameter
*
* FNV64INTblock: hash a byte vector of a specified length
* FNV64INTblockBasis: also takes an offset_basis parameter
*
* FNV64INTfile: hash the contents of a file
* FNV64INTfileBasis: also takes an offset_basis parameter
*
* FNV64INTinitBasis: initializes an FNV64 context with a
* provided 64-bit integer basis
* FNV64INTresult: returns the hash value
*/
#ifdef __cplusplus
extern "C" {
#endif
/* FNV64 */
extern int FNV64string ( const char *in,
uint8_t out[FNV64size] );
extern int FNV64stringBasis ( const char *in,
uint8_t out[FNV64size],
const uint8_t basis[FNV64size] );
extern int FNV64block ( const void *vin,
long int length,
uint8_t out[FNV64size] );
extern int FNV64blockBasis ( const void *vin,
long int length,
uint8_t out[FNV64size],
const uint8_t basis[FNV64size] );
extern int FNV64file ( const char * fname,
uint8_t out[FNV64size] );
extern int FNV64fileBasis ( const char * fname,
uint8_t out[FNV64size],
const uint8_t basis[FNV64size] );
extern int FNV64init ( FNV64context * const );
extern int FNV64initBasis ( FNV64context * const,
const uint8_t basis[FNV64size] );
extern int FNV64blockin ( FNV64context * const,
const void * vin,
long int length );
extern int FNV64stringin ( FNV64context * const,
const char * in );
extern int FNV64filein ( FNV64context * const,
const char *fname );
extern int FNV64result ( FNV64context * const,
uint8_t out[FNV64size] );
#ifdef FNV_64bitIntegers
extern int FNV64INTstring ( const char *in,
uint64_t * const out );
extern int FNV64INTstringBasis ( const char *in,
uint64_t * const out,
uint64_t basis );
extern int FNV64INTblock ( const void *vin,
long int length,
uint64_t * const out );
extern int FNV64INTblockBasis ( const void *vin,
long int length,
uint64_t * const out,
uint64_t basis );
extern int FNV64INTfile ( const char * fname,
uint64_t * const out );
extern int FNV64INTfileBasis ( const char * fname,
uint64_t * const out,
uint64_t basis );
extern int FNV64INTinitBasis ( FNV64context * const,
uint64_t basis );
extern int FNV64INTresult ( FNV64context * const,
uint64_t * const out );
#endif /* FNV_64bitIntegers */
#ifdef __cplusplus
}
#endif
#endif /* _FNV64_H_ */
<CODE ENDS>
<CODE BEGINS> file "FNV64.c"
//*************************** FNV64.c ****************************//
//****************** See RFC 9923 for details. *******************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
/* This file implements the FNV (Fowler/Noll/Vo) non-cryptographic
* hash function FNV-1a for 64-bit hashes.
*/
#include <stdio.h>
#include "FNVconfig.h"
#include "fnv-private.h"
#include "FNV64.h"
//*****************************************************************
// CODE THAT IS THE SAME FOR 32-BIT and 64-BIT ARITHMETIC
//*****************************************************************
/* hash the contents of a file, return byte vector
******************************************************************/
int FNV64file ( const char *fname,
uint8_t out[FNV64size] ) {
FNV64context e64Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV64init (&e64Context)) )
return error;
if ( (error = FNV64filein (&e64Context, fname)) )
return error;
return FNV64result (&e64Context, out);
} /* end FNV64file */
/* hash the contents of a file, return 64-bit integer
* with a non-standard basis
******************************************************************/
int FNV64fileBasis ( const char *fname,
uint8_t out[FNV64size],
const uint8_t basis[FNV64size] ) {
FNV64context e64Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV64initBasis (&e64Context, basis)) )
return error;
if ( (error = FNV64filein (&e64Context, fname)) )
return error;
return FNV64result (&e64Context, out);
} /* end FNV64fileBasis */
/* hash in the contents of a file
******************************************************************/
int FNV64filein ( FNV64context * const e64Context,
const char *fname ) {
FILE *fp;
long int i;
char buf[1024];
int error;
if ( !e64Context || !fname )
return fnvNull;
switch ( e64Context->Computed ) {
case FNVinited+FNV64state:
e64Context->Computed = FNVcomputed+FNV64state;
break;
case FNVcomputed+FNV64state:
break;
default:
return fnvStateError;
}
if ( ( fp = fopen ( fname, "rb") ) == NULL )
return fnvBadParam;
if ( (error = FNV64blockin ( e64Context, "", 0)) ) {
fclose(fp);
return error;
}
while ( ( i = fread ( buf, 1, sizeof(buf), fp ) ) > 0 )
if ( (error = FNV64blockin ( e64Context, buf, i)) ) {
fclose(fp);
return error;
}
error = ferror(fp);
fclose(fp);
if (error)
return fnvBadParam;
return fnvSuccess;
}
//*****************************************************************
// START VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//*****************************************************************
#ifdef FNV_64bitIntegers
/* 64-bit FNV_prime = 2^40 + 2^8 + 0xb3 */
#define FNV64prime 0x00000100000001B3
/* FNV64: hash a zero-terminated string not including the zero
* to a 64-bit integer (64-bit)
******************************************************************/
int FNV64INTstring ( const char *in, uint64_t * const out ) {
return FNV64INTstringBasis ( in, out, FNV64basis );
} /* end FNV64INTstring */
/* FNV64: hash a zero-terminated string not including the zero
* to a 64-bit integer (64-bit) with a non-standard basis
******************************************************************/
int FNV64INTstringBasis ( const char *in,
uint64_t * const out,
uint64_t basis ) {
uint64_t temp;
uint8_t ch;
if ( !in || !out )
return fnvNull; /* Null input pointer */
temp = basis;
while ( (ch = *in++) )
temp = FNV64prime * ( temp ^ ch );
*out = temp;
return fnvSuccess;
} /* end FNV64INTstringBasis */
/* FNV64: hash a zero-terminated string to a 64-bit integer
* to a byte vector (64-bit)
******************************************************************/
int FNV64string ( const char *in, uint8_t out[FNV64size] ) {
uint64_t temp;
uint8_t ch;
if ( !in || !out )
return fnvNull; /* Null input pointer */
temp = FNV64basis;
while ( (ch = *in++) )
temp = FNV64prime * ( temp ^ ch );
for ( int i=0; i<FNV64size; ++i )
out[i] = ((uint8_t *)&temp)[i];
return fnvSuccess;
} /* end FNV64string */
/* FNV64: hash a zero-terminated string to a 64-bit integer
* to a byte vector (64-bit) with a non-standard basis
******************************************************************/
int FNV64stringBasis ( const char *in,
uint8_t out[FNV64size],
const uint8_t basis[FNV64size] ) {
uint64_t temp;
int i;
uint8_t ch;
if ( !in || !out || !basis )
return fnvNull; /* Null input pointer */
temp = basis[7];
for ( i = FNV64size-2; i>=0; --i )
temp = (temp<<8) + basis[i];
while ( (ch = *in++) )
temp = FNV64prime * ( temp ^ ch );
for ( i=0; i<FNV64size; ++i )
out[i] = ((uint8_t *)&temp)[i];
return fnvSuccess;
} /* end FNV64stringBasis */
/* FNV64: hash a counted block to a 64-bit integer (64-bit)
******************************************************************/
int FNV64INTblock ( const void *vin,
long int length,
uint64_t * const out ) {
return FNV64INTblockBasis ( vin, length, out, FNV64basis );
} /* end FNV64INTblock */
/* FNV64: hash a counted block to a 64-bit integer (64-bit)
* with a non-standard basis
******************************************************************/
int FNV64INTblockBasis ( const void *vin,
long int length,
uint64_t * const out,
uint64_t basis ) {
const uint8_t *in = (const uint8_t*)vin;
uint64_t temp;
if ( !in || !out )
return fnvNull;
/* Null input pointer or null output pointer */
if ( length < 0 )
return fnvBadParam;
for ( temp = basis; length > 0; length-- )
temp = FNV64prime * ( temp ^ *in++ );
*out = temp;
return fnvSuccess;
} /* end FNV64INTblockBasis */
/* FNV64: hash a counted block to a byte vector (64-bit)
******************************************************************/
int FNV64block ( const void *vin,
long int length,
uint8_t out[FNV64size] ) {
const uint8_t *in = (const uint8_t*)vin;
uint64_t temp;
if ( !in || !out )
return fnvNull;
/* Null input pointer or null output pointer */
if ( length < 0 )
return fnvBadParam;
for ( temp = FNV64basis; length > 0; length-- )
temp = FNV64prime * ( temp ^ *in++ );
for ( int i=0; i<FNV64size; ++i )
out[i] = ((uint8_t *)&temp)[i];
return fnvSuccess;
} /* end FNV64block */
/* FNV64: hash a counted block to a byte vector (64-bit)
* with a non-standard basis
******************************************************************/
int FNV64blockBasis ( const void *vin,
long int length,
uint8_t out[FNV64size],
const uint8_t basis[FNV64size] ) {
const uint8_t *in = (const uint8_t*)vin;
uint64_t temp;
int i;
if ( !in || !out || !basis )
return fnvNull;
/* Null input pointer or null output pointer */
if ( length < 0 )
return fnvBadParam;
temp = basis[7];
for ( i = FNV64size-2; i>=0; --i )
temp = (temp<<8) + basis[i];
for (; length > 0; length-- )
temp = FNV64prime * ( temp ^ *in++ );
for ( i=0; i<FNV64size; ++i )
out[i] = ((uint8_t *)&temp)[i];
return fnvSuccess;
} /* end FNV64blockBasis */
//*****************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV64
//*****************************************************************
/* initialize context (64-bit)
******************************************************************/
int FNV64init( FNV64context * const ctx ) {
return FNV64INTinitBasis ( ctx, FNV64basis );
} /* end FNV64init */
/* initialize context with a provided 64-bit integer basis (64-bit)
******************************************************************/
int FNV64INTinitBasis( FNV64context * const ctx, uint64_t basis ) {
if ( !ctx )
return fnvNull;
ctx->Hash = basis;
ctx->Computed = FNVinited+FNV64state;
return fnvSuccess;
} /* end FNV64INTinitBasis */
/* initialize context with a provided 8-byte vector basis (64-bit)
******************************************************************/
int FNV64initBasis( FNV64context * const ctx,
const uint8_t basis[FNV64size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i<FNV64size; ++i )
((uint8_t *)&ctx->Hash)[i] = basis[i];
ctx->Computed = FNVinited+FNV64state;
return fnvSuccess;
} /* end FNV64initBasis */
/* hash in a counted block (64-bit)
******************************************************************/
int FNV64blockin( FNV64context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint64_t temp;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV64state:
ctx->Computed = FNVcomputed+FNV64state;
break;
case FNVcomputed+FNV64state:
break;
default:
return fnvStateError;
}
for ( temp = ctx->Hash; length > 0; length-- )
temp = FNV64prime * ( temp ^ *in++ );
ctx->Hash = temp;
return fnvSuccess;
} /* end FNV64blockin */
/* hash in a zero-terminated string not including the zero (64-bit)
******************************************************************/
int FNV64stringin ( FNV64context * const ctx, const char *in ) {
uint64_t temp;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV64state:
ctx->Computed = FNVcomputed+FNV64state;
break;
case FNVcomputed+FNV64state:
break;
default:
return fnvStateError;
}
temp = ctx->Hash;
while ( (ch = (uint8_t)*in++) )
temp = FNV64prime * ( temp ^ ch );
ctx->Hash = temp;
return fnvSuccess;
} /* end FNV64stringin */
/* return hash as 64-bit int (64-bit)
******************************************************************/
int FNV64INTresult ( FNV64context * const ctx,
uint64_t * const out ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV64state )
return fnvStateError;
ctx->Computed = FNVemptied+FNV64state;
*out = ctx->Hash;
ctx->Hash = 0;
return fnvSuccess;
} /* end FNV64INTresult */
/* return hash as 8-byte vector (64-bit)
******************************************************************/
int FNV64result ( FNV64context * const ctx,
uint8_t out[FNV64size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV64state )
return fnvStateError;
ctx->Computed = FNVemptied+FNV64state;
for ( int i=0; i<FNV64size; ++i )
out[i] = ((uint8_t *)&ctx->Hash)[i];
ctx->Hash = 0;
return fnvSuccess;
} /* end FNV64result */
/* hash the contents of a file, return 64-bit integer
******************************************************************/
int FNV64INTfile ( const char *fname,
uint64_t * const out ) {
FNV64context e64Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV64init (&e64Context)) )
return error;
if ( (error = FNV64filein (&e64Context, fname)) )
return error;
return FNV64INTresult ( &e64Context, out );
} /* end FNV64INTfile */
/* hash the contents of a file, return 64-bit integer
* with a non-standard basis
******************************************************************/
int FNV64INTfileBasis ( const char *fname,
uint64_t * const out,
uint64_t basis ) {
FNV64context e64Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV64INTinitBasis (&e64Context, basis)) )
return error;
if ( (error = FNV64filein (&e64Context, fname)) )
return error;
return FNV64INTresult ( &e64Context, out );
} /* end FNV64INTfileBasis */
//***************************************************************
// END VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//***************************************************************
#else /* FNV_64bitIntegers */
//***************************************************************
// START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//***************************************************************
/* 64-bit FNV_prime = 2^40 + 2^8 + 0xb3 */
/* #define FNV64prime 0x00000100000001B3 */
#define FNV64primeX 0x01B3
#define FNV64shift 8
/* FNV64: hash a zero-terminated string not including the zero
******************************************************************/
int FNV64string ( const char *in, uint8_t out[FNV64size] ) {
FNV64context ctx;
int error;
if ( (error = FNV64init (&ctx)) )
return error;
if ( (error = FNV64stringin (&ctx, in)) )
return error;
return FNV64result (&ctx, out);
} /* end FNV64string */
/* FNV64: hash a zero-terminated string not including the zero
* with a non-standard offset_basis
******************************************************************/
int FNV64stringBasis ( const char *in,
uint8_t out[FNV64size],
const uint8_t basis[FNV64size] ) {
FNV64context ctx;
int error;
if ( (error = FNV64initBasis (&ctx, basis)) )
return error;
if ( (error = FNV64stringin (&ctx, in)) )
return error;
return FNV64result (&ctx, out);
} /* end FNV64stringBasis */
/* FNV64: hash a counted block
******************************************************************/
int FNV64block ( const void *vin,
long int length,
uint8_t out[FNV64size] ) {
FNV64context ctx;
int error;
if ( (error = FNV64init (&ctx)) )
return error;
if ( (error = FNV64blockin (&ctx, vin, length)) )
return error;
return FNV64result (&ctx, out);
} /* end FNV64block */
/* FNV64: hash a counted block with a non-standard offset_basis
******************************************************************/
int FNV64blockBasis ( const void *vin,
long int length,
uint8_t out[FNV64size],
const uint8_t basis[FNV64size] ) {
FNV64context ctx;
int error;
if ( (error = FNV64initBasis (&ctx, basis)) )
return error;
if ( (error = FNV64blockin (&ctx, vin, length)) )
return error;
return FNV64result (&ctx, out);
} /* end FNV64blockBasis */
//*****************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV64
//*****************************************************************
/* initialize context (32-bit)
******************************************************************/
int FNV64init ( FNV64context * const ctx ) {
if ( !ctx )
return fnvNull;
ctx->Hash[0] = 0xCBF2;
ctx->Hash[1] = 0x9CE4;
ctx->Hash[2] = 0x8422;
ctx->Hash[3] = 0x2325;
ctx->Computed = FNVinited+FNV64state;
return fnvSuccess;
} /* end FNV64init */
/* initialize context with a non-standard basis (32-bit)
******************************************************************/
int FNV64initBasis ( FNV64context * const ctx,
const uint8_t basis[FNV64size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i < FNV64size/2; ++i ) {
uint32_t temp = *basis++;
ctx->Hash[i] = ( temp<<8 ) + *basis++;
}
ctx->Computed = FNVinited+FNV64state;
return fnvSuccess;
} /* end FNV64initBasis */
/* hash in a counted block (32-bit)
******************************************************************/
int FNV64blockin ( FNV64context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint32_t temp[FNV64size/2];
uint32_t temp2[2];
int i;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV64state:
ctx->Computed = FNVcomputed+FNV64state;
break;
case FNVcomputed+FNV64state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV64size/2; ++i )
temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) {
/* temp = FNV64prime * ( temp ^ *in++ ); */
temp[3] ^= *in++;
temp2[1] = temp[3] << FNV64shift;
temp2[0] = temp[2] << FNV64shift;
for ( i=0; i<4; ++i )
temp[i] *= FNV64primeX;
temp[1] += temp2[1];
temp[0] += temp2[0];
for ( i=2; i>=0; --i ) {
temp[i] += temp[i+1] >> 16;
temp[i+1] &= 0xFFFF;
}
}
for ( i=0; i<FNV64size/2; ++i )
ctx->Hash[i] = temp[i];
return fnvSuccess;
} /* end FNV64blockin */
/* hash in a zero-terminated string not including the zero (32-bit)
******************************************************************/
int FNV64stringin ( FNV64context * const ctx, const char *in ) {
uint32_t temp[FNV64size/2];
uint32_t temp2[2];
int i;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV64state:
ctx->Computed = FNVcomputed+FNV64state;
break;
case FNVcomputed+FNV64state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV64size/2; ++i )
temp[i] = ctx->Hash[i];
while ( ( ch = (uint8_t)*in++ ) ) {
/* temp = FNV64prime * ( temp ^ ch ); */
temp[3] ^= ch;
temp2[1] = temp[3] << FNV64shift;
temp2[0] = temp[2] << FNV64shift;
for ( i=0; i<4; ++i )
temp[i] *= FNV64primeX;
temp[1] += temp2[1];
temp[0] += temp2[0];
for ( i=2; i>=0; --i ) {
temp[i] += temp[i+1] >> 16;
temp[i+1] &= 0xFFFF;
}
}
for ( i=0; i<FNV64size/2; ++i )
ctx->Hash[i] = temp[i];
return fnvSuccess;
} /* end FNV64stringin */
/* return hash (32-bit)
******************************************************************/
int FNV64result ( FNV64context * const ctx,
uint8_t out[FNV64size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV64state )
return fnvStateError;
for ( int i=0; i<FNV64size/2; ++i ) {
out[2*i] = ctx->Hash[i] >> 8;
out[2*i+1] = ctx->Hash[i];
ctx -> Hash[i] = 0;
}
ctx->Computed = FNVemptied+FNV64state;
return fnvSuccess;
} /* end FNV64result */
#endif /* FNV_64bitIntegers */
//*****************************************************************
// END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//*****************************************************************
<CODE ENDS>
8.2.3. FNV128 Code
The following code is the header and C source for 128-bit FNV-1a
providing a byte vector hash.
<CODE BEGINS> file "FNV128.h"
//************************** FNV128.h ************************//
//*************** See RFC 9923 for details. ******************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
#ifndef _FNV128_H_
#define _FNV128_H_
/*
* Description:
* This file provides headers for the 128-bit version of
* the FNV-1a non-cryptographic hash algorithm.
*/
#include "FNVconfig.h"
#include "FNVErrorCodes.h"
#include <stdint.h>
#define FNV128size (128/8)
/* If you do not have the ISO standard stdint.h header file, then
* you must typedef the following types:
*
* type meaning
* uint64_t unsigned 64-bit integer (ifdef FNV_64bitIntegers)
* uint32_t unsigned 32-bit integer
* uint16_t unsigned 16-bit integer
* uint8_t unsigned 8-bit integer (i.e., unsigned char)
*/
/*
* This structure holds context information for an FNV128 hash
*/
#ifdef FNV_64bitIntegers
/* version if 64-bit integers supported */
typedef struct FNV128context_s {
int Computed; /* state */
uint32_t Hash[FNV128size/4];
} FNV128context;
#else
/* version if 64-bit integers NOT supported */
typedef struct FNV128context_s {
int Computed; /* state */
uint16_t Hash[FNV128size/2];
} FNV128context;
#endif /* FNV_64bitIntegers */
/* Function Prototypes:
*
* FNV128string: hash a zero-terminated string not including
* the terminating zero
* FNV128stringBasis: also takes an offset_basis parameter
*
* FNV128block: hash a byte vector of a specified length
* FNV128blockBasis: also takes an offset_basis parameter
*
* FNV128file: hash the contents of a file
* FNV128fileBasis: also takes an offset_basis parameter
*
* FNV128init: initializes an FNV128 context
* FNV128initBasis: initializes an FNV128 context with a
* provided 16-byte vector basis
* FNV128blockin: hash in a byte vector of a specified length
* FNV128stringin: hash in a zero-terminated string not
* including the terminating zero
* FNV128filein: hash in the contents of a file
* FNV128result: returns the hash value
*
* Hash is returned as an array of 8-bit unsigned integers
*/
#ifdef __cplusplus
extern "C" {
#endif
/* FNV128 */
extern int FNV128string ( const char *in,
uint8_t out[FNV128size] );
extern int FNV128stringBasis ( const char *in,
uint8_t out[FNV128size],
const uint8_t basis[FNV128size] );
extern int FNV128block ( const void *vin,
long int length,
uint8_t out[FNV128size] );
extern int FNV128blockBasis ( const void *vin,
long int length,
uint8_t out[FNV128size],
const uint8_t basis[FNV128size] );
extern int FNV128file ( const char *fname,
uint8_t out[FNV128size] );
extern int FNV128fileBasis ( const char *fname,
uint8_t out[FNV128size],
const uint8_t basis[FNV128size] );
extern int FNV128init ( FNV128context * const );
extern int FNV128initBasis ( FNV128context * const,
const uint8_t basis[FNV128size] );
extern int FNV128blockin ( FNV128context * const,
const void *vin,
long int length );
extern int FNV128stringin ( FNV128context * const,
const char *in );
extern int FNV128filein ( FNV128context * const,
const char *fname );
extern int FNV128result ( FNV128context * const,
uint8_t out[FNV128size] );
#ifdef __cplusplus
}
#endif
#endif /* _FNV128_H_ */
<CODE ENDS>
<CODE BEGINS> file "FNV128.c"
//**************************** FNV128.c **************************//
//******************* See RFC 9923 for details. ******************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
/* This file implements the FNV (Fowler/Noll/Vo) non-cryptographic
* hash function FNV-1a for 128-bit hashes.
*/
#include <stdio.h>
#include "FNVconfig.h"
#include "fnv-private.h"
#include "FNV128.h"
//*****************************************************************
// COMMON CODE FOR 64- AND 32-BIT INTEGER MODES
//*****************************************************************
/* FNV128: hash a zero-terminated string not including the zero
******************************************************************/
int FNV128string ( const char *in, uint8_t out[FNV128size] ) {
FNV128context ctx;
int error;
if ( (error = FNV128init ( &ctx )) )
return error;
if ( (error = FNV128stringin ( &ctx, in )) )
return error;
return FNV128result (&ctx, out);
} /* end FNV128string */
/* FNV128: hash a zero-terminated string not including the zero
******************************************************************/
int FNV128stringBasis ( const char *in,
uint8_t out[FNV128size],
const uint8_t basis[FNV128size] ) {
FNV128context ctx;
int error;
if ( (error = FNV128initBasis ( &ctx, basis )) )
return error;
if ( (error = FNV128stringin ( &ctx, in )) )
return error;
return FNV128result ( &ctx, out );
} /* end FNV128stringBasis */
/* FNV128: hash a counted block (64/32-bit)
******************************************************************/
int FNV128block ( const void *vin,
long int length,
uint8_t out[FNV128size] ) {
FNV128context ctx;
int error;
if ( (error = FNV128init ( &ctx )) )
return error;
if ( (error = FNV128blockin ( &ctx, vin, length )) )
return error;
return FNV128result ( &ctx, out );
} /* end FNV128block */
/* FNV128: hash a counted block (64/32-bit)
******************************************************************/
int FNV128blockBasis ( const void *vin,
long int length,
uint8_t out[FNV128size],
const uint8_t basis[FNV128size] ) {
FNV128context ctx;
int error;
if ( (error = FNV128initBasis ( &ctx, basis )) )
return error;
if ( (error = FNV128blockin ( &ctx, vin, length )) )
return error;
return FNV128result ( &ctx, out );
} /* end FNV128blockBasis */
/* hash the contents of a file
******************************************************************/
int FNV128file ( const char *fname,
uint8_t out[FNV128size] ) {
FNV128context e128Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV128init (&e128Context)) )
return error;
if ( (error = FNV128filein (&e128Context, fname)) )
return error;
return FNV128result ( &e128Context, out );
} /* end FNV128file */
/* hash the contents of a file with a non-standard basis
******************************************************************/
int FNV128fileBasis ( const char *fname,
uint8_t out[FNV128size],
const uint8_t basis[FNV128size] ) {
FNV128context e128Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV128initBasis (&e128Context, basis)) )
return error;
if ( (error = FNV128filein (&e128Context, fname)) )
return error;
return FNV128result ( &e128Context, out );
} /* end FNV128fileBasis */
/* hash in the contents of a file
******************************************************************/
int FNV128filein ( FNV128context * const e128Context,
const char *fname ) {
FILE *fp;
long int i;
char buf[1024];
int error;
if ( !e128Context || !fname )
return fnvNull;
switch ( e128Context->Computed ) {
case FNVinited+FNV128state:
e128Context->Computed = FNVcomputed+FNV128state;
break;
case FNVcomputed+FNV128state:
break;
default:
return fnvStateError;
}
if ( ( fp = fopen ( fname, "rb") ) == NULL )
return fnvBadParam;
if ( (error = FNV128blockin ( e128Context, "", 0)) ) {
fclose(fp);
return error;
}
while ( ( i = fread ( buf, 1, sizeof(buf), fp ) ) > 0 )
if ( (error = FNV128blockin ( e128Context, buf, i)) ) {
fclose(fp);
return error;
}
error = ferror(fp);
fclose(fp);
if (error) return fnvBadParam;
return fnvSuccess;
} /* end FNV128filein */
//*****************************************************************
// START VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//*****************************************************************
#ifdef FNV_64bitIntegers
/* 128-bit FNV_prime = 2^88 + 2^8 + 0x3b */
/* 0x00000000 01000000 00000000 0000013B */
#define FNV128primeX 0x013B
#define FNV128shift 24
//*****************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV128
//*****************************************************************/
/* initialize context (64-bit)
******************************************************************/
int FNV128init ( FNV128context * const ctx ) {
const uint32_t FNV128basis[FNV128size/4] =
{ 0x6C62272E, 0x07BB0142, 0x62B82175, 0x6295C58D };
if ( !ctx )
return fnvNull;
for ( int i=0; i<4; ++i )
ctx->Hash[i] = FNV128basis[i];
ctx->Computed = FNVinited+FNV128state;
return fnvSuccess;
} /* end FNV128init */
/* initialize context with a provided 16-byte vector basis (64-bit)
******************************************************************/
int FNV128initBasis ( FNV128context * const ctx,
const uint8_t basis[FNV128size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i < FNV128size/4; ++i ) {
uint32_t temp = *basis++<<24;
temp += *basis++<<16;
temp += *basis++<<8;
ctx->Hash[i] = temp + *basis++;
}
ctx->Computed = FNVinited+FNV128state;
return fnvSuccess;
} /* end FNV128initBasis */
/* hash in a counted block (64-bit)
******************************************************************/
int FNV128blockin ( FNV128context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint64_t temp[FNV128size/4];
uint64_t temp2[2];
int i;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV128state:
ctx->Computed = FNVcomputed+FNV128state;
break;
case FNVcomputed+FNV128state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV128size/4; ++i )
temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) {
/* temp = FNV128prime * ( temp ^ *in++ ); */
temp[FNV128size/4-1] ^= *in++;
temp2[1] = temp[3] << FNV128shift;
temp2[0] = temp[2] << FNV128shift;
for ( i=0; i < FNV128size/4; ++i )
temp[i] *= FNV128primeX;
temp[1] += temp2[1];
temp[0] += temp2[0];
for ( i = 3; i > 0; --i ) {
temp[i-1] += temp[i] >> 32;
temp[i] &= 0xFFFFFFFF;
}
}
for ( i=0; i<FNV128size/4; ++i )
ctx->Hash[i] = (uint32_t)temp[i];
return fnvSuccess;
} /* end FNV128blockin */
/* hash in a zero-terminated string not including the zero (64-bit)
******************************************************************/
int FNV128stringin ( FNV128context * const ctx, const char *in ) {
uint64_t temp[FNV128size/4];
uint64_t temp2[2];
int i;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV128state:
ctx->Computed = FNVcomputed+FNV128state;
break;
case FNVcomputed+FNV128state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV128size/4; ++i )
temp[i] = ctx->Hash[i];
while ( ( ch = (uint8_t)*in++ ) ) {
/* temp = FNV128prime * ( temp ^ ch ); */
temp[3] ^= ch;
temp2[1] = temp[3] << FNV128shift;
temp2[0] = temp[2] << FNV128shift;
for ( i=0; i < FNV128size/4; ++i )
temp[i] *= FNV128primeX;
temp[1] += temp2[1];
temp[0] += temp2[0];
for ( i = 3; i > 0; --i ) {
temp[i-1] += temp[i] >> 32;
temp[i] &= 0xFFFFFFFF;
}
}
for ( i=0; i<FNV128size/4; ++i )
ctx->Hash[i] = (uint32_t)temp[i];
return fnvSuccess;
} /* end FNV128stringin */
/* return hash as 16-byte vector (64-bit)
******************************************************************/
int FNV128result ( FNV128context * const ctx,
uint8_t out[FNV128size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV128state )
return fnvStateError;
for ( int i=0; i<FNV128size/4; ++i ) {
out[4*i] = ctx->Hash[i] >> 24;
out[4*i+1] = ctx->Hash[i] >> 16;
out[4*i+2] = ctx->Hash[i] >> 8;
out[4*i+3] = ctx->Hash[i];
ctx -> Hash[i] = 0;
}
ctx->Computed = FNVemptied+FNV128state;
return fnvSuccess;
} /* end FNV128result */
//****************************************************************
// END VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//****************************************************************
#else /* FNV_64bitIntegers */
//****************************************************************
// START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//****************************************************************
/* 128-bit FNV_prime = 2^88 + 2^8 + 0x3b */
/* 0x00000000 01000000 00000000 0000013B */
#define FNV128primeX 0x013B
#define FNV128shift 8
//*****************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV128
//*****************************************************************
/* initialize context (32-bit)
******************************************************************/
int FNV128init ( FNV128context * const ctx ) {
const uint16_t FNV128basis[FNV128size/2] =
{ 0x6C62, 0x272E, 0x07BB, 0x0142,
0x62B8, 0x2175, 0x6295, 0xC58D };
if ( !ctx )
return fnvNull;
for ( int i=0; i<FNV128size/2; ++i )
ctx->Hash[i] = FNV128basis[i];
ctx->Computed = FNVinited+FNV128state;
return fnvSuccess;
} /* end FNV128init */
/* initialize context with a provided 16-byte vector basis (32-bit)
******************************************************************/
int FNV128initBasis ( FNV128context * const ctx,
const uint8_t basis[FNV128size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i < FNV128size/2; ++i ) {
uint32_t temp = *basis++;
ctx->Hash[i] = ( temp<<8 ) + *basis++;
}
ctx->Computed = FNVinited+FNV128state;
return fnvSuccess;
} /* end FNV128initBasis */
/* hash in a counted block (32-bit)
*****************************************************************/
int FNV128blockin ( FNV128context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint32_t temp[FNV128size/2];
uint32_t temp2[3];
int i;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV128state:
ctx->Computed = FNVcomputed+FNV128state;
break;
case FNVcomputed+FNV128state:
break;
default:
return fnvStateError;
}
for ( i=0; i < FNV128size/2; ++i )
temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) {
/* temp = FNV128prime * ( temp ^ *in++ ); */
temp[FNV128size/2-1] ^= *in++;
for ( i=2; i >= 0; --i )
temp2[i] = temp[i+5] << FNV128shift;
for ( i=0; i < (FNV128size/2); ++i )
temp[i] *= FNV128primeX;
for ( i=2; i >= 0; --i )
temp[i] += temp2[i];
for ( i=FNV128size/2-1; i>0; --i ) {
temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF;
}
}
for ( i=0; i < FNV128size/2; ++i )
ctx->Hash[i] = temp[i];
return fnvSuccess;
} /* end FNV128blockin */
/* hash in a zero-terminated string not including the zero (32-bit)
******************************************************************/
int FNV128stringin ( FNV128context * const ctx, const char *in ) {
uint32_t temp[FNV128size/2];
uint32_t temp2[3];
int i;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV128state:
ctx->Computed = FNVcomputed+FNV128state;
break;
case FNVcomputed+FNV128state:
break;
default:
return fnvStateError;
}
for ( i=0; i < FNV128size/2; ++i )
temp[i] = ctx->Hash[i];
while ( (ch = (uint8_t)*in++) ) {
/* temp = FNV128prime * ( temp ^ *in++ ); */
temp[FNV128size/2-1] ^= ch;
for ( i=2; i >= 0; --i )
temp2[i] = temp[i+5] << FNV128shift;
for ( i=0; i<(FNV128size/2); ++i )
temp[i] *= FNV128primeX;
for ( i=2; i >= 0; --i )
temp[i] += temp2[i];
for ( i=FNV128size/2-1; i>0; --i ) {
temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF;
}
}
for ( i=0; i < FNV128size/2; ++i )
ctx->Hash[i] = temp[i];
return fnvSuccess;
} /* end FNV128stringin */
/* return hash (32-bit)
******************************************************************/
int FNV128result ( FNV128context * const ctx,
uint8_t out[FNV128size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV128state )
return fnvStateError;
for ( int i=0; i<FNV128size/2; ++i ) {
out[2*i] = ctx->Hash[i] >> 8;
out[2*i+1] = ctx->Hash[i];
ctx -> Hash[i] = 0;
}
ctx->Computed = FNVemptied+FNV128state;
return fnvSuccess;
} /* end FNV128result */
#endif /* FNV_64bitIntegers */
//******************************************************************
// END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//******************************************************************
<CODE ENDS>
8.2.4. FNV256 Code
The following code is the header and C source for 256-bit FNV-1a
providing a byte vector hash.
<CODE BEGINS> file "FNV256.h"
//************************* FNV256.h ***********************//
//************** See RFC 9923 for details. *****************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
#ifndef _FNV256_H_
#define _FNV256_H_
/*
* Description:
* This file provides headers for the 256-bit version of
* the FNV-1a non-cryptographic hash algorithm.
*/
#include "FNVconfig.h"
#include "FNVErrorCodes.h"
#include <stdint.h>
#define FNV256size (256/8)
/* If you do not have the ISO standard stdint.h header file, then
* you must typedef the following types:
*
* type meaning
* uint64_t unsigned 64-bit integer (ifdef FNV_64bitIntegers)
* uint32_t unsigned 32-bit integer
* uint16_t unsigned 16-bit integer
* uint8_t unsigned 8-bit integer (i.e., unsigned char)
*/
/*
* This structure holds context information for an FNV256 hash
*/
#ifdef FNV_64bitIntegers
/* version if 64-bit integers supported */
typedef struct FNV256context_s {
int Computed; /* state */
uint32_t Hash[FNV256size/4];
} FNV256context;
#else
/* version if 64-bit integers NOT supported */
typedef struct FNV256context_s {
int Computed; /* state */
uint16_t Hash[FNV256size/2];
} FNV256context;
#endif /* FNV_64bitIntegers */
/* Function Prototypes:
*
* FNV256string: hash a zero-terminated string not including
* the terminating zero
* FNV256stringBasis: also takes an offset_basis parameter
*
* FNV256block: hash a byte vector of a specified length
* FNV256blockBasis: also takes an offset_basis parameter
*
* FNV256file: hash the contents of a file
* FNV256fileBasis: also takes an offset_basis parameter
*
* FNV256init: initializes an FNV256 context
* FNV256initBasis: initializes an FNV256 context with a
* provided 32-byte vector basis
* FNV256blockin: hash in a byte vector of a specified length
* FNV256stringin: hash in a zero-terminated string not
* including the terminating zero
* FNV256filein: hash in the contents of a file
* FNV256result: returns the hash value
*
* Hash is returned as an array of 8-bit unsigned integers
*/
#ifdef __cplusplus
extern "C" {
#endif
/* FNV256 */
extern int FNV256string ( const char *in,
uint8_t out[FNV256size] );
extern int FNV256stringBasis ( const char *in,
uint8_t out[FNV256size],
const uint8_t basis[FNV256size] );
extern int FNV256block ( const void *vin,
long int length,
uint8_t out[FNV256size] );
extern int FNV256blockBasis ( const void *vin,
long int length,
uint8_t out[FNV256size],
const uint8_t basis[FNV256size] );
extern int FNV256file ( const char *fname,
uint8_t out[FNV256size] );
extern int FNV256fileBasis ( const char *fname,
uint8_t out[FNV256size],
const uint8_t basis[FNV256size] );
extern int FNV256init ( FNV256context * const );
extern int FNV256initBasis ( FNV256context * const,
const uint8_t basis[FNV256size] );
extern int FNV256blockin ( FNV256context * const,
const void *vin,
long int length );
extern int FNV256stringin ( FNV256context * const,
const char *in );
extern int FNV256filein ( FNV256context * const,
const char *fname );
extern int FNV256result ( FNV256context * const,
uint8_t out[FNV256size] );
#ifdef __cplusplus
}
#endif
#endif /* _FNV256_H_ */
<CODE ENDS>
<CODE BEGINS> file "FNV256.c"
//**************************** FNV256.c **************************//
//******************* See RFC 9923 for details. ******************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
/* This file implements the FNV (Fowler/Noll/Vo) non-cryptographic
* hash function FNV-1a for 256-bit hashes.
*/
#include <stdio.h>
#include "fnv-private.h"
#include "FNV256.h"
//*****************************************************************
// COMMON CODE FOR 64- AND 32-BIT INTEGER MODES
//*****************************************************************
/* FNV256: hash a zero-terminated string not including the zero
******************************************************************/
int FNV256string ( const char *in, uint8_t out[FNV256size] ) {
FNV256context ctx;
int error;
if ( (error = FNV256init ( &ctx )) )
return error;
if ( (error = FNV256stringin ( &ctx, in )) )
return error;
return FNV256result ( &ctx, out );
} /* end FNV256string */
/* FNV256: hash a zero-terminated string not including the zero
* with a non-standard basis
******************************************************************/
int FNV256stringBasis ( const char *in,
uint8_t out[FNV256size],
const uint8_t basis[FNV256size] ) {
FNV256context ctx;
int error;
if ( (error = FNV256initBasis ( &ctx, basis )) )
return error;
if ( (error = FNV256stringin ( &ctx, in )) )
return error;
return FNV256result ( &ctx, out );
} /* end FNV256stringBasis */
/* FNV256: hash a counted block (64/32-bit)
******************************************************************/
int FNV256block ( const void *vin,
long int length,
uint8_t out[FNV256size] ) {
FNV256context ctx;
int error;
if ( (error = FNV256init ( &ctx )) )
return error;
if ( (error = FNV256blockin ( &ctx, vin, length)) )
return error;
return FNV256result ( &ctx, out );
} /* end FNV256block */
/* FNV256: hash a counted block (64/32-bit)
* with a non-standard basis
******************************************************************/
int FNV256blockBasis ( const void *vin,
long int length,
uint8_t out[FNV256size],
const uint8_t basis[FNV256size] ) {
FNV256context ctx;
int error;
if ( (error = FNV256initBasis ( &ctx, basis )) )
return error;
if ( (error = FNV256blockin ( &ctx, vin, length)) )
return error;
return FNV256result ( &ctx, out );
} /* end FNV256blockBasis */
/* hash the contents of a file
******************************************************************/
int FNV256file ( const char *fname,
uint8_t out[FNV256size] ) {
FNV256context e256Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV256init (&e256Context)) )
return error;
if ( (error = FNV256filein (&e256Context, fname)) )
return error;
return FNV256result ( &e256Context, out );
} /* end FNV256file */
/* hash the contents of a file with a non-standard basis
******************************************************************/
int FNV256fileBasis ( const char *fname,
uint8_t out[FNV256size],
const uint8_t basis[FNV256size]) {
FNV256context e256Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV256initBasis (&e256Context, basis)) )
return error;
if ( (error = FNV256filein (&e256Context, fname)) )
return error;
return FNV256result ( &e256Context, out );
} /* end FNV256fileBasis */
/* hash in the contents of a file
******************************************************************/
int FNV256filein ( FNV256context * const e256Context,
const char *fname ) {
FILE *fp;
long int i;
char buf[1024];
int error;
if ( !e256Context || !fname )
return fnvNull;
switch ( e256Context->Computed ) {
case FNVinited+FNV256state:
e256Context->Computed = FNVcomputed+FNV256state;
break;
case FNVcomputed+FNV256state:
break;
default:
return fnvStateError;
}
if ( ( fp = fopen ( fname, "rb") ) == NULL )
return fnvBadParam;
if ( (error = FNV256blockin ( e256Context, "", 0)) ) {
fclose(fp);
return error;
}
while ( ( i = fread ( buf, 1, sizeof(buf), fp ) ) > 0 )
if ( (error = FNV256blockin ( e256Context, buf, i)) ) {
fclose(fp);
return error;
}
error = ferror(fp);
fclose(fp);
if (error) return fnvBadParam;
return fnvSuccess;
} /* end FNV256filein */
//*****************************************************************
// START VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//*****************************************************************
#ifdef FNV_64bitIntegers
/* 256-bit FNV_prime = 2^168 + 2^8 + 0x63 */
/* 0x0000000000000000 0000010000000000
0000000000000000 0000000000000163 */
#define FNV256primeX 0x0163
#define FNV256shift 8
//*****************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV256
//*****************************************************************
/* initialize context (64-bit)
******************************************************************/
int FNV256init ( FNV256context * const ctx ) {
const uint32_t FNV256basis[FNV256size/4] = {
0xDD268DBC, 0xAAC55036, 0x2D98C384, 0xC4E576CC,
0xC8B15368, 0x47B6BBB3, 0x1023B4C8, 0xCAEE0535 };
if ( !ctx )
return fnvNull;
for ( int i=0; i<FNV256size/4; ++i )
ctx->Hash[i] = FNV256basis[i];
ctx->Computed = FNVinited+FNV256state;
return fnvSuccess;
} /* end FNV256init */
/* initialize context with a provided 32-byte vector basis (64-bit)
* with a non-standard basis
******************************************************************/
int FNV256initBasis ( FNV256context * const ctx,
const uint8_t basis[FNV256size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i < FNV256size/4; ++i ) {
uint32_t temp = *basis++<<24;
temp += *basis++<<16;
temp += *basis++<<8;
ctx->Hash[i] = temp + *basis++;
}
ctx->Computed = FNVinited+FNV256state;
return fnvSuccess;
} /* end FNV256initBasis */
/* hash in a counted block (64-bit)
******************************************************************/
int FNV256blockin ( FNV256context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint64_t temp[FNV256size/4];
uint64_t temp2[3];
int i;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV256state:
ctx->Computed = FNVcomputed+FNV256state;
break;
case FNVcomputed+FNV256state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV256size/4; ++i )
temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) {
/* temp = FNV256prime * ( temp ^ *in++ ); */
temp[FNV256size/4-1] ^= *in++;
for ( i=2; i >= 0; --i )
temp2[i] = temp[i+5] << FNV256shift;
for ( i=0; i < FNV256size/4; ++i )
temp[i] *= FNV256primeX;
for ( i=2; i >= 0; --i )
temp[i] += temp2[i];
for ( i=FNV256size/4-1; i>0; --i ) {
temp[i-1] += temp[i] >> 32;
temp[i] &= 0xFFFFFFFF;
}
}
for ( i=0; i<FNV256size/4; ++i )
ctx->Hash[i] = (uint32_t)temp[i];
return fnvSuccess;
} /* end FNV256blockin */
/* hash in a zero-terminated string not including the zero (64-bit)
******************************************************************/
int FNV256stringin ( FNV256context * const ctx, const char *in ) {
uint64_t temp[FNV256size/4];
uint64_t temp2[3];
int i;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV256state:
ctx->Computed = FNVcomputed+FNV256state;
break;
case FNVcomputed+FNV256state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV256size/4; ++i )
temp[i] = ctx->Hash[i];
while ( (ch = (uint8_t)*in++) ) {
/* temp = FNV256prime * ( temp ^ ch ); */
temp[FNV256size/4-1] ^= ch;
for ( i=2; i >= 0; --i )
temp2[i] = temp[i+5] << FNV256shift;
for ( i=0; i<FNV256size/4; ++i )
temp[i] *= FNV256primeX;
for ( i=2; i >= 0; --i )
temp[i] += temp2[i];
for ( i=FNV256size/4-1; i>0; --i ) {
temp[i-1] += temp[i] >> 32;
temp[i] &= 0xFFFFFFFF;
}
}
for ( i=0; i<FNV256size/4; ++i )
ctx->Hash[i] = (uint32_t)temp[i];
return fnvSuccess;
} /* end FNV256stringin */
/* return hash as 8-byte vector (64-bit)
******************************************************************/
int FNV256result ( FNV256context * const ctx,
uint8_t out[FNV256size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV256state )
return fnvStateError;
for ( int i=0; i<FNV256size/4; ++i ) {
out[4*i] = ctx->Hash[i] >> 24;
out[4*i+1] = ctx->Hash[i] >> 16;
out[4*i+2] = ctx->Hash[i] >> 8;
out[4*i+3] = ctx->Hash[i];
ctx -> Hash[i] = 0;
}
ctx->Computed = FNVemptied+FNV256state;
return fnvSuccess;
} /* end FNV256result */
//****************************************************************
// END VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//****************************************************************
#else /* FNV_64bitIntegers */
//****************************************************************
// START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//****************************************************************
/* 256-bit FNV_prime = 2^168 + 2^8 + 0x63 */
/* 0x00000000 00000000 00000100 00000000
00000000 00000000 00000000 00000163 */
#define FNV256primeX 0x0163
#define FNV256shift 8
//****************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV256
//****************************************************************
/* initialize context (32-bit)
*****************************************************************/
int FNV256init ( FNV256context * const ctx ) {
const uint16_t FNV256basis[FNV256size/2] = {
0xDD26, 0x8DBC, 0xAAC5, 0x5036, 0x2D98, 0xC384, 0xC4E5, 0x76CC,
0xC8B1, 0x5368, 0x47B6, 0xBBB3, 0x1023, 0xB4C8, 0xCAEE, 0x0535 };
if ( !ctx )
return fnvNull;
for ( int i=0; i<FNV256size/2; ++i )
ctx->Hash[i] = FNV256basis[i];
ctx->Computed = FNVinited+FNV256state;
return fnvSuccess;
} /* end FNV256init */
/* initialize context with a provided 32-byte vector basis (32-bit)
******************************************************************/
int FNV256initBasis ( FNV256context * const ctx,
const uint8_t basis[FNV256size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i < FNV256size/2; ++i ) {
uint32_t temp = *basis++;
ctx->Hash[i] = ( temp<<8 ) + *basis++;
}
ctx->Computed = FNVinited+FNV256state;
return fnvSuccess;
} /* end FNV256initBasis */
/* hash in a counted block (32-bit)
*****************************************************************/
int FNV256blockin ( FNV256context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint32_t temp[FNV256size/2];
uint32_t temp2[6];
int i;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV256state:
ctx->Computed = FNVcomputed+FNV256state;
break;
case FNVcomputed+FNV256state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV256size/2; ++i )
temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) {
/* temp = FNV256prime * ( temp ^ *in++ ); */
temp[FNV256size/2-1] ^= *in++;
for ( i=0; i<6; ++i )
temp2[5-i] = temp[FNV256size/2-1-i] << FNV256shift;
for ( i=0; i<FNV256size/2; ++i )
temp[i] *= FNV256primeX;
for ( i=0; i<6; ++i )
temp[i] += temp2[i];
for ( i=FNV256size/2-1; i>0; --i ) {
temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF;
}
}
for ( i=0; i<FNV256size/2; ++i )
ctx->Hash[i] = temp[i];
return fnvSuccess;
} /* end FNV256blockin */
/* hash in a zero-terminated string not including the zero (32-bit)
******************************************************************/
int FNV256stringin ( FNV256context * const ctx, const char *in ) {
uint32_t temp[FNV256size/2];
uint32_t temp2[6];
int i;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV256state:
ctx->Computed = FNVcomputed+FNV256state;
break;
case FNVcomputed+FNV256state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV256size/2; ++i )
temp[i] = ctx->Hash[i];
while ( ( ch = (uint8_t)*in++ ) ) {
/* temp = FNV256prime * ( temp ^ *in++ ); */
temp[FNV256size/2-1] ^= ch;
for ( i=0; i<6; ++i )
temp2[5-i] = temp[FNV256size/2-1-i] << FNV256shift;
for ( i=0; i<FNV256size/2; ++i )
temp[i] *= FNV256primeX;
for ( i=0; i<6; ++i )
temp[i] += temp2[i];
for ( i=FNV256size/2-1; i>0; --i ) {
temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF;
}
}
for ( i=0; i<FNV256size/2; ++i )
ctx->Hash[i] = temp[i];
return fnvSuccess;
} /* end FNV256stringin */
/* return hash (32-bit)
*****************************************************************/
int FNV256result ( FNV256context * const ctx,
uint8_t out[FNV256size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV256state )
return fnvStateError;
for ( int i=0; i<FNV256size/2; ++i ) {
out[2*i] = ctx->Hash[i] >> 8;
out[2*i+1] = ctx->Hash[i];
ctx->Hash[i] = 0;
}
ctx->Computed = FNVemptied+FNV256state;
return fnvSuccess;
} /* end FNV256result */
#endif /* FNV_64bitIntegers */
//****************************************************************
// END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//****************************************************************
<CODE ENDS>
8.2.5. FNV512 Code
The following code is the header and C source for 512-bit FNV-1a
providing a byte vector hash.
<CODE BEGINS> file "FNV512.h"
//************************* FNV512.h ***********************//
//************** See RFC 9923 for details. *****************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
#ifndef _FNV512_H_
#define _FNV512_H_
/*
* Description:
* This file provides headers for the 512-bit version of
* the FNV-1a non-cryptographic hash algorithm.
*/
#include "FNVconfig.h"
#include "FNVErrorCodes.h"
#include <stdint.h>
#define FNV512size (512/8)
/* If you do not have the ISO standard stdint.h header file, then
* you must typedef the following types:
*
* type meaning
* uint64_t unsigned 64-bit integer (ifdef FNV_64bitIntegers)
* uint32_t unsigned 32-bit integer
* uint16_t unsigned 16-bit integer
* uint8_t unsigned 8-bit integer (i.e., unsigned char)
*/
/*
* This structure holds context information for an FNV512 hash
*/
#ifdef FNV_64bitIntegers
/* version if 64-bit integers supported */
typedef struct FNV512context_s {
int Computed; /* state */
uint32_t Hash[FNV512size/4];
} FNV512context;
#else
/* version if 64-bit integers NOT supported */
typedef struct FNV512context_s {
int Computed; /* state */
uint16_t Hash[FNV512size/2];
} FNV512context;
#endif /* FNV_64bitIntegers */
/* Function Prototypes:
*
* FNV512string: hash a zero-terminated string not including
* the terminating zero
* FNV512stringBasis: also takes an offset_basis parameter
*
* FNV512block: hash a byte vector of a specified length
* FNV512blockBasis: also takes an offset_basis parameter
*
* FNV512file: hash the contents of a file
* FNV512fileBasis: also takes an offset_basis parameter
*
* FNV512init: initializes an FNV512 context
* FNV512initBasis: initializes an FNV512 context with a
* provided 64-byte vector basis
* FNV512blockin: hash in a byte vector of a specified length
* FNV512stringin: hash in a zero-terminated string not
* including the terminating zero
* FNV512filein: hash in the contents of a file
* FNV512result: returns the hash value
*
* Hash is returned as an array of 8-bit unsigned integers
*/
#ifdef __cplusplus
extern "C" {
#endif
/* FNV512 */
extern int FNV512string ( const char *in,
uint8_t out[FNV512size] );
extern int FNV512stringBasis ( const char *in,
uint8_t out[FNV512size],
const uint8_t basis[FNV512size] );
extern int FNV512block ( const void *vin,
long int length,
uint8_t out[FNV512size] );
extern int FNV512blockBasis ( const void *vin,
long int length,
uint8_t out[FNV512size],
const uint8_t basis[FNV512size] );
extern int FNV512file ( const char *fname,
uint8_t out[FNV512size] );
extern int FNV512fileBasis ( const char *fname,
uint8_t out[FNV512size],
const uint8_t basis[FNV512size] );
extern int FNV512init ( FNV512context * const );
extern int FNV512initBasis ( FNV512context * const,
const uint8_t basis[FNV512size] );
extern int FNV512blockin ( FNV512context * const,
const void *vin,
long int length );
extern int FNV512stringin ( FNV512context * const,
const char *in );
extern int FNV512filein ( FNV512context * const,
const char *fname );
extern int FNV512result ( FNV512context * const,
uint8_t out[FNV512size] );
#ifdef __cplusplus
}
#endif
#endif /* _FNV512_H_ */
<CODE ENDS>
<CODE BEGINS> file "FNV512.c"
//**************************** FNV512.c **************************//
//******************* See RFC 9923 for details. ******************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
/* This file implements the FNV (Fowler/Noll/Vo) non-cryptographic
* hash function FNV-1a for 512-bit hashes.
*/
#include <stdio.h>
#include "fnv-private.h"
#include "FNV512.h"
//*****************************************************************
// COMMON CODE FOR 64- AND 32-BIT INTEGER MODES
//*****************************************************************
/* FNV512: hash a zero-terminated string not including the zero
******************************************************************/
int FNV512string ( const char *in, uint8_t out[FNV512size] ) {
FNV512context ctx;
int error;
if ( (error = FNV512init ( &ctx )) )
return error;
if ( (error = FNV512stringin ( &ctx, in )) )
return error;
return FNV512result ( &ctx, out );
} /* end FNV512string */
/* FNV512: hash a zero-terminated string not including the zero
* with a non-standard basis
******************************************************************/
int FNV512stringBasis ( const char *in,
uint8_t out[FNV512size],
const uint8_t basis[FNV512size] ) {
FNV512context ctx;
int error;
if ( (error = FNV512initBasis ( &ctx, basis )) )
return error;
if ( (error = FNV512stringin ( &ctx, in )) )
return error;
return FNV512result ( &ctx, out );
} /* end FNV512stringBasis */
/* FNV512: hash a counted block (64/32-bit)
******************************************************************/
int FNV512block ( const void *vin,
long int length,
uint8_t out[FNV512size] ) {
FNV512context ctx;
int error;
if ( (error = FNV512init ( &ctx )) )
return error;
if ( (error = FNV512blockin ( &ctx, vin, length)) )
return error;
return FNV512result ( &ctx, out );
} /* end FNV512block */
/* FNV512: hash a counted block (64/32-bit)
* with a non-standard basis
******************************************************************/
int FNV512blockBasis ( const void *vin,
long int length,
uint8_t out[FNV512size],
const uint8_t basis[FNV512size] ) {
FNV512context ctx;
int error;
if ( (error = FNV512initBasis ( &ctx, basis )) )
return error;
if ( (error = FNV512blockin ( &ctx, vin, length)) )
return error;
return FNV512result ( &ctx, out );
} /* end FNV512blockBasis */
/* hash the contents of a file
******************************************************************/
int FNV512file ( const char *fname,
uint8_t out[FNV512size] ) {
FNV512context e512Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV512init (&e512Context)) )
return error;
if ( (error = FNV512filein (&e512Context, fname)) )
return error;
return FNV512result ( &e512Context, out );
} /* end FNV512file */
/* hash the contents of a file with a non-standard basis
******************************************************************/
int FNV512fileBasis ( const char *fname,
uint8_t out[FNV512size],
const uint8_t basis[FNV512size] ) {
FNV512context e512Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV512initBasis (&e512Context, basis)) )
return error;
if ( (error = FNV512filein (&e512Context, fname)) )
return error;
return FNV512result ( &e512Context, out );
} /* end FNV512fileBasis */
/* hash in the contents of a file
******************************************************************/
int FNV512filein ( FNV512context * const e512Context,
const char *fname ) {
FILE *fp;
long int i;
char buf[1024];
int error;
if ( !e512Context || !fname )
return fnvNull;
switch ( e512Context->Computed ) {
case FNVinited+FNV512state:
e512Context->Computed = FNVcomputed+FNV512state;
break;
case FNVcomputed+FNV512state:
break;
default:
return fnvStateError;
}
if ( ( fp = fopen ( fname, "rb") ) == NULL )
return fnvBadParam;
if ( (error = FNV512blockin ( e512Context, "", 0)) ) {
fclose(fp);
return error;
}
while ( ( i = fread ( buf, 1, sizeof(buf), fp ) ) > 0 )
if ( (error=FNV512blockin ( e512Context, buf, i)) ) {
fclose(fp);
return error;
}
error = ferror(fp);
fclose(fp);
if (error) return fnvBadParam;
return fnvSuccess;
} /* end FNV512filein */
//*****************************************************************
// START VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//*****************************************************************
#ifdef FNV_64bitIntegers
/* 512-bit FNV_prime = 2^344 + 2^8 + 0x57 =
0x0000000000000000 0000000000000000
0000000001000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 0000000000000157 */
#define FNV512primeX 0x0157
#define FNV512shift 24
//*****************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV512
//*****************************************************************
/* initialize context (64-bit)
******************************************************************/
int FNV512init ( FNV512context * const ctx ) {
const uint32_t FNV512basis[FNV512size/4] = {
0xB86DB0B1, 0x171F4416, 0xDCA1E50F, 0x309990AC,
0xAC87D059, 0xC9000000, 0x00000000, 0x00000D21,
0xE948F68A, 0x34C192F6, 0x2EA79BC9, 0x42DBE7CE,
0x18203641, 0x5F56E34B, 0xAC982AAC, 0x4AFE9FD9 };
if ( !ctx )
return fnvNull;
for ( int i=0; i<FNV512size/4; ++i )
ctx->Hash[i] = FNV512basis[i];
ctx->Computed = FNVinited+FNV512state;
return fnvSuccess;
} /* end FNV512init */
/* initialize context with a provided 64-byte vector basis (64-bit)
******************************************************************/
int FNV512initBasis ( FNV512context * const ctx,
const uint8_t basis[FNV512size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i < FNV512size/4; ++i ) {
uint32_t temp = *basis++<<24;
temp += *basis++<<16;
temp += *basis++<<8;
ctx->Hash[i] = temp + *basis++;
}
ctx->Computed = FNVinited+FNV512state;
return fnvSuccess;
} /* end FNV512initBasis */
/* hash in a counted block (64-bit)
******************************************************************/
int FNV512blockin ( FNV512context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint64_t temp[FNV512size/4];
uint64_t temp2[6];
int i;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV512state:
ctx->Computed = FNVcomputed+FNV512state;
break;
case FNVcomputed+FNV512state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV512size/4; ++i )
temp[i] = ctx->Hash[i]; // copy into temp
for ( ; length > 0; length-- ) {
/* temp = FNV512prime * ( temp ^ *in++ ); */
temp[FNV512size/4-1] ^= *in++;
for ( i=0; i<6; ++i )
temp2[5-i] = temp[FNV512size/4-1-i] << FNV512shift;
for ( i=0; i<FNV512size/4; ++i )
temp[i] *= FNV512primeX;
for ( i=0; i<6; ++i )
temp[i] += temp2[i];
for ( i=FNV512size/4-1; i>0; --i ) {
temp[i-1] += temp[i] >> 32; // propagate carries
temp[i] &= 0xFFFFFFFF;
}
} /* end for length */
for ( i=0; i<FNV512size/4; ++i )
ctx->Hash[i] = (uint32_t)temp[i]; // store back into hash
return fnvSuccess;
} /* end FNV512blockin */
/* hash in a zero-terminated string not including the zero (64-bit)
******************************************************************/
int FNV512stringin ( FNV512context * const ctx, const char *in ) {
uint64_t temp[FNV512size/4];
uint64_t temp2[6];
int i;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV512state:
ctx->Computed = FNVcomputed+FNV512state;
break;
case FNVcomputed+FNV512state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV512size/4; ++i )
temp[i] = ctx->Hash[i]; // copy into temp
while ( (ch = (uint8_t)*in++) ) {
/* temp = FNV512prime * ( temp ^ ch ); */
temp[FNV512size/4-1] ^= ch;
for ( i=0; i<6; ++i )
temp2[5-i] = temp[FNV512size/4-1-i] << FNV512shift;
for ( i=0; i<FNV512size/4; ++i )
temp[i] *= FNV512primeX;
for ( i=0; i<6; ++i )
temp[i] += temp2[i];
for ( i=FNV512size/4-1; i>0; --i ) {
temp[i-1] += temp[i] >> 32; // propagate carries
temp[i] &= 0xFFFFFFFF;
}
}
for ( i=0; i<FNV512size/4; ++i )
ctx->Hash[i] = (uint32_t)temp[i]; // store back into hash
return fnvSuccess;
} /* end FNV512stringin */
/* return hash (64-bit)
******************************************************************/
int FNV512result ( FNV512context * const ctx,
uint8_t out[FNV512size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV512state )
return fnvStateError;
for ( int i=0; i<FNV512size/4; ++i ) {
out[4*i] = ctx->Hash[i] >> 24;
out[4*i+1] = ctx->Hash[i] >> 16;
out[4*i+2] = ctx->Hash[i] >> 8;
out[4*i+3] = ctx->Hash[i];
ctx -> Hash[i] = 0;
}
ctx->Computed = FNVemptied+FNV512state;
return fnvSuccess;
} /* end FNV512result */
//*****************************************************************
// END VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//*****************************************************************
#else /* FNV_64bitIntegers */
//*****************************************************************
// START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//*****************************************************************
/* 512-bit FNV_prime = 2^344 + 2^8 + 0x57 =
0x00000000 00000000 00000000 00000000
00000000 01000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000157 */
#define FNV512primeX 0x0157
#define FNV512shift 8
//*****************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV512
//*****************************************************************
/* initialize context (32-bit)
******************************************************************/
int FNV512init ( FNV512context * const ctx ) {
const uint16_t FNV512basis[FNV512size/2] = {
0xB86D, 0xB0B1, 0x171F, 0x4416, 0xDCA1, 0xE50F, 0x3099, 0x90AC,
0xAC87, 0xD059, 0xC900, 0x0000, 0x0000, 0x0000, 0x0000, 0x0D21,
0xE948, 0xF68A, 0x34C1, 0x92F6, 0x2EA7, 0x9BC9, 0x42DB, 0xE7CE,
0x1820, 0x3641, 0x5F56, 0xE34B, 0xAC98, 0x2AAC, 0x4AFE, 0x9FD9 };
if ( !ctx )
return fnvNull;
for ( int i=0; i<FNV512size/2; ++i )
ctx->Hash[i] = FNV512basis[i];
ctx->Computed = FNVinited+FNV512state;
return fnvSuccess;
} /* end FNV512init */
/* initialize context with a provided 64-byte vector basis (32-bit)
******************************************************************/
int FNV512initBasis ( FNV512context * const ctx,
const uint8_t basis[FNV512size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i < FNV512size/2; ++i ) {
uint32_t temp = *basis++;
ctx->Hash[i] = ( temp<<8 ) + *basis++;
}
ctx->Computed = FNVinited+FNV512state;
return fnvSuccess;
} /* end FNV512initBasis */
/* hash in a counted block (32-bit)
******************************************************************/
int FNV512blockin ( FNV512context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint32_t temp[FNV512size/2];
uint32_t temp2[11];
int i;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV512state:
ctx->Computed = FNVcomputed+FNV512state;
break;
case FNVcomputed+FNV512state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV512size/2; ++i )
temp[i] = ctx->Hash[i]; // copy into temp
for ( ; length > 0; length-- ) {
/* temp = FNV512prime * ( temp ^ *in++ ); */
temp[FNV512size/2-1] ^= *in++;
for ( i=0; i<11; ++i )
temp2[10-i] = temp[FNV512size/2-1-i] << FNV512shift;
for ( i=0; i<FNV512size/2; ++i )
temp[i] *= FNV512primeX;
for ( i=0; i<11; ++i )
temp[i] += temp2[i];
for ( i=FNV512size/2-1; i>0; --i ) {
temp[i-1] += temp[i] >> 16; // propagate carries
temp[i] &= 0xFFFF;
}
} /* end for length */
for ( i=0; i<FNV512size/2; ++i )
ctx->Hash[i] = (uint16_t)temp[i]; // store back into hash
return fnvSuccess;
} /* end FNV512blockin */
/* hash in a zero-terminated string not including the zero (32-bit)
******************************************************************/
int FNV512stringin ( FNV512context * const ctx, const char *in ) {
uint32_t temp[FNV512size/2];
uint32_t temp2[11];
int i;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV512state:
ctx->Computed = FNVcomputed+FNV512state;
break;
case FNVcomputed+FNV512state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV512size/2; ++i )
temp[i] = ctx->Hash[i]; // copy into temp
while ( (ch = (uint8_t)*in++) ) {
/* temp = FNV512prime * ( temp ^ *in++ ); */
temp[FNV512size/2-1] ^= ch;
for ( i=0; i<11; ++i )
temp2[10-i] = temp[FNV512size/2-1-i] << FNV512shift;
for ( i=0; i<FNV512size/2; ++i )
temp[i] *= FNV512primeX;
for ( i=0; i<11; ++i )
temp[i] += temp2[i];
for ( i=FNV512size/2-1; i>0; --i ) {
temp[i-1] += temp[i] >> 16; // propagate carries
temp[i] &= 0xFFFF;
}
}
for ( i=0; i<FNV512size/2; ++i )
ctx->Hash[i] = temp[i]; // store back into hash
return fnvSuccess;
} /* end FNV512stringin */
/* return hash (32-bit)
******************************************************************/
int FNV512result ( FNV512context * const ctx,
uint8_t out[FNV512size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV512state )
return fnvStateError;
for ( int i=0; i<FNV512size/2; ++i ) {
out[2*i] = ctx->Hash[i] >> 8;
out[2*i+1] = ctx->Hash[i];
ctx->Hash[i] = 0;
}
ctx->Computed = FNVemptied+FNV512state;
return fnvSuccess;
} /* end FNV512result */
#endif /* FNV_64bitIntegers */
//*****************************************************************
// END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//*****************************************************************
<CODE ENDS>
8.2.6. FNV1024 Code
The following code is the header and C source for 1024-bit FNV-1a
providing a byte vector hash.
<CODE BEGINS> file "FNV1024.h"
//*********************** FNV1024.h ***********************//
//************* See RFC 9923 for details. *****************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
#ifndef _FNV1024_H_
#define _FNV1024_H_
/*
* Description:
* This file provides headers for the 1024-bit version of
* the FNV-1a non-cryptographic hash algorithm.
*/
#include "FNVconfig.h"
#include "FNVErrorCodes.h"
#include <stdint.h>
#define FNV1024size (1024/8)
/* If you do not have the ISO standard stdint.h header file, then
* you must typedef the following types:
*
* type meaning
* uint64_t unsigned 64-bit integer (ifdef FNV_64bitIntegers)
* uint32_t unsigned 32-bit integer
* uint16_t unsigned 16-bit integer
* uint8_t unsigned 8-bit integer (i.e., unsigned char)
*/
/*
* This structure holds context information for an FNV1024 hash
*/
#ifdef FNV_64bitIntegers
/* version if 64-bit integers supported */
typedef struct FNV1024context_s {
int Computed; /* state */
uint32_t Hash[FNV1024size/4];
} FNV1024context;
#else
/* version if 64-bit integers NOT supported */
typedef struct FNV1024context_s {
int Computed; /* state */
uint16_t Hash[FNV1024size/2];
} FNV1024context;
#endif /* FNV_64bitIntegers */
/* Function Prototypes:
*
* FNV1024string: hash a zero-terminated string not including
* the terminating zero
* FNV1024stringBasis: also takes an offset_basis parameter
*
* FNV1024block: hash a byte vector of a specified length
* FNV1024blockBasis: also takes an offset_basis parameter
*
* FNV1024file: hash the contents of a file
* FNV1024fileBasis: also takes an offset_basis parameter
*
* FNV1024init: initializes an FNV1024 context
* FNV1024initBasis: initializes an FNV1024 context with a
* provided 128-byte vector basis
* FNV1024blockin: hash in a byte vector of a specified length
* FNV1024stringin: hash in a zero-terminated string not
* including the terminating zero
* FNV1024filein: hash in the contents of a file
* FNV1024result: returns the hash value
*
* Hash is returned as an array of 8-bit unsigned integers
*/
#ifdef __cplusplus
extern "C" {
#endif
/* FNV1024 */
extern int FNV1024string ( const char *in,
uint8_t out[FNV1024size] );
extern int FNV1024stringBasis ( const char *in,
uint8_t out[FNV1024size],
const uint8_t basis[FNV1024size] );
extern int FNV1024block ( const void *vin,
long int length,
uint8_t out[FNV1024size] );
extern int FNV1024blockBasis ( const void *vin,
long int length,
uint8_t out[FNV1024size],
const uint8_t basis[FNV1024size] );
extern int FNV1024file ( const char *fname,
uint8_t out[FNV1024size] );
extern int FNV1024fileBasis ( const char *fname,
uint8_t out[FNV1024size],
const uint8_t basis[FNV1024size] );
extern int FNV1024init ( FNV1024context * const );
extern int FNV1024initBasis ( FNV1024context * const,
const uint8_t basis[FNV1024size] );
extern int FNV1024blockin ( FNV1024context * const,
const void *vin,
long int length );
extern int FNV1024stringin ( FNV1024context * const,
const char *in );
extern int FNV1024filein ( FNV1024context * const,
const char *fname );
extern int FNV1024result ( FNV1024context * const,
uint8_t out[FNV1024size] );
#ifdef __cplusplus
}
#endif
#endif /* _FNV1024_H_ */
<CODE ENDS>
<CODE BEGINS> file "FNV1024.c"
//************************** FNV1024.c **************************//
//****************** See RFC 9923 for details. ******************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
/* This file implements the FNV (Fowler/Noll/Vo) non-cryptographic
* hash function FNV-1a for 1024-bit hashes.
*/
#include <stdio.h>
#include "fnv-private.h"
#include "FNV1024.h"
//*****************************************************************
// COMMON CODE FOR 64- AND 32-BIT INTEGER MODES
//*****************************************************************
/* FNV1024: hash a zero-terminated string not including the zero
******************************************************************/
int FNV1024string ( const char *in, uint8_t out[FNV1024size] ) {
FNV1024context ctx;
int error;
if ( (error = FNV1024init ( &ctx )) )
return error;
if ( (error = FNV1024stringin ( &ctx, in )) )
return error;
return FNV1024result ( &ctx, out );
} /* end FNV1024string */
/* FNV1024: hash a zero-terminated string not including the zero
* with a non-standard basis
******************************************************************/
int FNV1024stringBasis ( const char *in,
uint8_t out[FNV1024size],
const uint8_t basis[FNV1024size] ) {
FNV1024context ctx;
int error;
if ( (error = FNV1024initBasis ( &ctx, basis )) )
return error;
if ( (error = FNV1024stringin ( &ctx, in )) )
return error;
return FNV1024result ( &ctx, out );
} /* end FNV1024stringBasis */
/* FNV1024: hash a counted block (64/32-bit)
******************************************************************/
int FNV1024block ( const void *vin,
long int length,
uint8_t out[FNV1024size] ) {
FNV1024context ctx;
int error;
if ( (error = FNV1024init ( &ctx )) )
return error;
if ( (error = FNV1024blockin ( &ctx, vin, length)) )
return error;
return FNV1024result ( &ctx, out );
} /* end FNV1024block */
/* FNV1024: hash a counted block (64/32-bit)
* with a non-standard basis
******************************************************************/
int FNV1024blockBasis ( const void *vin,
long int length,
uint8_t out[FNV1024size],
const uint8_t basis[FNV1024size] ) {
FNV1024context ctx;
int error;
if ( (error = FNV1024initBasis ( &ctx, basis )) )
return error;
if ( (error = FNV1024blockin ( &ctx, vin, length)) )
return error;
return FNV1024result ( &ctx, out );
} /* end FNV1024blockBasis */
/* hash the contents of a file
******************************************************************/
int FNV1024file ( const char *fname,
uint8_t out[FNV1024size] ) {
FNV1024context e1024Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV1024init (&e1024Context)) )
return error;
if ( (error = FNV1024filein (&e1024Context, fname)) )
return error;
return FNV1024result ( &e1024Context, out );
} /* end FNV1024file */
/* hash the contents of a file with a non-standard basis
******************************************************************/
int FNV1024fileBasis ( const char *fname,
uint8_t out[FNV1024size],
const uint8_t basis[FNV1024size] ) {
FNV1024context e1024Context;
int error;
if ( !out )
return fnvNull;
if ( (error = FNV1024initBasis (&e1024Context, basis)) )
return error;
if ( (error = FNV1024filein (&e1024Context, fname)) )
return error;
return FNV1024result ( &e1024Context, out );
} /* end FNV1024fileBasis */
/* hash in the contents of a file
******************************************************************/
int FNV1024filein ( FNV1024context * const e1024Context,
const char *fname ) {
FILE *fp;
long int i;
char buf[1024];
int error;
if ( !e1024Context || !fname )
return fnvNull;
switch ( e1024Context->Computed ) {
case FNVinited+FNV1024state:
e1024Context->Computed = FNVcomputed+FNV1024state;
break;
case FNVcomputed+FNV1024state:
break;
default:
return fnvStateError;
}
if ( ( fp = fopen ( fname, "rb") ) == NULL )
return fnvBadParam;
if ( (error = FNV1024blockin ( e1024Context, "", 0)) ) {
fclose(fp);
return error;
}
while ( ( i = fread ( buf, 1, sizeof(buf), fp ) ) > 0 )
if ( (error = FNV1024blockin ( e1024Context, buf, i)) ) {
fclose(fp);
return error;
}
error = ferror(fp);
fclose(fp);
if (error) return fnvBadParam;
return fnvSuccess;
} /* end FNV1024filein */
//****************************************************************//
// START VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//****************************************************************//
#ifdef FNV_64bitIntegers
/* 1024-bit FNV_prime = 2^680 + 2^8 + 0x8d =
0x0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 0000010000000000
0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 000000000000018D */
#define FNV1024primeX 0x018D
#define FNV1024shift 8
//***************************************************************//
// Set of init, input, and output functions below
// to incrementally compute FNV1024
//**************************************************************//
/* initialize context (64-bit)
******************************************************************/
int FNV1024init ( FNV1024context * const ctx ) {
const uint32_t FNV1024basis[FNV1024size/4] = {
0x00000000, 0x00000000, 0x005F7A76, 0x758ECC4D,
0x32E56D5A, 0x591028B7, 0x4B29FC42, 0x23FDADA1,
0x6C3BF34E, 0xDA3674DA, 0x9A21D900, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x0004C6D7,
0xEB6E7380, 0x2734510A, 0x555F256C, 0xC005AE55,
0x6BDE8CC9, 0xC6A93B21, 0xAFF4B16C, 0x71EE90B3 };
if ( !ctx )
return fnvNull;
for ( int i=0; i<FNV1024size/4; ++i )
ctx->Hash[i] = FNV1024basis[i];
ctx->Computed = FNVinited+FNV1024state;
return fnvSuccess;
} /* end FNV1024init */
/* initialize context with a provided 128-byte vector basis (64-bit)
*******************************************************************/
int FNV1024initBasis ( FNV1024context * const ctx,
const uint8_t basis[FNV1024size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i < FNV1024size/4; ++i ) {
uint32_t temp = *basis++<<24;
temp += *basis++<<16;
temp += *basis++<<8;
ctx->Hash[i] = temp + *basis++;
}
ctx->Computed = FNVinited+FNV1024state;
return fnvSuccess;
} /* end FNV1024initBasis */
/* hash in a counted block (64-bit)
******************************************************************/
int FNV1024blockin ( FNV1024context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint64_t temp[FNV1024size/4];
uint64_t temp2[11];
int i;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV1024state:
ctx->Computed = FNVcomputed+FNV1024state;
break;
case FNVcomputed+FNV1024state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV1024size/4; ++i )
temp[i] = ctx->Hash[i]; // copy into temp
for ( ; length > 0; length-- ) {
/* temp = FNV1024prime * ( temp ^ *in++ ); */
temp[FNV1024size/4-1] ^= *in++;
for ( i=0; i<11; ++i )
temp2[10-i] = temp[FNV1024size/4-1-i] << FNV1024shift;
for ( i=0; i<FNV1024size/4; ++i )
temp[i] *= FNV1024primeX;
for ( i=0; i<11; ++i )
temp[i] += temp2[i];
for ( i=FNV1024size/4-1; i>0; --i ) {
temp[i-1] += temp[i] >> 32; // propagate carries
temp[i] &= 0xFFFFFFFF;
}
} /* end for length */
for ( i=0; i<FNV1024size/4; ++i )
ctx->Hash[i] = (uint32_t)temp[i]; // store back into hash
return fnvSuccess;
} /* end FNV1024blockin */
/* hash in a zero-terminated string not including the zero (64-bit)
******************************************************************/
int FNV1024stringin ( FNV1024context * const ctx, const char *in ) {
uint64_t temp[FNV1024size/4];
uint64_t temp2[11];
int i;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV1024state:
ctx->Computed = FNVcomputed+FNV1024state;
break;
case FNVcomputed+FNV1024state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV1024size/4; ++i )
temp[i] = ctx->Hash[i]; // copy into temp
while ( (ch = (uint8_t)*in++) ) {
/* temp = FNV1024prime * ( temp ^ ch ); */
temp[FNV1024size/4-1] ^= ch;
for ( i=0; i<11; ++i )
temp2[10-i] = temp[FNV1024size/4-1-i] << FNV1024shift;
for ( i=0; i<FNV1024size/4; ++i )
temp[i] *= FNV1024primeX;
for ( i=0; i<11; ++i )
temp[i] += temp2[i];
for ( i=FNV1024size/4-1; i>0; --i ) {
temp[i-1] += temp[i] >> 32;
temp[i] &= 0xFFFFFFFF;
}
}
for ( i=0; i<FNV1024size/4; ++i )
ctx->Hash[i] = (uint32_t)temp[i]; // store back into hash
return fnvSuccess;
} /* end FNV1024stringin */
/* return hash (64-bit)
******************************************************************/
int FNV1024result ( FNV1024context * const ctx,
uint8_t out[FNV1024size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV1024state )
return fnvStateError;
for ( int i=0; i<FNV1024size/4; ++i ) {
out[4*i] = ctx->Hash[i] >> 24;
out[4*i+1] = ctx->Hash[i] >> 16;
out[4*i+2] = ctx->Hash[i] >> 8;
out[4*i+3] = ctx->Hash[i];
ctx -> Hash[i] = 0;
}
ctx->Computed = FNVemptied+FNV1024state;
return fnvSuccess;
} /* end FNV1024result */
//****************************************************************//
// END VERSION FOR WHEN YOU HAVE 64-BIT ARITHMETIC
//****************************************************************//
#else /* FNV_64bitIntegers */
//****************************************************************//
// START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//****************************************************************//
/*
1024-bit FNV_prime = 2^680 + 2^8 + 0x8d =
0x00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000100 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 0000018D */
#define FNV1024primeX 0x018D
#define FNV1024shift 8
//*****************************************************************
// Set of init, input, and output functions below
// to incrementally compute FNV1024
//*****************************************************************
/* initialize context (32-bit)
******************************************************************/
int FNV1024init ( FNV1024context * const ctx ) {
const uint16_t FNV1024basis[FNV1024size/2] = {
0x0000, 0x0000, 0x0000, 0x0000, 0x005F, 0x7A76, 0x758E, 0xCC4D,
0x32E5, 0x6D5A, 0x5910, 0x28B7, 0x4B29, 0xFC42, 0x23FD, 0xADA1,
0x6C3B, 0xF34E, 0xDA36, 0x74DA, 0x9A21, 0xD900, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0004, 0xC6D7,
0xEB6E, 0x7380, 0x2734, 0x510A, 0x555F, 0x256C, 0xC005, 0xAE55,
0x6BDE, 0x8CC9, 0xC6A9, 0x3B21, 0xAFF4, 0xB16C, 0x71EE, 0x90B3 };
if ( !ctx )
return fnvNull;
for ( int i=0; i<FNV1024size/2; ++i )
ctx->Hash[i] = FNV1024basis[i];
ctx->Computed = FNVinited+FNV1024state;
return fnvSuccess;
} /* end FNV1024init */
/* initialize context with a provided 128-byte vector basis (32-bit)
*******************************************************************/
int FNV1024initBasis ( FNV1024context * const ctx,
const uint8_t basis[FNV1024size] ) {
if ( !ctx || !basis )
return fnvNull;
for ( int i=0; i < FNV1024size/2; ++i ) {
uint32_t temp = *basis++;
ctx->Hash[i] = ( temp<<8 ) + *basis++;
}
ctx->Computed = FNVinited+FNV1024state;
return fnvSuccess;
} /* end FNV1024initBasis */
/* hash in a counted block (32-bit)
******************************************************************/
int FNV1024blockin ( FNV1024context * const ctx,
const void *vin,
long int length ) {
const uint8_t *in = (const uint8_t*)vin;
uint32_t temp[FNV1024size/2];
uint32_t temp2[22];
int i;
if ( !ctx || !in )
return fnvNull;
if ( length < 0 )
return fnvBadParam;
switch ( ctx->Computed ) {
case FNVinited+FNV1024state:
ctx->Computed = FNVcomputed+FNV1024state;
break;
case FNVcomputed+FNV1024state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV1024size/2; ++i )
temp[i] = ctx->Hash[i]; // copy into temp
for ( ; length > 0; length-- ) {
/* temp = FNV1024prime * ( temp ^ *in++ ); */
temp[FNV1024size/2-1] ^= *in++;
for ( i=0; i<22; ++i )
temp2[21-i] = temp[FNV1024size/2-1-i] << FNV1024shift;
for ( i=0; i<FNV1024size/2; ++i )
temp[i] *= FNV1024primeX;
for ( i=0; i<22; ++i )
temp[i] += temp2[i];
for ( i=FNV1024size/2-1; i>0; --i ) {
temp[i-1] += temp[i] >> 16; // propagate carries
temp[i] &= 0xFFFF;
}
}
for ( i=0; i<FNV1024size/2; ++i )
ctx->Hash[i] = temp[i]; // store back into hash
return fnvSuccess;
} /* end FNV1024blockin */
/* hash in a zero-terminated string not including the zero (32-bit)
******************************************************************/
int FNV1024stringin ( FNV1024context * const ctx, const char *in ) {
uint32_t temp[FNV1024size/2];
uint32_t temp2[22];
int i;
uint8_t ch;
if ( !ctx || !in )
return fnvNull;
switch ( ctx->Computed ) {
case FNVinited+FNV1024state:
ctx->Computed = FNVcomputed+FNV1024state;
break;
case FNVcomputed+FNV1024state:
break;
default:
return fnvStateError;
}
for ( i=0; i<FNV1024size/2; ++i )
temp[i] = ctx->Hash[i]; // copy into temp
while ( (ch = (uint8_t)*in++) ) {
/* temp = FNV1024prime * ( temp ^ *in++ ); */
temp[FNV1024size/2-1] ^= ch;
for ( i=0; i<22; ++i )
temp2[21-i] = temp[FNV1024size/2-1-i] << FNV1024shift;
for ( i=0; i<FNV1024size/2; ++i )
temp[i] *= FNV1024primeX;
for ( i=0; i<22; ++i )
temp[i] += temp2[i];
for ( i=FNV1024size/2-1; i>0; --i ) {
temp[i-1] += temp[i] >> 16; // propagate carries
temp[i] &= 0xFFFF;
}
}
for ( i=0; i<FNV1024size/2; ++i )
ctx->Hash[i] = temp[i]; // store back into hash
return fnvSuccess;
} /* end FNV1024stringin */
/* return hash (32-bit)
******************************************************************/
int FNV1024result ( FNV1024context * const ctx,
uint8_t out[FNV1024size] ) {
if ( !ctx || !out )
return fnvNull;
if ( ctx->Computed != FNVcomputed+FNV1024state )
return fnvStateError;
for ( int i=0; i<FNV1024size/2; ++i ) {
out[2*i] = ctx->Hash[i] >> 8;
out[2*i+1] = ctx->Hash[i];
ctx->Hash[i] = 0;
}
ctx->Computed = FNVemptied+FNV1024state;
return fnvSuccess;
} /* end FNV1024result */
#endif /* FNV_64bitIntegers */
//****************************************************************//
// END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC
//****************************************************************//
<CODE ENDS>
8.3. FNV Test Code
Below is source code for a test driver with a command line interface
as documented in Section 8.1.3. By default, with no command line
arguments, it runs tests of all FNV lengths.
<CODE BEGINS> file "main.c"
//************************* Main.c **************************//
//*************** See RFC 9923 for details. *****************//
/* Copyright (c) 2016-2025 IETF Trust and the persons
* identified as authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution.
*/
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
/* To do a thorough test, you need to run with
* FNV_64bitIntegers defined and with it undefined
*/
#include "FNVconfig.h"
#include "fnv-private.h"
#include "FNV32.h"
#include "FNV64.h"
#include "FNV128.h"
#include "FNV256.h"
#include "FNV512.h"
#include "FNV1024.h"
/* global variables */
char *funcName = "funcName not set?";
const char *errteststring = "foo";
int Terr = -1; /* Total errors */
int verbose = 0; /* Verbose flag */
enum { FNV32selected = 0, FNV64selected, FNV128selected,
FNV256selected, FNV512selected, FNV1024selected,
FNVnone = -1 } selected = FNVnone;
#define NTestBytes 3
const uint8_t errtestbytes[NTestBytes] = { (uint8_t)1,
(uint8_t)2, (uint8_t)3 };
// initial teststring is null, so initial result is offset_basis
const char *teststring[] = {
"",
"a",
"foobar",
"Hello!\x01\xFF\xED"
};
#define NTstrings (sizeof(teststring)/sizeof(char *))
// due to FNV-1 versus FNV1a, XOR in final backslash separately
const char BasisString[] = "chongo <Landon Curt Noll> /\\../";
FNV32context e32Context;
uint32_t eUint32 = 42;
#ifdef FNV_64bitIntegers
uint64_t eUint64 = 42;
#endif
FNV64context e64Context;
FNV128context e128Context;
FNV256context e256Context;
FNV512context e512Context;
FNV1024context e1024Context;
uint8_t hash[FNV1024size]; /* largest size needed */
uint8_t FakeBasis[FNV1024size];
uint8_t ZeroBasis[FNV1024size];
char tempFileNameTemplate[] = "tmp.XXXXXXXXXX";
const char *tempFileName = 0;
//****************************************************************
// local prototypes in alphabetical order
//****************************************************************
void CommonTest ( void );
void ErrTestReport ( void );
int find_selected(const char *optarg);
void HexPrint ( int count, const uint8_t *ptr );
void TestAll ( void );
void Test32 ( void );
void Test64 ( void );
void Test128 ( void );
void Test256 ( void );
void Test512 ( void );
void Test1024 ( void );
void TestNValue ( const char *subfunc, // test calculated value
const char *string,
int N, // size
const uint8_t *was,
const uint8_t should[N] );
int TestR ( const char *,
int expect,
int actual ); // test return code
void usage( const char *argv0 ); // print help message
void ValueTestReport ( void ); // print test results
#ifndef FNV_64bitIntegers
# undef uint64
# define uint64_t no_64_bit_integers
#endif /* FNV_64bitIntegers */
// array of function pointers, etc.
struct { // sometimes indexed into by the enum variable "selected"
int length;
void (*Testfunc)( void );
int (*Stringfunc)( const char *, uint8_t *); // string
int (*Blockfunc)( const void *, long int, uint8_t *); // block
int (*Filefunc)( const char *, uint8_t *); // file
int (*StringBasisfunc)
( const char *, uint8_t *, const uint8_t *); // stringBasis
int (*BlockBasisfunc)
(const void *, long int, uint8_t *,
const uint8_t *); // blockBasis
int (*FileBasisfunc)
(const char *, uint8_t *, const uint8_t *); // fileBlock
} funcmap[] = { // valid sizes
{ 32, Test32, FNV32string, FNV32block, FNV32file,
FNV32stringBasis, FNV32blockBasis, FNV32fileBasis },
{ 64, Test64, FNV64string, FNV64block, FNV64file,
FNV64stringBasis, FNV64blockBasis, FNV64fileBasis },
{ 128, Test128, FNV128string, FNV128block, FNV128file,
FNV128stringBasis, FNV128blockBasis, FNV128fileBasis },
{ 256, Test256, FNV256string, FNV256block, FNV256file,
FNV256stringBasis, FNV256blockBasis, FNV256fileBasis },
{ 512, Test512, FNV512string, FNV512block, FNV512file,
FNV512stringBasis, FNV512blockBasis, FNV512fileBasis },
{ 1024, Test1024, FNV1024string, FNV1024block, FNV1024file,
FNV1024stringBasis, FNV1024blockBasis, FNV1024fileBasis },
{ 0, Test32, FNV32string, FNV32block, FNV32file } // fence post
};
//****************************************************************
// main
//****************************************************************
int main( int argc, const char **argv ) {
int option; // command line option letter
int i;
uint16_t endianness = 5*256 + 11;
mkstemp(tempFileNameTemplate);
tempFileName = tempFileNameTemplate;
if ( ((uint8_t *)&endianness)[0] != 11 )
printf ("Coded for little endian but computer seems\n"
" to be big endian! Multi-byte integer results\n"
" may be incorrect!\n");
for ( i=0; i<FNV1024size; ++i ) {// initialize a couple of arrays
ZeroBasis[i] = 0;
FakeBasis[i] = (uint8_t)i;
}
if ( argc == 1 ) { // if no arguments
TestAll();
if ( tempFileName )
unlink(tempFileName);
exit(0);
}
// process command line options
//*****************************************************************
while ((option = getopt(argc, (char *const *)argv, ":af:ht:u:v"))
!= -1) {
if ( verbose )
printf ( "Got option %c\n", option );
switch ( option ) {
case 'a': // run all tests
TestAll();
break;
case 'f': // followed by name of file to hash
if ( selected == FNVnone ) {
printf ( "No hash size selected.\n" );
break;
}
printf ( "FNV-%i Hash of contents of file '%s':\n",
funcmap[selected].length, optarg );
if ( funcmap[selected].Filefunc ( optarg, hash ))
printf ( "Hashing file '%s' fails: %s.\n",
optarg, strerror(errno) );
else
HexPrint ( funcmap[selected].length/8, hash );
printf ( "\n" );
break;
case 'h': // help
usage( argv[0] );
break;
case 't': // followed by size of FNV to test, 0->all
selected = find_selected(optarg);
if (selected == FNVnone)
printf ( "Bad argument to option -t\n"
"Valid sizes are 32, 64, 128,"
" 256, 512, and 1024\n" );
else
funcmap[selected].Testfunc(); // invoke test
break;
case 'u': // followed by size of FNV to use
selected = find_selected(optarg);
if ( selected == FNVnone )
printf ( "Bad argument to option -u\n"
"Valid sizes are 32, 64, 128,"
" 256, 512, and 1024\n" );
break;
case 'v': // toggle Verbose flag
if ( (verbose ^= 1) ) {
printf ( "Verbose on.\n" );
#ifdef FNV_64bitIntegers
printf ("Has 64-bit integers. ");
#else
printf ("Does not have 64-bit integers. ");
#endif
// also tests the TestR function
funcName = "Testing TestR";
TestR ( "should fail", 1, 2 );
TestR ( "should not have failed", 3, 3 );
}
else
printf ( "Verbose off.\n" );
break;
case '?': //
printf ( "Unknown option %c\n", optopt );
usage( argv[0] );
return 1;
} /* end switch */
} /* end while */
if ( ( option == -1 ) && verbose )
printf ( "No more options.\n" );
// Through all the options, now, if a size is set, encrypt any
// other tokens on the command line
//******************************************************
for ( i = optind; i < argc; ++i ) {
int rc; // return code
if ( selected == FNVnone ) {
printf ( "No hash size selected.\n" );
break; // out of for
}
rc = funcmap[selected].Stringfunc(argv[i], hash);
if ( rc )
printf ( "FNV-%i of '%s' returns error %i\n",
funcmap[selected].length,
argv[i], rc );
else {
printf ( "FNV-%i of '%s' is ",
funcmap[selected].length, argv[i] );
HexPrint ( funcmap[selected].length/8, hash );
printf ( "\n" );
}
}
if ( tempFileName )
unlink(tempFileName);
return 0;
} /* end main */
/* Write to a temp file
******************************************************************/
const char *WriteTemp( const char *str, long int iLen ) {
FILE *fp = fopen( tempFileName, "w" );
if (!fp) {
printf ( "Cannot open tempfile: %s: %s\n",
tempFileName, strerror(errno) );
return 0;
}
long int ret = fwrite( str, 1, iLen, fp );
fclose(fp);
if ( ret != iLen ) {
printf ( "Cannot write tempfile: %s: %s\n",
tempFileName, strerror(errno) );
return 0;
}
return tempFileName;
}
//****************************************************************
// Test status return code
//****************************************************************
int TestR ( const char *name, int expect, int actual ) {
if ( expect != actual ) {
printf ( "%s %s returned %i instead of %i.\n",
funcName, name, actual, expect );
++Terr; /* increment error count */
}
return actual;
} /* end TestR */
//****************************************************************
// General byte vector return value test
//****************************************************************
void TestNValue ( const char *subfunc,
const char *string, // usually what was hashed
int N,
const uint8_t was[N],
const uint8_t should[N] ) {
if ( memcmp ( was, should, N ) != 0 ) {
++Terr;
printf ( "%s %s of '%s'",
funcName, subfunc, string );
printf ( " computed " );
HexPrint ( N, was );
printf ( ", expected " );
HexPrint ( N, should );
printf ( ".\n" );
}
else if ( verbose ) {
printf ( "%s %s of '%s' computed ",
funcName, subfunc, string );
HexPrint ( N, was );
printf ( " as expected.\n" );
}
} /* end TestNValue */
//****************************************************************
// Reports on status/value returns
//****************************************************************
void ErrTestReport ( void ) {
if ( Terr )
printf ( "%s test of error checks failed %i times.\n",
funcName, Terr );
else if ( verbose )
printf ( "%s test of error checks passed.\n",
funcName );
} /* end ErrTestReport */
void ValueTestReport ( void ) {
if ( Terr )
printf ( "%s test of return values failed %i times.\n",
funcName, Terr );
else
printf ( "%s test of return values passed.\n", funcName );
} /* end ValueTestReport */
//****************************************************************
// Verify the size of hash as a command line option argument
// and return the index in funcmap[], -1 if not found.
//****************************************************************
int find_selected(const char *optarg) {
int argval, count;
count = sscanf ( optarg, "%i", &argval );
if ( count > 0 ) {
int i;
for ( i = 0; funcmap[i].length; ++i ) {
if ( funcmap[i].length == argval ) {
return i;
} /* end if */
} /* end for */
}
return FNVnone;
} /* end find_selected */
//****************************************************************
// Print some bytes as hexadecimal
//****************************************************************
void HexPrint( int count, const uint8_t *ptr ) {
for ( int i = 0; i < count; ++i )
printf ( "%02X", ptr[i] );
} /* end HexPrint */
//****************************************************************
// Test all sizes
//****************************************************************
void TestAll ( void ) {
for ( int i=0; funcmap[i].length; ++i )
funcmap[i].Testfunc ();
} /* end TestAll */
//****************************************************************
// Common error check tests
//****************************************************************
void CommonTest ( void ) {
TestR ( "string1b", fnvNull,
funcmap[selected].Stringfunc ( (char *)0, hash ) );
TestR ( "string2b", fnvNull,
funcmap[selected].Stringfunc ( errteststring,
(uint8_t *)0 ) );
TestR ( "strBasis1b", fnvNull,
funcmap[selected].StringBasisfunc ( (char *)0,
hash, FakeBasis ) );
TestR ( "strBasis2b", fnvNull,
funcmap[selected].StringBasisfunc ( errteststring,
(uint8_t *)0, FakeBasis ) );
TestR ( "strBasis3b", fnvNull,
funcmap[selected].StringBasisfunc ( errteststring,
hash, (uint8_t *)0 ) );
TestR ( "blk1", fnvNull,
funcmap[selected].Blockfunc ( (uint8_t *)0, 1, hash ) );
TestR ( "blk2", fnvBadParam,
funcmap[selected].Blockfunc ( errtestbytes, -1, hash ) );
TestR ( "blk3", fnvNull,
funcmap[selected].Blockfunc ( errtestbytes, 1,
(uint8_t *)0 ) );
TestR ( "blk1b", fnvNull,
funcmap[selected].BlockBasisfunc ( (uint8_t *)0, 1,
hash, FakeBasis ) );
TestR ( "blk2b", fnvBadParam,
funcmap[selected].BlockBasisfunc ( errtestbytes, -1,
hash, FakeBasis ) );
TestR ( "blk3b", fnvNull,
funcmap[selected].BlockBasisfunc ( errtestbytes, 1,
(uint8_t *)0, FakeBasis ) );
TestR ( "blk4b", fnvNull,
funcmap[selected].BlockBasisfunc ( errtestbytes, 1,
hash, (uint8_t *)0 ) );
TestR ( "file1", fnvNull,
funcmap[selected].Filefunc ( (char *)0, hash ) );
TestR ( "file2", fnvNull,
funcmap[selected].Filefunc ( "foo.txt", (uint8_t *)0 ) );
TestR ( "file1b", fnvNull,
funcmap[selected].FileBasisfunc ( (char *)0, hash,
FakeBasis ) );
TestR ( "file2b", fnvNull,
funcmap[selected].FileBasisfunc ( "foo.txt", (uint8_t *)0,
FakeBasis ) );
TestR ( "file3b", fnvNull,
funcmap[selected].FileBasisfunc ( "foo.txt", hash,
(uint8_t *)0 ) );
} /* end CommonTest */
//****************************************************************
// Print command line help
//****************************************************************
void usage( const char *argv0 ) {
printf (
"%s [-a] [-t nnn] [-u nnn] [-v] [-f filename] [token ...]\n"
" -a = run all tests\n"
" -f filename = hash file contents\n"
" -h = help, print this message\n"
" -t nnn = Test hash size nnn\n"
" -u nnn = Use hash size nnn\n"
" -v = toggle Verbose flag\n"
" Each token is hashed.\n", argv0 );
} /* end usage */
//****************************************************************
// Test Macros
//****************************************************************
// test for return values
//************************
#define TestInit(INIT,CTX,CTXT) \
TestR ( "init1", fnvSuccess, INIT ( &CTX ) ); \
TestR ( "init2", fnvNull, INIT ( (CTXT *)0 ) );
#define TestInitBasis(INITB,CTX,CTXT) \
TestR ( "initB1", fnvSuccess, INITB (&CTX, FakeBasis ) ); \
TestR ( "initB2", fnvNull, INITB ( (CTXT *)0, hash ) ); \
TestR ( "initB3", fnvNull, INITB ( &CTX, (uint8_t *)0 ) );
#define TestBlockin(BLKIN,CTX,CTXT) \
TestR ( "blockin1", fnvNull, \
BLKIN ( (CTXT *)0, errtestbytes, NTestBytes ) ); \
TestR ( "blockin2", fnvNull, \
BLKIN ( &CTX, (uint8_t *)0, NTestBytes ) ); \
TestR ( "blockin3", fnvBadParam, \
BLKIN ( &CTX, errtestbytes, -1 ) ); \
TestR ( "blockin4", fnvStateError, \
BLKIN ( &CTX, errtestbytes, NTestBytes ) );
#define TestStringin(STRIN,CTX,CTXT) \
TestR ( "stringin1", fnvNull, \
STRIN ( (CTXT *)0, errteststring ) ); \
TestR ( "stringin2", fnvNull, STRIN ( &CTX, (char *)0 ) ); \
TestR ( "stringin3", fnvStateError, \
STRIN ( &CTX, errteststring ) );
#define TestFilein(FLIN,CTX,CTXT) \
TestR ( "file1", fnvNull, FLIN ( (CTXT *)0, errteststring ) ); \
TestR ( "file2", fnvNull, FLIN ( &CTX, (char *)0 ) ); \
TestR ( "file3", fnvStateError, \
FLIN ( &CTX, errteststring ) );
#define TestResult(RSLT,CTX,CTXT) \
TestR ( "result1", fnvNull, RSLT ( (CTXT *)0, hash ) ); \
TestR ( "result2", fnvNull, RSLT ( &CTX, (uint8_t *)0 ) ); \
TestR ( "result3", fnvStateError, \
FNV128result ( &e128Context, hash ) );
// test return values for INT versions including non-std basis
//*************************************************************
#define TestINT(STRINT,STRINTB,BLKINT,BLKINTB,INITINTB, \
INTV,INTVT,ctxT) \
TestR ( "string1i", fnvNull, STRINT ( (char *)0, &INTV ) ); \
TestR ( "string2i", fnvNull, \
STRINT ( errteststring, (INTVT *)0 ) ); \
TestR ( "string3i", fnvNull, STRINTB ((char *)0, &INTV, INTV) );\
TestR ( "string4i", fnvNull, \
STRINTB (errteststring, (INTVT *)0, INTV) ); \
TestR ( "block1i", fnvNull, BLKINT ( (uint8_t *)0, 1, &INTV ) );\
TestR ( "block2i", fnvBadParam, \
BLKINT ( errtestbytes, -1, &INTV ) ); \
TestR ( "block3i", fnvNull, \
BLKINT ( errtestbytes, 1, (INTVT *)0 ) ); \
TestR ( "block4i", fnvNull, \
BLKINTB ( (uint8_t *)0, 1, &INTV, INTV ) ); \
TestR ( "block5i", fnvBadParam, \
BLKINTB ( errtestbytes, -1, &INTV, INTV ) ); \
TestR ( "block6i", fnvNull, \
BLKINTB ( errtestbytes, 1, (INTVT *)0, INTV ) ); \
TestR ( "initBasis1i", fnvNull, INITINTB ( (ctxT *)0, INTV ) );
#define TestINTrf(RSLTINT,FILEINT,FILEINTB, \
ctx,ctxT,INTV,INTVT) \
TestR ( "result1i", fnvNull, RSLTINT ( (ctxT *)0, &INTV ) ); \
TestR ( "result2i", fnvNull, RSLTINT ( &ctx, (INTVT *)0 ) ); \
TestR ( "result3i", fnvStateError, RSLTINT ( &ctx, &INTV ) ); \
TestR ( "file1i", fnvNull, FILEINT ( (char *)0, &INTV ) ); \
TestR ( "file2i", fnvNull, FILEINT ( "foo.txt", (INTVT *)0 ) ); \
TestR ( "file3i", fnvNull, FILEINTB ( (char *)0, &INTV, INTV) );\
TestR ( "file4i", fnvNull, \
FILEINTB ( "foo.txt", (INTVT *)0, INTV ) );
// test to calculate standard basis from basis zero FNV-1
// depends on zero basis making the initial multiply a no-op
//*****************************
#define BasisZero(STRING,SIZ,VALUE) \
err = TestR ( "fnv0s", fnvSuccess, \
STRING ( BasisString, hash, ZeroBasis ) ); \
if ( err == fnvSuccess ) { \
hash[SIZ-1] ^= '\\'; \
TestNValue ( "fnv0sv", BasisString, SIZ, hash, VALUE[0] ); \
}
#define BasisINTZero(STRINT,SIZ,VALUE,INTV,INTVT) \
err = TestR ( "fnv0s", fnvSuccess, \
STRINT ( BasisString, &INTV, (INTVT) 0 ) ); \
if ( err == fnvSuccess ) { \
INTV ^= '\\'; \
TestNValue ( "fnv0svi", BasisString, SIZ, \
(uint8_t *)&INTV, (uint8_t *)&VALUE[0] ); \
}
// test for return hash values
//*****************************
#define TestSTRBLKHash(STR,BLK,SVAL,BVAL,SZ) \
if ( TestR ( "stringa", fnvSuccess, \
STR ( teststring[i], hash ) ) ) \
printf ( " Index = %i\n", i ); \
else \
TestNValue ( "stringb", teststring[i], SZ, \
hash, (uint8_t *)&SVAL[i] ); \
if ( TestR ( "blocka", fnvSuccess, BLK ( teststring[i], \
(long int)(strlen(teststring[i])+1), hash ) ) ) \
printf ( " Index = %i\n", i ); \
else \
TestNValue ( "blockb", teststring[i], SZ, \
hash, (uint8_t *)&BVAL[i] );
// Test incremental functions
//****************************
#define IncrHash(INIT,CTX,BLK,RSLT,INITB,STR,SZ,SVAL) \
err = TestR ( "inita", fnvSuccess, INIT ( &CTX ) ); \
if ( err ) break; \
iLen = strlen ( teststring[i] ); \
err = TestR ( "blockina", fnvSuccess, \
BLK ( &CTX, (uint8_t *)teststring[i], iLen/2 ) ); \
if ( err ) break; \
if ( i & 1 ) { \
err = TestR ( "basisra", fnvSuccess, RSLT ( &CTX, hash ) ); \
if ( err ) break; \
err = TestR ( "basisia", fnvSuccess, INITB ( &CTX, hash ) );\
if ( err ) break; \
} \
err = TestR ( "stringina", fnvSuccess, STR ( &CTX, \
teststring[i] + iLen/2 ) ); \
if ( err ) break; \
err = TestR ( "resulta", fnvSuccess, RSLT ( &CTX, hash ) ); \
if ( err ) break; \
TestNValue ( "incrementala", teststring[i], SZ, \
hash, (uint8_t *)&SVAL[i] );
// test file hash
//*****************************
#define TestFILEHash(FILE,BVAL,SZ) \
err = TestR ( "fileafh", fnvSuccess, \
FILE ( WriteTemp(teststring[i], iLen), \
hash ) ); \
if ( err ) break; \
TestNValue ( "filebfh", teststring[i], SZ, hash, \
(uint8_t *)&BVAL[i] );
//****************************************************************
// FNV32 Test
//****************************************************************
void Test32 ( void ) {
long int iLen;
uint32_t FNV32svalues[NTstrings] = {
0x811c9dc5, 0xe40c292c, 0xbf9cf968, 0xfd9d3881 };
uint32_t FNV32bvalues[NTstrings] = {
0x050c5d1f, 0x2b24d044, 0x0c1c9eb8, 0xbf7ff313 };
int i, err;
uint8_t FNV32basisT[FNV32size] = {0xC5, 0x9D, 0x1C, 0x81 };
funcName = "FNV-32";
selected = FNV32selected;
/* test error checks */
Terr = 0;
TestInit (FNV32init, e32Context, FNV32context)
TestInitBasis (FNV32initBasis, e32Context, FNV32context)
CommonTest();
TestINT (FNV32INTstring, FNV32INTstringBasis, FNV32INTblock,
FNV32INTblockBasis, FNV32INTinitBasis, eUint32,
uint32_t, FNV32context)
e32Context.Computed = FNVclobber+FNV32state;
TestBlockin (FNV32blockin, e32Context, FNV32context)
TestStringin (FNV32stringin, e32Context, FNV32context)
TestFilein (FNV32filein, e32Context, FNV32context)
TestResult (FNV32result, e32Context, FNV32context)
TestINTrf(FNV32INTresult,FNV32INTfile,FNV32INTfileBasis,
e32Context,FNV32context,eUint32,uint32_t)
ErrTestReport ();
Terr = 0;
err = TestR ( "fnv0s", fnvSuccess,
FNV32stringBasis ( BasisString, hash, ZeroBasis ) );
if ( err == fnvSuccess ) {
hash[0] ^= '\\';
TestNValue ( "fnv0sv32", BasisString, FNV32size,
hash, (uint8_t *)&FNV32svalues[0]);
}
BasisINTZero (FNV32INTstringBasis,FNV32size,FNV32svalues, \
eUint32,uint32_t)
for ( i = 0; i < NTstrings; ++i ) {
/* test actual results int */
err = TestR ( "stringai", fnvSuccess,
FNV32INTstring ( teststring[i], &eUint32 ) );
if ( err == fnvSuccess )
TestNValue ( "stringbi", teststring[i], FNV32size,
(uint8_t *)&eUint32,
(uint8_t *)&FNV32svalues[i] );
err = TestR ( "blockai", fnvSuccess,
FNV32INTblock ( (uint8_t *)teststring[i],
(unsigned long)(strlen(teststring[i])+1),
&eUint32 ) );
if ( err == fnvSuccess )
TestNValue ( "blockbi", teststring[i], FNV32size,
(uint8_t *)&eUint32,
(uint8_t *)&FNV32bvalues[i] );
/* test actual results byte */
TestSTRBLKHash ( FNV32string, FNV32block, FNV32svalues,
FNV32bvalues, FNV32size )
/* now try testing the incremental stuff */
IncrHash (FNV32init, e32Context, FNV32blockin, FNV32result,
FNV32initBasis, FNV32stringin, FNV32size, FNV32svalues)
/* now try testing the incremental stuff int */
err = TestR ( "initai", fnvSuccess,
FNV32init (&e32Context) );
if ( err ) break;
iLen = strlen ( teststring[i] );
err = TestR ( "blockinai", fnvSuccess,
FNV32blockin ( &e32Context,
(uint8_t *)teststring[i],
iLen/2 ) );
if ( err ) break;
err = TestR ( "stringinai", fnvSuccess,
FNV32stringin ( &e32Context,
teststring[i] + iLen/2 ) );
if ( err ) break;
err = TestR ( "resultai", fnvSuccess,
FNV32INTresult ( &e32Context, &eUint32 ) );
if ( err ) break;
TestNValue ( "incrementalai", teststring[i], FNV32size,
(uint8_t *)&eUint32,
(uint8_t *)&FNV32svalues[i] );
/* now try testing the incremental stuff byte basis */
err = TestR ( "initab", fnvSuccess,
FNV32initBasis (&e32Context,
(uint8_t *)&FNV32basisT) );
if ( err ) break;
iLen = strlen ( teststring[i] );
err = TestR ( "blockinab", fnvSuccess,
FNV32blockin ( &e32Context,
(uint8_t *)teststring[i],
iLen/2 ) );
if ( err ) break;
err = TestR ( "stringinab", fnvSuccess,
FNV32stringin ( &e32Context,
teststring[i] + iLen/2 ) );
if ( err ) break;
err = TestR ( "resultab", fnvSuccess,
FNV32result ( &e32Context, hash ) );
if ( err ) break;
TestNValue ( "incrementala", teststring[i], FNV32size,
hash, (uint8_t *)&FNV32svalues[i] );
/* now try testing file hash int */
err = TestR ( "fileafi", fnvSuccess,
FNV32INTfile ( WriteTemp(teststring[i], iLen),
&eUint32 ) );
if ( err ) break;
TestNValue ( "filebfi", teststring[i], FNV32size,
(uint8_t *)&eUint32,
(uint8_t *)&FNV32svalues[i] );
/* now try testing file hash byte */
TestFILEHash ( FNV32file, FNV32svalues, FNV32size )
} // end for i
ValueTestReport ();
} /* end Test32 */
#ifdef FNV_64bitIntegers
//****************************************************************
// Code for testing FNV64 using 64-bit integers
//****************************************************************
void Test64 ( void ) { /* with 64-bit integers */
long int iLen;
uint64_t FNV64basisT = FNV64basis;
uint64_t FNV64svalues[NTstrings] = {
0xcbf29ce484222325, 0xaf63dc4c8601ec8c, 0x85944171f73967e8,
0xbd51ea7094ee6fa1 };
uint64_t FNV64bvalues[NTstrings] = {
0xaf63bd4c8601b7df, 0x089be207b544f1e4, 0x34531ca7168b8f38,
0xa0a0fe4d1127ae93 };
int i, err;
funcName = "FNV-64";
selected = FNV64selected;
/* test error checks */
Terr = 0;
TestInit (FNV64init, e64Context, FNV64context)
TestInitBasis (FNV64initBasis, e64Context, FNV64context)
CommonTest();
TestINT(FNV64INTstring,FNV64INTstringBasis,FNV64INTblock,
FNV64INTblockBasis,FNV64INTinitBasis,
eUint64,uint64_t,FNV64context)
e64Context.Computed = FNVclobber+FNV64state;
TestBlockin (FNV64blockin, e64Context, FNV64context)
TestStringin (FNV64stringin, e64Context, FNV64context)
TestFilein (FNV64filein, e64Context, FNV64context)
TestResult (FNV64result, e64Context, FNV64context)
TestINTrf(FNV64INTresult,FNV64INTfile,FNV64INTfileBasis,
e64Context,FNV64context,eUint64,uint64_t)
ErrTestReport ();
/* test actual results int */
Terr = 0;
err = TestR ( "fnv0s", fnvSuccess,
FNV64stringBasis ( BasisString, hash, ZeroBasis ) );
if ( err == fnvSuccess ) {
hash[0] ^= '\\';
TestNValue ( "fnv0sv64", BasisString, FNV64size,
hash, (uint8_t *)&FNV64svalues[0]);
}
BasisINTZero (FNV64INTstringBasis,FNV64size,FNV64svalues, \
eUint64,uint64_t)
for ( i = 0; i < NTstrings; ++i ) {
/* test actual results int */
err = TestR ( "stringai", fnvSuccess,
FNV64INTstring ( teststring[i], &eUint64 ) );
if ( err == fnvSuccess )
TestNValue ( "stringbi", teststring[i], FNV64size,
(uint8_t *)&eUint64,
(uint8_t *)&FNV64svalues[i] );
err = TestR ( "blockai", fnvSuccess,
FNV64INTblock ( (uint8_t *)teststring[i],
(unsigned long)(strlen(teststring[i])+1),
&eUint64 ) );
if ( err == fnvSuccess )
TestNValue ( "blockbi", teststring[i], FNV64size,
(uint8_t *)&eUint64,
(uint8_t *)&FNV64bvalues[i] );
/* test actual results byte */
TestSTRBLKHash ( FNV64string, FNV64block, FNV64svalues,
FNV64bvalues, FNV64size )
/* now try testing the incremental stuff */
IncrHash (FNV64init, e64Context, FNV64blockin, FNV64result,
FNV64initBasis, FNV64stringin, FNV64size, FNV64svalues)
/* now try testing the incremental stuff int */
err = TestR ( "initai", fnvSuccess,
FNV64init (&e64Context) );
if ( err ) break;
iLen = strlen ( teststring[i] );
err = TestR ( "blockinai", fnvSuccess,
FNV64blockin ( &e64Context,
(uint8_t *)teststring[i],
iLen/2 ) );
if ( err ) break;
err = TestR ( "stringinai", fnvSuccess,
FNV64stringin ( &e64Context,
teststring[i] + iLen/2 ) );
if ( err ) break;
err = TestR ( "resultai", fnvSuccess,
FNV64INTresult ( &e64Context, &eUint64 ) );
if ( err ) break;
TestNValue ( "incrementalai", teststring[i], FNV64size,
(uint8_t *)&eUint64,
(uint8_t *)&FNV64svalues[i] );
/* now try testing the incremental stuff byte basis */
err = TestR ( "initab", fnvSuccess,
FNV64initBasis (&e64Context,
(uint8_t *)&FNV64basisT) );
if ( err ) break;
iLen = strlen ( teststring[i] );
err = TestR ( "blockinab", fnvSuccess,
FNV64blockin ( &e64Context,
(uint8_t *)teststring[i],
iLen/2 ) );
if ( err ) break;
err = TestR ( "stringinab", fnvSuccess,
FNV64stringin ( &e64Context,
teststring[i] + iLen/2 ) );
if ( err ) break;
err = TestR ( "resultab", fnvSuccess,
FNV64result ( &e64Context, hash ) );
if ( err ) break;
TestNValue ( "incrementala", teststring[i], FNV64size,
hash, (uint8_t *)&FNV64svalues[i] );
/* now try testing file int */
err = TestR ( "fileafi", fnvSuccess,
FNV64INTfile ( WriteTemp(teststring[i], iLen),
&eUint64 ) );
if ( err ) break;
TestNValue ( "filebfi", teststring[i], FNV64size,
(uint8_t *)&eUint64,
(uint8_t *)&FNV64svalues[i] );
/* now try testing file hash */
TestFILEHash(FNV64file,FNV64svalues,FNV64size)
}
ValueTestReport ();
} /* end Test64 */
#else
//****************************************************************
// Code for testing FNV64 without 64-bit integers
//****************************************************************
void Test64 ( void ) { /* without 64-bit integers */
int i, err;
long int iLen;
uint8_t FNV64svalues[NTstrings][FNV64size] = {
{ 0xcb, 0xf2, 0x9c, 0xe4, 0x84, 0x22, 0x23, 0x25 },
{ 0xaf, 0x63, 0xdc, 0x4c, 0x86, 0x01, 0xec, 0x8c },
{ 0x85, 0x94, 0x41, 0x71, 0xf7, 0x39, 0x67, 0xe8 },
{ 0xbd, 0x51, 0xea, 0x70, 0x94, 0xee, 0x6f, 0xa1 } };
uint8_t FNV64bvalues[NTstrings][FNV64size] = {
{ 0xaf, 0x63, 0xbd, 0x4c, 0x86, 0x01, 0xb7, 0xdf },
{ 0x08, 0x9b, 0xe2, 0x07, 0xb5, 0x44, 0xf1, 0xe4 },
{ 0x34, 0x53, 0x1c, 0xa7, 0x16, 0x8b, 0x8f, 0x38 },
{ 0xa0, 0xa0, 0xfe, 0x4d, 0x11, 0x27, 0xae, 0x93 } };
funcName = "FNV-64";
selected = FNV64selected;
/* test error checks */
Terr = 0;
TestR ( "init1", fnvSuccess, FNV64init (&e64Context) );
CommonTest();
TestInit (FNV64init, e64Context, FNV64context)
TestInitBasis (FNV64initBasis, e64Context, FNV64context)
e64Context.Computed = FNVclobber+FNV64state;
TestBlockin (FNV64blockin, e64Context, FNV64context)
TestStringin (FNV64stringin, e64Context, FNV64context)
TestFilein (FNV64filein, e64Context, FNV64context)
TestResult (FNV64result, e64Context, FNV64context)
ErrTestReport ();
/* test actual results */
Terr = 0;
BasisZero(FNV64stringBasis,FNV64size,FNV64svalues)
for ( i = 0; i < NTstrings; ++i ) {
TestSTRBLKHash ( FNV64string, FNV64block,
FNV64svalues, FNV64bvalues, FNV64size )
/* try testing the incremental stuff */
IncrHash(FNV64init,e64Context,FNV64blockin,FNV64result,
FNV64initBasis,FNV64stringin,FNV64size,FNV64svalues)
/* now try testing file hash */
TestFILEHash(FNV64file,FNV64svalues,FNV64size)
}
ValueTestReport ();
} /* end Test64 */
#endif /* FNV_64bitIntegers */
//****************************************************************
// Code for testing FNV128
//****************************************************************
void Test128 ( void ) {
int i, err;
long int iLen;
uint8_t FNV128svalues[NTstrings][FNV128size] = {
{ 0x6c, 0x62, 0x27, 0x2e, 0x07, 0xbb, 0x01, 0x42,
0x62, 0xb8, 0x21, 0x75, 0x62, 0x95, 0xc5, 0x8d },
{ 0xd2, 0x28, 0xcb, 0x69, 0x6f, 0x1a, 0x8c, 0xaf,
0x78, 0x91, 0x2b, 0x70, 0x4e, 0x4a, 0x89, 0x64 },
{ 0x34, 0x3e, 0x16, 0x62, 0x79, 0x3c, 0x64, 0xbf,
0x6f, 0x0d, 0x35, 0x97, 0xba, 0x44, 0x6f, 0x18 },
{ 0x74, 0x20, 0x2c, 0x60, 0x0b, 0x05, 0x1c, 0x16,
0x5b, 0x1a, 0xca, 0xfe, 0xd1, 0x0d, 0x14, 0x19 } };
uint8_t FNV128bvalues[NTstrings][FNV128size] = {
{ 0xd2, 0x28, 0xcb, 0x69, 0x10, 0x1a, 0x8c, 0xaf,
0x78, 0x91, 0x2b, 0x70, 0x4e, 0x4a, 0x14, 0x7f },
{ 0x08, 0x80, 0x95, 0x45, 0x19, 0xab, 0x1b, 0xe9,
0x5a, 0xa0, 0x73, 0x30, 0x55, 0xb7, 0x0e, 0x0c },
{ 0xe0, 0x1f, 0xcf, 0x9a, 0x45, 0x4f, 0xf7, 0x8d,
0xa5, 0x40, 0xf1, 0xb2, 0x32, 0x34, 0xb2, 0x88 },
{ 0xe2, 0x67, 0xa7, 0x41, 0xa8, 0x49, 0x8f, 0x82,
0x19, 0xf7, 0xc7, 0x8b, 0x3b, 0x17, 0xba, 0xc3 } };
funcName = "FNV-128";
selected = FNV128selected;
/* test error checks */
Terr = 0;
TestInit (FNV128init, e128Context, FNV128context)
TestInitBasis (FNV128initBasis, e128Context, FNV128context)
CommonTest();
e128Context.Computed = FNVclobber+FNV128state;
TestBlockin (FNV128blockin, e128Context, FNV128context)
TestStringin (FNV128stringin, e128Context, FNV128context)
TestFilein (FNV128filein, e128Context, FNV128context)
TestResult (FNV128result, e128Context, FNV128context)
ErrTestReport ();
/* test actual results */
Terr = 0;
BasisZero(FNV128stringBasis,FNV128size,FNV128svalues)
for ( i = 0; i < NTstrings; ++i ) {
TestSTRBLKHash ( FNV128string, FNV128block,
FNV128svalues, FNV128bvalues, FNV128size )
/* try testing the incremental stuff */
IncrHash(FNV128init,e128Context,FNV128blockin,FNV128result,
FNV128initBasis,FNV128stringin,FNV128size,FNV128svalues)
/* now try testing file hash */
TestFILEHash(FNV128file,FNV128svalues,FNV128size)
}
ValueTestReport ();
} /* end Test128 */
//****************************************************************
// Code for testing FNV256
//****************************************************************
void Test256 ( void ) {
int i, err;
long int iLen;
uint8_t FNV256svalues[NTstrings][FNV256size] = {
{ 0xdd, 0x26, 0x8d, 0xbc, 0xaa, 0xc5, 0x50, 0x36,
0x2d, 0x98, 0xc3, 0x84, 0xc4, 0xe5, 0x76, 0xcc,
0xc8, 0xb1, 0x53, 0x68, 0x47, 0xb6, 0xbb, 0xb3,
0x10, 0x23, 0xb4, 0xc8, 0xca, 0xee, 0x05, 0x35 },
{ 0x63, 0x32, 0x3f, 0xb0, 0xf3, 0x53, 0x03, 0xec,
0x28, 0xdc, 0x75, 0x1d, 0x0a, 0x33, 0xbd, 0xfa,
0x4d, 0xe6, 0xa9, 0x9b, 0x72, 0x66, 0x49, 0x4f,
0x61, 0x83, 0xb2, 0x71, 0x68, 0x11, 0x63, 0x7c },
{ 0xb0, 0x55, 0xea, 0x2f, 0x30, 0x6c, 0xad, 0xad,
0x4f, 0x0f, 0x81, 0xc0, 0x2d, 0x38, 0x89, 0xdc,
0x32, 0x45, 0x3d, 0xad, 0x5a, 0xe3, 0x5b, 0x75,
0x3b, 0xa1, 0xa9, 0x10, 0x84, 0xaf, 0x34, 0x28 },
{ 0x0c, 0x5a, 0x44, 0x40, 0x2c, 0x65, 0x38, 0xcf,
0x98, 0xef, 0x20, 0xc4, 0x03, 0xa8, 0x0f, 0x65,
0x9b, 0x80, 0xc9, 0xa5, 0xb0, 0x1a, 0x6a, 0x87,
0x34, 0x2e, 0x26, 0x72, 0x64, 0x45, 0x67, 0xb1 } };
uint8_t FNV256bvalues[NTstrings][FNV256size] = {
{ 0x63, 0x32, 0x3f, 0xb0, 0xf3, 0x53, 0x03, 0xec,
0x28, 0xdc, 0x56, 0x1d, 0x0a, 0x33, 0xbd, 0xfa,
0x4d, 0xe6, 0xa9, 0x9b, 0x72, 0x66, 0x49, 0x4f,
0x61, 0x83, 0xb2, 0x71, 0x68, 0x11, 0x38, 0x7f },
{ 0xf4, 0xf7, 0xa1, 0xc2, 0xef, 0xd0, 0xe1, 0xe4,
0xbb, 0x19, 0xe3, 0x45, 0x25, 0xc0, 0x72, 0x1a,
0x06, 0xdd, 0x32, 0x8f, 0xa3, 0xd7, 0xa9, 0x14,
0x39, 0xa0, 0x73, 0x43, 0x50, 0x1c, 0xf4, 0xf4 },
{ 0x6a, 0x7f, 0x34, 0xab, 0xc8, 0x5d, 0xe7, 0xd9,
0x51, 0xb5, 0x15, 0x7e, 0xb5, 0x67, 0x2c, 0x59,
0xb6, 0x04, 0x87, 0x65, 0x09, 0x47, 0xd3, 0x91,
0xb1, 0x2d, 0x71, 0xe7, 0xfe, 0xf5, 0x53, 0x78 },
{ 0x3b, 0x97, 0x2c, 0x31, 0xbe, 0x84, 0x3a, 0x45,
0x59, 0x02, 0x20, 0xd1, 0x12, 0x0d, 0x59, 0xe6,
0xa3, 0x97, 0xa0, 0xc3, 0x34, 0xa1, 0xb9, 0x7d,
0x5b, 0xff, 0x50, 0xa1, 0x0c, 0x3e, 0xca, 0x73 } };
funcName = "FNV-256";
selected = FNV256selected;
/* test error checks */
Terr = 0;
TestInit (FNV256init, e256Context, FNV256context)
TestInitBasis (FNV256initBasis, e256Context, FNV256context)
CommonTest();
e256Context.Computed = FNVclobber+FNV256state;
TestBlockin (FNV256blockin, e256Context, FNV256context)
TestStringin (FNV256stringin, e256Context, FNV256context)
TestFilein (FNV256filein, e256Context, FNV256context)
TestResult (FNV256result, e256Context, FNV256context)
ErrTestReport ();
/* test actual results */
Terr = 0;
BasisZero(FNV256stringBasis,FNV256size,FNV256svalues)
for ( i = 0; i < NTstrings; ++i ) {
TestSTRBLKHash ( FNV256string, FNV256block,
FNV256svalues, FNV256bvalues, FNV256size )
/* try testing the incremental stuff */
IncrHash(FNV256init,e256Context,FNV256blockin,FNV256result,
FNV256initBasis,FNV256stringin,FNV256size,FNV256svalues)
/* now try testing file hash */
TestFILEHash(FNV256file,FNV256svalues,FNV256size)
}
ValueTestReport ();
} /* end Test256 */
//****************************************************************
// Code for testing FNV512
//****************************************************************
void Test512 ( void ) {
int i, err;
long int iLen;
uint8_t FNV512svalues[NTstrings][FNV512size] = {
{ 0xb8, 0x6d, 0xb0, 0xb1, 0x17, 0x1f, 0x44, 0x16,
0xdc, 0xa1, 0xe5, 0x0f, 0x30, 0x99, 0x90, 0xac,
0xac, 0x87, 0xd0, 0x59, 0xc9, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x21,
0xe9, 0x48, 0xf6, 0x8a, 0x34, 0xc1, 0x92, 0xf6,
0x2e, 0xa7, 0x9b, 0xc9, 0x42, 0xdb, 0xe7, 0xce,
0x18, 0x20, 0x36, 0x41, 0x5f, 0x56, 0xe3, 0x4b,
0xac, 0x98, 0x2a, 0xac, 0x4a, 0xfe, 0x9f, 0xd9 },
{ 0xe4, 0x3a, 0x99, 0x2d, 0xc8, 0xfc, 0x5a, 0xd7,
0xde, 0x49, 0x3e, 0x3d, 0x69, 0x6d, 0x6f, 0x85,
0xd6, 0x43, 0x26, 0xec, 0x07, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x98, 0x6f,
0x90, 0xc2, 0x53, 0x2c, 0xaf, 0x5b, 0xe7, 0xd8,
0x82, 0x91, 0xba, 0xa8, 0x94, 0xa3, 0x95, 0x22,
0x53, 0x28, 0xb1, 0x96, 0xbd, 0x6a, 0x8a, 0x64,
0x3f, 0xe1, 0x2c, 0xd8, 0x7b, 0x27, 0xff, 0x88 },
{ 0xb0, 0xec, 0x73, 0x8d, 0x9c, 0x6f, 0xd9, 0x69,
0xd0, 0x5f, 0x0b, 0x35, 0xf6, 0xc0, 0xed, 0x53,
0xad, 0xca, 0xcc, 0xcd, 0x8e, 0x00, 0x00, 0x00,
0x4b, 0xf9, 0x9f, 0x58, 0xee, 0x41, 0x96, 0xaf,
0xb9, 0x70, 0x0e, 0x20, 0x11, 0x08, 0x30, 0xfe,
0xa5, 0x39, 0x6b, 0x76, 0x28, 0x0e, 0x47, 0xfd,
0x02, 0x2b, 0x6e, 0x81, 0x33, 0x1c, 0xa1, 0xa9,
0xce, 0xd7, 0x29, 0xc3, 0x64, 0xbe, 0x77, 0x88 },
{ 0x4f, 0xdf, 0x00, 0xec, 0xb9, 0xbc, 0x04, 0xdd,
0x19, 0x38, 0x61, 0x8f, 0xe5, 0xc4, 0xfb, 0xb8,
0x80, 0xa8, 0x2b, 0x15, 0xf5, 0xb6, 0xbd, 0x72,
0x1e, 0xc2, 0xea, 0xfe, 0x03, 0xc4, 0x62, 0x48,
0xf7, 0xa6, 0xc2, 0x47, 0x89, 0x92, 0x80, 0xd6,
0xd2, 0xf4, 0x2f, 0xf6, 0xb4, 0x7b, 0xf2, 0x20,
0x79, 0xdf, 0xd4, 0xbf, 0xe8, 0x7b, 0xf0, 0xbb,
0x4e, 0x71, 0xea, 0xcb, 0x1e, 0x28, 0x77, 0x35 } };
uint8_t FNV512bvalues[NTstrings][FNV512size] = {
{ 0xe4, 0x3a, 0x99, 0x2d, 0xc8, 0xfc, 0x5a, 0xd7,
0xde, 0x49, 0x3e, 0x3d, 0x69, 0x6d, 0x6f, 0x85,
0xd6, 0x43, 0x26, 0xec, 0x28, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x98, 0x6f,
0x90, 0xc2, 0x53, 0x2c, 0xaf, 0x5b, 0xe7, 0xd8,
0x82, 0x91, 0xba, 0xa8, 0x94, 0xa3, 0x95, 0x22,
0x53, 0x28, 0xb1, 0x96, 0xbd, 0x6a, 0x8a, 0x64,
0x3f, 0xe1, 0x2c, 0xd8, 0x7b, 0x28, 0x2b, 0xbf },
{ 0x73, 0x17, 0xdf, 0xed, 0x6c, 0x70, 0xdf, 0xec,
0x6a, 0xdf, 0xce, 0xd2, 0xa5, 0xe0, 0x4d, 0x7e,
0xec, 0x74, 0x4e, 0x3c, 0xe9, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x17, 0x93, 0x3d, 0x7a,
0xf4, 0x5d, 0x70, 0xde, 0xf4, 0x23, 0xa3, 0x16,
0xf1, 0x41, 0x17, 0xdf, 0x27, 0x2c, 0xd0, 0xfd,
0x6b, 0x85, 0xf0, 0xf7, 0xc9, 0xbf, 0x6c, 0x51,
0x96, 0xb3, 0x16, 0x0d, 0x02, 0x97, 0x5f, 0x38 },
{ 0x82, 0xf6, 0xe1, 0x04, 0x96, 0xde, 0x78, 0x34,
0xb0, 0x8b, 0x21, 0xef, 0x46, 0x4c, 0xd2, 0x47,
0x9e, 0x1d, 0x25, 0xe0, 0xca, 0x00, 0x00, 0x65,
0xcb, 0x74, 0x80, 0x27, 0x39, 0xe0, 0xe5, 0x71,
0x75, 0x22, 0xec, 0xf6, 0xd1, 0xf9, 0xa5, 0x2f,
0x5f, 0xee, 0xfb, 0x4f, 0xab, 0x22, 0x73, 0xfd,
0xe8, 0x31, 0x0f, 0x1b, 0x7b, 0x5c, 0x9a, 0x84,
0x22, 0x48, 0xf4, 0xcb, 0xfb, 0x32, 0x27, 0x38 },
{ 0xfa, 0x7e, 0xb9, 0x1e, 0xfb, 0x64, 0x64, 0x11,
0x8a, 0x73, 0x33, 0xbd, 0x96, 0x3b, 0xb6, 0x1f,
0x2c, 0x6f, 0xe2, 0xe3, 0x6c, 0xd7, 0xd3, 0xe7,
0x37, 0x28, 0xda, 0x57, 0x0c, 0x1f, 0xaf, 0xc3,
0xd0, 0x6e, 0x4d, 0xd9, 0x53, 0x4a, 0x9f, 0xd4,
0xa5, 0x2c, 0x43, 0x8b, 0xd2, 0x11, 0x69, 0x83,
0x4a, 0xe6, 0x0d, 0x20, 0x7e, 0x0f, 0x8a, 0xf6,
0x1a, 0xa1, 0x96, 0x25, 0x68, 0x37, 0xb8, 0x03 } };
funcName = "FNV-512";
selected = FNV512selected;
/* test error checks */
Terr = 0;
TestInit (FNV512init, e512Context, FNV512context)
TestInitBasis (FNV512initBasis, e512Context, FNV512context)
CommonTest();
e512Context.Computed = FNVclobber+FNV512state;
TestBlockin (FNV512blockin, e512Context, FNV512context)
TestStringin (FNV512stringin, e512Context, FNV512context)
TestFilein (FNV512filein, e512Context, FNV512context)
TestResult (FNV512result, e512Context, FNV512context)
ErrTestReport ();
/* test actual results */
Terr = 0;
BasisZero(FNV512stringBasis,FNV512size,FNV512svalues)
for ( i = 0; i < NTstrings; ++i ) {
TestSTRBLKHash ( FNV512string, FNV512block,
FNV512svalues, FNV512bvalues, FNV512size )
/* try testing the incremental stuff */
IncrHash(FNV512init,e512Context,FNV512blockin,FNV512result,
FNV512initBasis,FNV512stringin,FNV512size,FNV512svalues)
/* now try testing file hash */
TestFILEHash(FNV512file,FNV512svalues,FNV512size)
}
ValueTestReport ();
} /* end Test512 */
//****************************************************************
// Code for testing FNV1024
//****************************************************************
void Test1024 ( void ) {
uint8_t FNV1024svalues[NTstrings][FNV1024size] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x5f, 0x7a, 0x76, 0x75, 0x8e, 0xcc, 0x4d,
0x32, 0xe5, 0x6d, 0x5a, 0x59, 0x10, 0x28, 0xb7,
0x4b, 0x29, 0xfc, 0x42, 0x23, 0xfd, 0xad, 0xa1,
0x6c, 0x3b, 0xf3, 0x4e, 0xda, 0x36, 0x74, 0xda,
0x9a, 0x21, 0xd9, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc6, 0xd7,
0xeb, 0x6e, 0x73, 0x80, 0x27, 0x34, 0x51, 0x0a,
0x55, 0x5f, 0x25, 0x6c, 0xc0, 0x05, 0xae, 0x55,
0x6b, 0xde, 0x8c, 0xc9, 0xc6, 0xa9, 0x3b, 0x21,
0xaf, 0xf4, 0xb1, 0x6c, 0x71, 0xee, 0x90, 0xb3 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x98, 0xd7, 0xc1, 0x9f, 0xbc, 0xe6, 0x53, 0xdf,
0x22, 0x1b, 0x9f, 0x71, 0x7d, 0x34, 0x90, 0xff,
0x95, 0xca, 0x87, 0xfd, 0xae, 0xf3, 0x0d, 0x1b,
0x82, 0x33, 0x72, 0xf8, 0x5b, 0x24, 0xa3, 0x72,
0xf5, 0x0e, 0x57, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x07, 0x68, 0x5c, 0xd8,
0x1a, 0x49, 0x1d, 0xbc, 0xcc, 0x21, 0xad, 0x06,
0x64, 0x8d, 0x09, 0xa5, 0xc8, 0xcf, 0x5a, 0x78,
0x48, 0x20, 0x54, 0xe9, 0x14, 0x70, 0xb3, 0x3d,
0xde, 0x77, 0x25, 0x2c, 0xae, 0xf6, 0x95, 0xaa },
{ 0x00, 0x00, 0x06, 0x31, 0x17, 0x5f, 0xa7, 0xae,
0x64, 0x3a, 0xd0, 0x87, 0x23, 0xd3, 0x12, 0xc9,
0xfd, 0x02, 0x4a, 0xdb, 0x91, 0xf7, 0x7f, 0x6b,
0x19, 0x58, 0x71, 0x97, 0xa2, 0x2b, 0xcd, 0xf2,
0x37, 0x27, 0x16, 0x6c, 0x45, 0x72, 0xd0, 0xb9,
0x85, 0xd5, 0xae, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42,
0x70, 0xd1, 0x1e, 0xf4, 0x18, 0xef, 0x08, 0xb8,
0xa4, 0x9e, 0x1e, 0x82, 0x5e, 0x54, 0x7e, 0xb3,
0x99, 0x37, 0xf8, 0x19, 0x22, 0x2f, 0x3b, 0x7f,
0xc9, 0x2a, 0x0e, 0x47, 0x07, 0x90, 0x08, 0x88,
0x84, 0x7a, 0x55, 0x4b, 0xac, 0xec, 0x98, 0xb0 },
{ 0xf6, 0xf7, 0x47, 0xaf, 0x25, 0xa9, 0xde, 0x26,
0xe8, 0xa4, 0x93, 0x43, 0x1e, 0x31, 0xb4, 0xa1,
0xed, 0x2a, 0x92, 0x30, 0x4a, 0xf6, 0xca, 0x97,
0x6b, 0xc1, 0xd9, 0x6f, 0xfc, 0xad, 0x35, 0x24,
0x4e, 0x8d, 0x38, 0x5d, 0x55, 0xf4, 0x2f, 0xdc,
0xc8, 0xf2, 0x99, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xf7, 0xca, 0x87, 0xce,
0x43, 0x22, 0x7b, 0x98, 0xc1, 0x44, 0x60, 0x7e,
0x67, 0xcc, 0x50, 0xaf, 0x99, 0xbc, 0xc5, 0xd1,
0x51, 0x4b, 0xb0, 0xd9, 0x23, 0xee, 0xde, 0xdd,
0x69, 0xe8, 0xe7, 0x47, 0x02, 0x05, 0x08, 0x3a,
0x0c, 0x02, 0x27, 0xd0, 0xcc, 0x69, 0xde, 0x23 } };
uint8_t FNV1024bvalues[NTstrings][FNV1024size] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x98, 0xd7, 0xc1, 0x9f, 0xbc, 0xe6, 0x53, 0xdf,
0x22, 0x1b, 0x9f, 0x71, 0x7d, 0x34, 0x90, 0xff,
0x95, 0xca, 0x87, 0xfd, 0xae, 0xf3, 0x0d, 0x1b,
0x82, 0x33, 0x72, 0xf8, 0x5b, 0x24, 0xa3, 0x72,
0xf5, 0x0e, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x07, 0x68, 0x5c, 0xd8,
0x1a, 0x49, 0x1d, 0xbc, 0xcc, 0x21, 0xad, 0x06,
0x64, 0x8d, 0x09, 0xa5, 0xc8, 0xcf, 0x5a, 0x78,
0x48, 0x20, 0x54, 0xe9, 0x14, 0x70, 0xb3, 0x3d,
0xde, 0x77, 0x25, 0x2c, 0xae, 0xf6, 0x65, 0x97 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4,
0x6e, 0xf4, 0x1c, 0xd2, 0x3a, 0x4d, 0xcd, 0xd4,
0x06, 0x83, 0x49, 0x63, 0xb7, 0x8e, 0x82, 0x24,
0x1a, 0x6f, 0x5c, 0xb0, 0x6f, 0x40, 0x3c, 0xbd,
0x5a, 0x7c, 0x89, 0x03, 0xce, 0xf6, 0xa5, 0xf4,
0xfd, 0xd2, 0x95, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x0b, 0x7c, 0xd7, 0xfb, 0x20,
0xc3, 0x63, 0x1d, 0xc8, 0x90, 0x39, 0x52, 0xe9,
0xee, 0xb7, 0xf6, 0x18, 0x69, 0x8f, 0x4c, 0x87,
0xda, 0x23, 0xad, 0x74, 0xb2, 0xc5, 0xf6, 0xf1,
0xfe, 0xc4, 0xa6, 0x4b, 0x54, 0x66, 0x18, 0xa2 },
{ 0x00, 0x09, 0xdc, 0x92, 0x10, 0x75, 0xfd, 0x8a,
0x5e, 0x3e, 0x1a, 0x37, 0x2c, 0x72, 0xa5, 0x9b,
0xb1, 0x0c, 0xca, 0x1a, 0x94, 0xc8, 0xb2, 0x38,
0x7d, 0x63, 0xa7, 0xef, 0xa7, 0xfc, 0xa7, 0xa7,
0x17, 0xa6, 0x4e, 0x6c, 0x2d, 0x62, 0xfb, 0x61,
0x78, 0xf7, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x08,
0xf4, 0x4d, 0x00, 0x8a, 0xaa, 0xb0, 0x86, 0x57,
0x49, 0x35, 0x50, 0x2c, 0x49, 0x08, 0x7c, 0x84,
0x9b, 0xcb, 0xbe, 0xfa, 0x03, 0x3f, 0x45, 0x2a,
0xf6, 0x38, 0x24, 0x26, 0xba, 0x5d, 0x3b, 0xb5,
0x71, 0xb6, 0x46, 0x5b, 0x2a, 0xe8, 0xc8, 0xf0 },
{ 0xc8, 0x01, 0xf8, 0xe0, 0x8a, 0xe9, 0x1b, 0x18,
0x0b, 0x98, 0xdd, 0x7d, 0x9f, 0x65, 0xce, 0xb6,
0x87, 0xca, 0x86, 0x35, 0x8c, 0x69, 0x05, 0xf6,
0x0a, 0x7d, 0x10, 0x14, 0xc1, 0x82, 0xb0, 0x4f,
0xd6, 0x08, 0xa2, 0xca, 0x4d, 0xd6, 0x0a, 0x30,
0x0a, 0x15, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x80, 0x45, 0x14, 0x9a, 0xde,
0x1c, 0x79, 0xab, 0xe3, 0xb7, 0x09, 0xa4, 0x06,
0xf7, 0xd9, 0x20, 0x51, 0x69, 0xbe, 0xc5, 0x9b,
0x12, 0x61, 0x40, 0xbc, 0xb9, 0x6f, 0x9d, 0x5d,
0x3e, 0x2e, 0xa9, 0x1e, 0x21, 0xcd, 0xc2, 0x04,
0x9f, 0x57, 0xbe, 0xcd, 0x00, 0x2d, 0x7c, 0x47 } };
long int iLen;
int i, err;
funcName = "FNV-1024";
selected = FNV1024selected;
/* test error checks */
Terr = 0;
TestInit (FNV1024init, e1024Context, FNV1024context)
TestInitBasis (FNV1024initBasis, e1024Context, FNV1024context)
CommonTest();
e1024Context.Computed = FNVclobber+FNV1024state;
TestBlockin (FNV1024blockin, e1024Context, FNV1024context)
TestStringin (FNV1024stringin, e1024Context, FNV1024context)
TestFilein (FNV1024filein, e1024Context, FNV1024context)
TestResult (FNV1024result, e1024Context, FNV1024context)
ErrTestReport ();
/* test actual results */
Terr = 0;
BasisZero(FNV1024stringBasis,FNV1024size,FNV1024svalues)
for ( i = 0; i < NTstrings; ++i ) {
TestSTRBLKHash ( FNV1024string, FNV1024block,
FNV1024svalues, FNV1024bvalues,
FNV1024size )
/* try testing the incremental stuff */
IncrHash(FNV1024init,e1024Context,FNV1024blockin,
FNV1024result, FNV1024initBasis,
FNV1024stringin,FNV1024size,FNV1024svalues)
/* now try testing file hash */
TestFILEHash(FNV1024file,FNV1024svalues,FNV1024size)
}
ValueTestReport ();
} /* end Test1024 */
<CODE ENDS>
8.4. Makefile
Below is a simple makefile to produce and run the test program or to
provide a library with all the FNV functions supplied in it.
WARNING: When actually using the following as a makefile, the five-
character sequence "<TAB>" must be changed to a tab (0x09) character!
<CODE BEGINS> file "makefile"
# Makefile for fnv
# If you extract this file from RFC 9923, the five-character sequence
# <TAB> below must be replaced with a tab (0x09) character.
explanation:
<TAB>@echo Choose one of the following make targets:
<TAB>@echo make FNVhash -- test program
<TAB>@echo make libfnv.a -- library you can use
<TAB>@echo make clean -- removes all of the built targets
SRC=FNV32.c FNV64.c FNV128.c FNV256.c FNV512.c FNV1024.c
HDR=FNV32.h FNV64.h FNV128.h FNV256.h FNV512.h FNV1024.h \
<TAB>FNVconfig.h FNVErrorCodes.h fnv-private.h
OBJ=$(SRC:.c=.o)
CFLAGS=-Wall
AR=ar
ARFLAGS= rcs
FNVhash: libfnv.a main.c
<TAB>$(CC) $(CFLAGS) -o FNVhash main.c libfnv.a
libfnv.a: $(SRC) $(HDR)
<TAB>rm -f libfnv.a *.o
<TAB>$(CC) $(CFLAGS) -c $(SRC)
<TAB>$(AR) $(ARFLAGS) libfnv.a $(OBJ)
clean:
<TAB>rm -rf libfnv.a FNVhash *.o
<CODE ENDS>