LAMMP 4.2.0
Lamina High-Precision Arithmetic Library
载入中...
搜索中...
未找到
类型定义 | 函数
secret.h 文件参考
#include "lmmp.h"
+ secret.h 的引用(Include)关系图:
+ 此图展示该文件直接或间接的被哪些文件引用了:

浏览源代码.

类型定义

typedef uint64_t key128_t[2]
 
typedef uint64_t key256_t[4]
 
typedef uint64_t key64_t[1]
 
typedef const uint64_t srckey128_t[2]
 
typedef const uint64_t srckey256_t[4]
 
typedef const uint64_t srckey64_t[1]
 Copyright (C) 2026 HJimmyK(Jericho Knox)
 

函数

uint64_t lmmp_siphash24_ (mp_srcptr in, mp_size_t inlen, srckey128_t key)
 SipHash-2-4 函数（非标准处理任意字节流的 SipHash-2-4）
 
uint64_t lmmp_xxhash_ (mp_srcptr in, mp_size_t inlen, srckey64_t key)
 xxhash 函数（非标准处理任意字节流的 xxhash）
 

类型定义说明

◆ key128_t

typedef uint64_t key128_t[2]

在文件 secret.h 第 39 行定义.

◆ key256_t

typedef uint64_t key256_t[4]

在文件 secret.h 第 40 行定义.

◆ key64_t

typedef uint64_t key64_t[1]

在文件 secret.h 第 38 行定义.

◆ srckey128_t

typedef const uint64_t srckey128_t[2]

在文件 secret.h 第 35 行定义.

◆ srckey256_t

typedef const uint64_t srckey256_t[4]

在文件 secret.h 第 36 行定义.

◆ srckey64_t

typedef const uint64_t srckey64_t[1]

Copyright (C) 2026 HJimmyK(Jericho Knox)

This file is part of LAMMP.

LAMMP is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License (LGPL) as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This program is distributed WITHOUT ANY WARRANTY.

See https://www.gnu.org/licenses/.

在文件 secret.h 第 34 行定义.

函数说明

◆ lmmp_siphash24_()

uint64_t lmmp_siphash24_ ( mp_srcptr  in,
mp_size_t  inlen,
srckey128_t  key 
)

SipHash-2-4 函数（非标准处理任意字节流的 SipHash-2-4）

参数
in输入数据，可以为 NULL
inlen输入数据长度
key128-bit 秘钥，可以为 NULL
警告
若 key 为 NULL，则使用全零秘钥
返回
64-bit hash 值

在文件 siphash.c 第 23 行定义.

23 {
24#define SIPROUND \
25 do { \
26 v0 += v1; \
27 v1 = rotl64(v1, 13); \
28 v1 ^= v0; \
29 v0 = rotl64(v0, 32); \
30 v2 += v3; \
31 v3 = rotl64(v3, 16); \
32 v3 ^= v2; \
33 v0 += v3; \
34 v3 = rotl64(v3, 21); \
35 v3 ^= v0; \
36 v2 += v1; \
37 v1 = rotl64(v1, 17); \
38 v1 ^= v2; \
39 v2 = rotl64(v2, 32); \
40 } while (0)
41
42 uint64_t k0;
43 uint64_t k1;
44 if (key == NULL) {
45 k0 = 0;
46 k1 = 0;
47 } else {
48 k0 = key[0];
49 k1 = key[1];
50 }
51
52 uint64_t v0 = 0x736f6d6570736575ULL ^ k0;
53 uint64_t v1 = 0x646f72616e646f6dULL ^ k1;
54 uint64_t v2 = 0x6c7967656e657261ULL ^ k0;
55 uint64_t v3 = 0x7465646279746573ULL ^ k1;
56
57 const uint64_t* data = (const uint64_t*)in;
58 const uint64_t* end = data + inlen;
59
60 const uint64_t* limit = data + (inlen & ~3ULL);
61
62 while (data < limit) {
63 uint64_t m0 = data[0];
64 uint64_t m1 = data[1];
65 uint64_t m2 = data[2];
66 uint64_t m3 = data[3];
67 data += 4;
68
69 v3 ^= m0;
70 SIPROUND;
71 SIPROUND;
72 v0 ^= m0;
73
74 v3 ^= m1;
75 SIPROUND;
76 SIPROUND;
77 v0 ^= m1;
78
79 v3 ^= m2;
80 SIPROUND;
81 SIPROUND;
82 v0 ^= m2;
83
84 v3 ^= m3;
85 SIPROUND;
86 SIPROUND;
87 v0 ^= m3;
88 }
89
90 while (data < end) {
91 uint64_t m = *data++;
92 v3 ^= m;
93 SIPROUND;
94 SIPROUND;
95 v0 ^= m;
96 }
97
98 uint64_t b = ((uint64_t)(inlen * LIMB_BYTES)) << 56;
99 v3 ^= b;
100 SIPROUND;
101 SIPROUND;
102 v0 ^= b;
103
104 v2 ^= 0xff;
105 SIPROUND;
106 SIPROUND;
107 SIPROUND;
108 SIPROUND;
109
110 return v0 ^ v1 ^ v2 ^ v3;
111}
LIMB_BYTES
#define LIMB_BYTES
Definition mparam.h:85
v0
#define v0
v1
#define v1
v2
#define v2
n
#define n
SIPROUND
#define SIPROUND

引用了 LIMB_BYTES, n, SIPROUND, v0, v1 , 以及 v2.

◆ lmmp_xxhash_()

uint64_t lmmp_xxhash_ ( mp_srcptr  in,
mp_size_t  inlen,
srckey64_t  key 
)

xxhash 函数（非标准处理任意字节流的 xxhash）

参数
in输入数据，可以为 NULL
inlen输入数据长度
key64-bit 秘钥，可以为 NULL
警告
若 key 为 NULL，则使用全零秘钥
返回
64-bit hash 值

在文件 xxhash.c 第 29 行定义.

29 {
30 uint64_t seed = key == NULL ? 0 : key[0];
31 if (in == NULL || inlen == 0) {
32 seed += PRIME64_5;
33 seed += 0; // len = 0
34 seed ^= seed >> 33;
35 seed *= PRIME64_2;
36 seed ^= seed >> 29;
37 seed *= PRIME64_3;
38 seed ^= seed >> 32;
39 return seed;
40 }
41
42 const uint64_t* p = in;
43 const uint64_t* const end = in + inlen;
44 uint64_t h64;
45
46 if (inlen >= 4) {
47 const uint64_t* const limit = end - 4;
48 uint64_t v1 = seed + PRIME64_1 + PRIME64_2;
49 uint64_t v2 = seed + PRIME64_2;
50 uint64_t v3 = seed + 0;
51 uint64_t v4 = seed - PRIME64_1;
52
53 do {
54 v1 += *p * PRIME64_2;
55 v1 = rotl64(v1, 31);
56 v1 *= PRIME64_1;
57 p++;
58
59 v2 += *p * PRIME64_2;
60 v2 = rotl64(v2, 31);
61 v2 *= PRIME64_1;
62 p++;
63
64 v3 += *p * PRIME64_2;
65 v3 = rotl64(v3, 31);
66 v3 *= PRIME64_1;
67 p++;
68
69 v4 += *p * PRIME64_2;
70 v4 = rotl64(v4, 31);
71 v4 *= PRIME64_1;
72 p++;
73 } while (p <= limit);
74
75 h64 = rotl64(v1, 1) + rotl64(v2, 7) + rotl64(v3, 12) + rotl64(v4, 18);
76
77 v1 *= PRIME64_2;
78 v1 = rotl64(v1, 31);
79 v1 *= PRIME64_1;
80 h64 ^= v1;
81 h64 = h64 * PRIME64_1 + PRIME64_4;
82
83 v2 *= PRIME64_2;
84 v2 = rotl64(v2, 31);
85 v2 *= PRIME64_1;
86 h64 ^= v2;
87 h64 = h64 * PRIME64_1 + PRIME64_4;
88
89 v3 *= PRIME64_2;
90 v3 = rotl64(v3, 31);
91 v3 *= PRIME64_1;
92 h64 ^= v3;
93 h64 = h64 * PRIME64_1 + PRIME64_4;
94
95 v4 *= PRIME64_2;
96 v4 = rotl64(v4, 31);
97 v4 *= PRIME64_1;
98 h64 ^= v4;
99 h64 = h64 * PRIME64_1 + PRIME64_4;
100 } else {
101 h64 = seed + PRIME64_5;
102 }
103
104 h64 += (uint64_t)(inlen * sizeof(mp_limb_t));
105
106 while (p < end) {
107 uint64_t k1 = *p;
108 k1 *= PRIME64_2;
109 k1 = rotl64(k1, 31);
110 k1 *= PRIME64_1;
111 h64 ^= k1;
112 h64 = rotl64(h64, 27) * PRIME64_1 + PRIME64_4;
113 p++;
114 }
115
116 h64 ^= h64 >> 33;
117 h64 *= PRIME64_2;
118 h64 ^= h64 >> 29;
119 h64 *= PRIME64_3;
120 h64 ^= h64 >> 32;
121
122 return h64;
123}
mp_limb_t
uint64_t mp_limb_t
Definition lmmp.h:76
PRIME64_4
#define PRIME64_4
Definition xxhash.c:21
rotl64
static uint64_t rotl64(uint64_t x, int b)
Definition xxhash.c:24
PRIME64_1
#define PRIME64_1
Copyright (C) 2026 HJimmyK(Jericho Knox)
Definition xxhash.c:18
PRIME64_5
#define PRIME64_5
Definition xxhash.c:22
PRIME64_3
#define PRIME64_3
Definition xxhash.c:20
PRIME64_2
#define PRIME64_2
Definition xxhash.c:19

引用了 n, PRIME64_1, PRIME64_2, PRIME64_3, PRIME64_4, PRIME64_5, rotl64(), v1 , 以及 v2.

+ 函数调用图: