[ViewVC] Diff of: cvs/Digest-Hashcash/Hashcash.xs

Comparing Digest-Hashcash/Hashcash.xs (file contents):
Revision 1.1 by root, Sat Sep 6 22:12:00 2003 UTC vs.
Revision 1.7 by root, Tue Jul 21 05:01:01 2015 UTC

…		…
3	#include "XSUB.h"	3	#include "XSUB.h"
4		4
5	#include <time.h>	5	#include <time.h>
6	#include <stdlib.h>	6	#include <stdlib.h>
7	#include <stdint.h>	7	#include <stdint.h>
		8
		9	#include "perlmulticore.h"
8		10
9	/* NIST Secure Hash Algorithm */	11	/* NIST Secure Hash Algorithm */
10	/* heavily modified by Uwe Hollerbach <uh@alumni.caltech edu> */	12	/* heavily modified by Uwe Hollerbach <uh@alumni.caltech edu> */
11	/* from Peter C. Gutmann's implementation as found in */	13	/* from Peter C. Gutmann's implementation as found in */
12	/* Applied Cryptography by Bruce Schneier */	14	/* Applied Cryptography by Bruce Schneier */
…		…
19	* kept me from doing it, so here's the truth: I took this code from the	21	* kept me from doing it, so here's the truth: I took this code from the
20	* SHA1 perl module, since it looked reasonably well-crafted. I modified	22	* SHA1 perl module, since it looked reasonably well-crafted. I modified
21	* it here and there, though.	23	* it here and there, though.
22	*/	24	*/
23		25
		26	/*
		27	* we have lots of micro-optimizations here, this is just for toying
		28	* around...
		29	*/
		30
24	/* don't expect _too_ much from compilers for now. */	31	/* don't expect _too_ much from compilers for now. */
25	#if __GNUC_MAJOR > 2	32	#if __GNUC__ > 2
26	# define restrict __restrict__	33	# define restrict __restrict__
		34	# define inline __inline__
		35	# ifdef __i386
		36	# define GCCX86ASM 1
		37	# endif
27	#elif __STDC_VERSION__ < 199900	38	#elif __STDC_VERSION__ < 199900
28	# define restrict	39	# define restrict
		40	# define inline
29	#endif	41	#endif
		42
		43	#if __GNUC__ < 2
		44	# define __attribute__(x)
		45	#endif
		46
		47	#ifdef __i386
		48	# define a_regparm(n) __attribute__((__regparm__(n)))
		49	#else
		50	# define a_regparm(n)
		51	#endif
		52
		53	#define a_const __attribute__((__const__))
30		54
31	/* Useful defines & typedefs */	55	/* Useful defines & typedefs */
32		56
33	#if defined(U64TYPE) && (defined(USE_64_BIT_INT) \|\| ((BYTEORDER != 0x1234) && (BYTEORDER != 0x4321)))	57	#if defined(U64TYPE) && (defined(USE_64_BIT_INT) \|\| ((BYTEORDER != 0x1234) && (BYTEORDER != 0x4321)))
34	typedef U64TYPE ULONG;	58	typedef U64TYPE ULONG;
35	# if BYTEORDER == 0x1234	59	# if BYTEORDER == 0x1234
36	# undef BYTEORDER	60	# undef BYTEORDER
37	# define BYTEORDER 0x12345678	61	# define BYTEORDER 0x12345678
38	# elif BYTEORDER == 0x4321	62	# elif BYTEORDER == 0x4321
39	# undef BYTEORDER	63	# undef BYTEORDER
40	# define BYTEORDER 0x87654321	64	# define BYTEORDER 0x87654321
41	# endif	65	# endif
42	#else	66	#else
43	typedef uint_fast32_t ULONG; /* 32-or-more-bit quantity */	67	typedef uint_fast32_t ULONG; /* 32-or-more-bit quantity */
		68	#endif
		69
		70	#if GCCX86ASM
		71	# define zprefix(n) ({ int _r; __asm__ ("bsrl %1, %0" : "=r" (_r) : "r" (n)); 31 - _r ; })
		72	#elif __GNUC__ > 2 && __GNUC_MINOR__ > 3
		73	# define zprefix(n) (__extension__ ({ uint32_t n__ = (n); n ? __builtin_clz (n) : 32; }))
		74	#else
		75	static int a_const zprefix (ULONG n)
		76	{
		77	static char zp[256] =
		78	{
		79	8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
		80	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
		81	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		82	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		83	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		84	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		85	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		86	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		87	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		88	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		89	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		90	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		91	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		92	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		93	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		94	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		95	};
		96
		97	return
		98	n > 0xffffff ? zp[n >> 24]
		99	: n > 0xffff ? 8 + zp[n >> 16]
		100	: n > 0xff ? 16 + zp[n >> 8]
		101	: 24 + zp[n];
		102	}
44	#endif	103	#endif
45		104
46	#define SHA_BLOCKSIZE 64	105	#define SHA_BLOCKSIZE 64
47	#define SHA_DIGESTSIZE 20	106	#define SHA_DIGESTSIZE 20
48		107
49	typedef struct {	108	typedef struct {
50	ULONG digest[5]; /* message digest */	109	ULONG digest[5]; /* message digest */
51	ULONG count; /* 32-bit bit count */	110	ULONG count; /* 32-bit bit count */
		111	int local; /* unprocessed amount in data */
52	U8 data[SHA_BLOCKSIZE]; /* SHA data buffer */	112	U8 data[SHA_BLOCKSIZE]; /* SHA data buffer */
53	int local; /* unprocessed amount in data */
54	} SHA_INFO;	113	} SHA_INFO;
55		114
56
57	/* UNRAVEL should be fastest & biggest */
58	/* UNROLL_LOOPS should be just as big, but slightly slower */
59	/* both undefined should be smallest and slowest */
60
61	#define SHA_VERSION 1
62	#define UNRAVEL
63	/* #define UNROLL_LOOPS */
64		115
65	/* SHA f()-functions */	116	/* SHA f()-functions */
66	#define f1(x,y,z) ((x & y) \| (~x & z))	117	#define f1(x,y,z) ((x & y) \| (~x & z))
67	#define f2(x,y,z) (x ^ y ^ z)	118	#define f2(x,y,z) (x ^ y ^ z)
68	#define f3(x,y,z) ((x & y) \| (x & z) \| (y & z))	119	#define f3(x,y,z) ((x & y) \| (x & z) \| (y & z))
…		…
78	#define T32(x) ((x) & 0xffffffffL)	129	#define T32(x) ((x) & 0xffffffffL)
79		130
80	/* 32-bit rotate */	131	/* 32-bit rotate */
81	#define R32(x,n) T32(((x << n) \| (x >> (32 - n))))	132	#define R32(x,n) T32(((x << n) \| (x >> (32 - n))))
82		133
83	/* the generic case, for when the overall rotation is not unraveled */
84	#define FG(n) \
85	T = T32(R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n); \
86	E = D; D = C; C = R32(B,30); B = A; A = T
87
88	/* specific cases, for when the overall rotation is unraveled */	134	/* specific cases, for when the overall rotation is unraveled */
89	#define FA(n) \	135	#define FA(n) \
90	T = T32(R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n); B = R32(B,30)	136	T = T32(R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n); B = R32(B,30)
91		137
92	#define FB(n) \	138	#define FB(n) \
…		…
102	B = T32(R32(C,5) + f##n(D,E,T) + A + *WP++ + CONST##n); D = R32(D,30)	148	B = T32(R32(C,5) + f##n(D,E,T) + A + *WP++ + CONST##n); D = R32(D,30)
103		149
104	#define FT(n) \	150	#define FT(n) \
105	A = T32(R32(B,5) + f##n(C,D,E) + T + *WP++ + CONST##n); C = R32(C,30)	151	A = T32(R32(B,5) + f##n(C,D,E) + T + *WP++ + CONST##n); C = R32(C,30)
106		152
107		153	static void a_regparm(1) sha_transform(SHA_INFO *restrict sha_info)
108	static void sha_transform(restrict SHA_INFO *sha_info)
109	{	154	{
110	int i;	155	int i;
111	U8 *dp;	156	U8 *restrict dp;
112	ULONG T, A, B, C, D, E, W[80], *WP;	157	ULONG T, A, B, C, D, E, W[80], *restrict WP;
113		158
114	dp = sha_info->data;	159	dp = sha_info->data;
115		160
116	/*
117	the following makes sure that at least one code block below is
118	traversed or an error is reported, without the necessity for nested
119	preprocessor if/else/endif blocks, which are a great pain in the
120	nether regions of the anatomy...
121	*/
122	#undef SWAP_DONE
123
124	#if BYTEORDER == 0x1234	161	#if BYTEORDER == 0x1234
125	#define SWAP_DONE
126	assert(sizeof(ULONG) == 4);	162	assert(sizeof(ULONG) == 4);
		163	# ifdef HAS_NTOHL
		164	for (i = 0; i < 16; ++i) {
		165	T = ((ULONG ) dp);
		166	dp += 4;
		167	W[i] = ntohl (T);
		168	}
		169	# else
127	for (i = 0; i < 16; ++i) {	170	for (i = 0; i < 16; ++i) {
128	T = ((ULONG ) dp);	171	T = ((ULONG ) dp);
129	dp += 4;	172	dp += 4;
130	W[i] = ((T << 24) & 0xff000000) \| ((T << 8) & 0x00ff0000) \|	173	W[i] = ((T << 24) & 0xff000000) \| ((T << 8) & 0x00ff0000) \|
131	((T >> 8) & 0x0000ff00) \| ((T >> 24) & 0x000000ff);	174	((T >> 8) & 0x0000ff00) \| ((T >> 24) & 0x000000ff);
132	}	175	}
133	#endif	176	# endif
134
135	#if BYTEORDER == 0x4321	177	#elif BYTEORDER == 0x4321
136	#define SWAP_DONE
137	assert(sizeof(ULONG) == 4);	178	assert(sizeof(ULONG) == 4);
138	for (i = 0; i < 16; ++i) {	179	for (i = 0; i < 16; ++i) {
139	T = ((ULONG ) dp);	180	T = ((ULONG ) dp);
140	dp += 4;	181	dp += 4;
141	W[i] = T32(T);	182	W[i] = T32(T);
142	}	183	}
143	#endif
144
145	#if BYTEORDER == 0x12345678	184	#elif BYTEORDER == 0x12345678
146	#define SWAP_DONE
147	assert(sizeof(ULONG) == 8);	185	assert(sizeof(ULONG) == 8);
148	for (i = 0; i < 16; i += 2) {	186	for (i = 0; i < 16; i += 2) {
149	T = ((ULONG ) dp);	187	T = ((ULONG ) dp);
150	dp += 8;	188	dp += 8;
151	W[i] = ((T << 24) & 0xff000000) \| ((T << 8) & 0x00ff0000) \|	189	W[i] = ((T << 24) & 0xff000000) \| ((T << 8) & 0x00ff0000) \|
152	((T >> 8) & 0x0000ff00) \| ((T >> 24) & 0x000000ff);	190	((T >> 8) & 0x0000ff00) \| ((T >> 24) & 0x000000ff);
153	T >>= 32;	191	T >>= 32;
154	W[i+1] = ((T << 24) & 0xff000000) \| ((T << 8) & 0x00ff0000) \|	192	W[i+1] = ((T << 24) & 0xff000000) \| ((T << 8) & 0x00ff0000) \|
155	((T >> 8) & 0x0000ff00) \| ((T >> 24) & 0x000000ff);	193	((T >> 8) & 0x0000ff00) \| ((T >> 24) & 0x000000ff);
156	}	194	}
157	#endif
158
159	#if BYTEORDER == 0x87654321	195	#elif BYTEORDER == 0x87654321
160	#define SWAP_DONE
161	assert(sizeof(ULONG) == 8);	196	assert(sizeof(ULONG) == 8);
162	for (i = 0; i < 16; i += 2) {	197	for (i = 0; i < 16; i += 2) {
163	T = ((ULONG ) dp);	198	T = ((ULONG ) dp);
164	dp += 8;	199	dp += 8;
165	W[i] = T32(T >> 32);	200	W[i] = T32(T >> 32);
166	W[i+1] = T32(T);	201	W[i+1] = T32(T);
167	}	202	}
168	#endif	203	#else
169
170	#ifndef SWAP_DONE
171	#error Unknown byte order -- you need to add code here	204	#error Unknown byte order -- you need to add code here
172	#endif /* SWAP_DONE */	205	#endif
173		206
174	for (i = 16; i < 80; ++i) {	207	for (i = 16; i < 80; ++i)
		208	{
175	W[i] = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];	209	T = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];
176	#if (SHA_VERSION == 1)	210	W[i] = R32(T,1);
177	W[i] = R32(W[i], 1);
178	#endif /* SHA_VERSION */
179	}	211	}
		212
180	A = sha_info->digest[0];	213	A = sha_info->digest[0];
181	B = sha_info->digest[1];	214	B = sha_info->digest[1];
182	C = sha_info->digest[2];	215	C = sha_info->digest[2];
183	D = sha_info->digest[3];	216	D = sha_info->digest[3];
184	E = sha_info->digest[4];	217	E = sha_info->digest[4];
		218
185	WP = W;	219	WP = W;
186	#ifdef UNRAVEL
187	FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1); FC(1); FD(1);	220	FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1); FC(1); FD(1);
188	FE(1); FT(1); FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1);	221	FE(1); FT(1); FA(1); FB(1); FC(1); FD(1); FE(1); FT(1); FA(1); FB(1);
189	FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2); FE(2); FT(2);	222	FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2); FE(2); FT(2);
190	FA(2); FB(2); FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2);	223	FA(2); FB(2); FC(2); FD(2); FE(2); FT(2); FA(2); FB(2); FC(2); FD(2);
191	FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3); FA(3); FB(3);	224	FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3); FA(3); FB(3);
192	FC(3); FD(3); FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3);	225	FC(3); FD(3); FE(3); FT(3); FA(3); FB(3); FC(3); FD(3); FE(3); FT(3);
193	FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4); FC(4); FD(4);	226	FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4); FC(4); FD(4);
194	FE(4); FT(4); FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4);	227	FE(4); FT(4); FA(4); FB(4); FC(4); FD(4); FE(4); FT(4); FA(4); FB(4);
		228
195	sha_info->digest[0] = T32(sha_info->digest[0] + E);	229	sha_info->digest[0] = T32(sha_info->digest[0] + E);
196	sha_info->digest[1] = T32(sha_info->digest[1] + T);	230	sha_info->digest[1] = T32(sha_info->digest[1] + T);
197	sha_info->digest[2] = T32(sha_info->digest[2] + A);	231	sha_info->digest[2] = T32(sha_info->digest[2] + A);
198	sha_info->digest[3] = T32(sha_info->digest[3] + B);	232	sha_info->digest[3] = T32(sha_info->digest[3] + B);
199	sha_info->digest[4] = T32(sha_info->digest[4] + C);	233	sha_info->digest[4] = T32(sha_info->digest[4] + C);
200	#else /* !UNRAVEL */
201	#ifdef UNROLL_LOOPS
202	FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
203	FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1); FG(1);
204	FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
205	FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2); FG(2);
206	FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
207	FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3); FG(3);
208	FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
209	FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4); FG(4);
210	#else /* !UNROLL_LOOPS */
211	for (i = 0; i < 20; ++i) { FG(1); }
212	for (i = 20; i < 40; ++i) { FG(2); }
213	for (i = 40; i < 60; ++i) { FG(3); }
214	for (i = 60; i < 80; ++i) { FG(4); }
215	#endif /* !UNROLL_LOOPS */
216	sha_info->digest[0] = T32(sha_info->digest[0] + A);
217	sha_info->digest[1] = T32(sha_info->digest[1] + B);
218	sha_info->digest[2] = T32(sha_info->digest[2] + C);
219	sha_info->digest[3] = T32(sha_info->digest[3] + D);
220	sha_info->digest[4] = T32(sha_info->digest[4] + E);
221	#endif /* !UNRAVEL */
222	}	234	}
223		235
224	/* initialize the SHA digest */	236	/* initialize the SHA digest */
225		237
226	static void sha_init(restrict SHA_INFO *sha_info)	238	static void sha_init(SHA_INFO *restrict sha_info)
227	{	239	{
228	sha_info->digest[0] = 0x67452301L;	240	sha_info->digest[0] = 0x67452301L;
229	sha_info->digest[1] = 0xefcdab89L;	241	sha_info->digest[1] = 0xefcdab89L;
230	sha_info->digest[2] = 0x98badcfeL;	242	sha_info->digest[2] = 0x98badcfeL;
231	sha_info->digest[3] = 0x10325476L;	243	sha_info->digest[3] = 0x10325476L;
…		…
234	sha_info->local = 0;	246	sha_info->local = 0;
235	}	247	}
236		248
237	/* update the SHA digest */	249	/* update the SHA digest */
238		250
239	static void sha_update(restrict SHA_INFO sha_info, restrict U8 buffer, int count)	251	static void sha_update(SHA_INFO restrict sha_info, U8 restrict buffer, int count)
240	{	252	{
241	int i;	253	int i;
242		254
243	sha_info->count += count << 3;	255	sha_info->count += count;
244	if (sha_info->local) {	256	if (sha_info->local) {
245	i = SHA_BLOCKSIZE - sha_info->local;	257	i = SHA_BLOCKSIZE - sha_info->local;
246	if (i > count) {	258	if (i > count) {
247	i = count;	259	i = count;
248	}	260	}
…		…
264	}	276	}
265	memcpy(sha_info->data, buffer, count);	277	memcpy(sha_info->data, buffer, count);
266	sha_info->local = count;	278	sha_info->local = count;
267	}	279	}
268		280
269
270	#if 0
271	static void sha_transform_and_copy (unsigned char digest[20], restrict SHA_INFO *sha_info)
272	{
273	sha_transform (sha_info);
274
275	digest[ 0] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff);
276	digest[ 1] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff);
277	digest[ 2] = (unsigned char) ((sha_info->digest[0] >> 8) & 0xff);
278	digest[ 3] = (unsigned char) ((sha_info->digest[0] ) & 0xff);
279	digest[ 4] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff);
280	digest[ 5] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff);
281	digest[ 6] = (unsigned char) ((sha_info->digest[1] >> 8) & 0xff);
282	digest[ 7] = (unsigned char) ((sha_info->digest[1] ) & 0xff);
283	digest[ 8] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff);
284	digest[ 9] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff);
285	digest[10] = (unsigned char) ((sha_info->digest[2] >> 8) & 0xff);
286	digest[11] = (unsigned char) ((sha_info->digest[2] ) & 0xff);
287	digest[12] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff);
288	digest[13] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff);
289	digest[14] = (unsigned char) ((sha_info->digest[3] >> 8) & 0xff);
290	digest[15] = (unsigned char) ((sha_info->digest[3] ) & 0xff);
291	digest[16] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff);
292	digest[17] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff);
293	digest[18] = (unsigned char) ((sha_info->digest[4] >> 8) & 0xff);
294	digest[19] = (unsigned char) ((sha_info->digest[4] ) & 0xff);
295	}
296	#endif
297
298	/* finish computing the SHA digest */	281	/* finish computing the SHA digest */
299	static void sha_final(SHA_INFO *sha_info)	282	static int sha_final(SHA_INFO *sha_info)
300	{	283	{
301	int count;
302	U32 bit_count;
303
304	bit_count = sha_info->count;	284	int count = sha_info->count;
305	count = (int) ((bit_count >> 3) & 0x3f);	285	int local = sha_info->local;
306	((U8 *) sha_info->data)[count++] = 0x80;
307		286
308	if (count > SHA_BLOCKSIZE - 8) {
309	memset(((U8 *) sha_info->data) + count, 0, SHA_BLOCKSIZE - count);
310	sha_transform(sha_info);
311	memset((U8 *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
312	} else {
313	memset(((U8 *) sha_info->data) + count, 0, SHA_BLOCKSIZE - 8 - count);
314	}
315
316	sha_info->data[56] = 0;	287	sha_info->data[local] = 0x80;
317	sha_info->data[57] = 0;
318	sha_info->data[58] = 0;
319	sha_info->data[59] = 0;
320	sha_info->data[60] = (bit_count >> 24) & 0xff;
321	sha_info->data[61] = (bit_count >> 16) & 0xff;
322	sha_info->data[62] = (bit_count >> 8) & 0xff;
323	sha_info->data[63] = (bit_count >> 0) & 0xff;
324		288
		289	if (sha_info->local >= SHA_BLOCKSIZE - 8) {
		290	memset(sha_info->data + local + 1, 0, SHA_BLOCKSIZE - 1 - local);
325	sha_transform (sha_info);	291	sha_transform(sha_info);
		292	memset(sha_info->data, 0, SHA_BLOCKSIZE - 2);
		293	} else {
		294	memset(sha_info->data + local + 1, 0, SHA_BLOCKSIZE - 3 - local);
		295	}
		296
		297	sha_info->data[62] = count >> 5;
		298	sha_info->data[63] = count << 3;
		299
		300	sha_transform (sha_info);
		301
		302	return sha_info->digest[0]
		303	? zprefix (sha_info->digest[0])
		304	: zprefix (sha_info->digest[1]) + 32;
326	}	305	}
327		306
328	#define TRIALCHAR "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!#$%&()*+,-./;<=>?@[]{}^_\|"	307	#define TRIALCHAR "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!#$%&()*+,-./;<=>?@[]{}^_\|"
329		308
330	static char nextenc[256];	309	static char
		310	nextenc[256];
331		311
332	static char rand_char ()	312	static char
		313	rand_char ()
333	{	314	{
334	return TRIALCHAR[rand () % sizeof (TRIALCHAR)];	315	return TRIALCHAR[(int)(Drand01 () * sizeof (TRIALCHAR))];
335	}	316	}
336		317
337	static int zprefix (ULONG n)	318	typedef double (*NVTime)(void);
338	{
339	static char zp[256] =
340	{
341	8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
342	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
343	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
344	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
345	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
346	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
347	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
348	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
349	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
350	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
351	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
352	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
353	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
354	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
355	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
356	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
357	};
358		319
359	return	320	static double
360	n > 0xffffff ? zp[n >> 24]	321	simple_nvtime (void)
361	: n > 0xffff ? 8 + zp[n >> 16]	322	{
362	: n > 0xff ? 16 + zp[n >> 8]	323	return time (0);
363	: 24 + zp[n];	324	}
		325
		326	static NVTime
		327	get_nvtime (void)
		328	{
		329	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
		330
		331	if (svp && SvIOK(*svp))
		332	return INT2PTR(NVTime, SvIV(*svp));
		333	else
		334	return simple_nvtime;
		335
364	}	336	}
365		337
366	MODULE = Digest::Hashcash PACKAGE = Digest::Hashcash	338	MODULE = Digest::Hashcash PACKAGE = Digest::Hashcash
367		339
368	BOOT:	340	BOOT:
…		…
373	nextenc[TRIALCHAR[i]] = TRIALCHAR[(i + 1) % sizeof (TRIALCHAR)];	345	nextenc[TRIALCHAR[i]] = TRIALCHAR[(i + 1) % sizeof (TRIALCHAR)];
374	}	346	}
375		347
376	PROTOTYPES: ENABLE	348	PROTOTYPES: ENABLE
377		349
378	int	350	# could be improved quite a bit in accuracy
379	_estimate_time (float seconds = 2, float minfactor = 1)	351	NV
		352	_estimate_rounds ()
380	CODE:	353	CODE:
381	RETVAL = minfactor;	354	{
		355	char data[40];
		356	NVTime nvtime = get_nvtime ();
		357	NV t1, t2, t;
		358	int count = 0;
		359	SHA_INFO ctx;
		360
		361	t = nvtime ();
		362	do {
		363	t1 = nvtime ();
		364	} while (t == t1);
		365
		366	t = t2 = nvtime ();
		367	do {
		368	volatile int i;
		369	sha_init (&ctx);
		370	sha_update (&ctx, data, sizeof (data));
		371	i = sha_final (&ctx);
		372
		373	if (!(++count & 1023))
		374	t2 = nvtime ();
		375
		376	} while (t == t2);
		377
		378	RETVAL = (NV)count / (t2 - t1);
		379	}
382	OUTPUT:	380	OUTPUT:
383	RETVAL	381	RETVAL
384		382
385	SV *	383	SV *
386	_gentoken (int collisions, IV timestamp, char resource, char trial = "", int extrarand = 0)	384	_gentoken (int size, IV timestamp, char resource, char trial = "", int extrarand = 0)
387	CODE:	385	CODE:
		386	{
388	SHA_INFO ctx1, ctx;	387	SHA_INFO ctx1, ctx;
389	char token, seq, *s;	388	char token, seq, *s;
390	int toklen, i;	389	int toklen, i;
391	time_t tstamp = timestamp ? timestamp : time (0);	390	time_t tstamp = timestamp ? timestamp : time (0);
392	struct tm *tm = gmtime (&tstamp);	391	struct tm *tm = gmtime (&tstamp);
393		392
394	New (0, token,	393	New (0, token,
395	1 + 1 // version	394	1 + 1 // version
396	+ 12 + 1 // time field sans century	395	+ 12 + 1 // time field sans century
397	+ strlen (resource) + 1 // ressource	396	+ strlen (resource) + 1 // ressource
398	+ strlen (trial) + extrarand + 8 + 1 // trial	397	+ strlen (trial) + extrarand + 8 + 1 // trial
399	+ 1,	398	+ 1,
400	char);	399	char);
401		400
402	if (!token)	401	if (!token)
403	croak ("out of memory");	402	croak ("out of memory");
404		403
405	if (collisions > 32)	404	if (size > 64)
406	croak ("collisions must be <= 32 in this implementation\n");	405	croak ("size must be <= 64 in this implementation\n");
407		406
408	toklen = sprintf (token, "%d:%02d%02d%02d%02d%02d%02d:%s:%s",	407	toklen = sprintf (token, "%d:%02d%02d%02d%02d%02d%02d:%s:%s",
409	0, tm->tm_year % 100, tm->tm_mon + 1, tm->tm_mday,	408	0, tm->tm_year % 100, tm->tm_mon + 1, tm->tm_mday,
410	tm->tm_hour, tm->tm_min, tm->tm_sec,	409	tm->tm_hour, tm->tm_min, tm->tm_sec,
411	resource, trial);	410	resource, trial);
412		411
		412	if (toklen > 8000)
		413	croak ("token length must be <= 8000 in this implementation\n");
		414
		415	perlinterp_release ();
		416
413	i = toklen + extrarand;	417	i = toklen + extrarand;
414	while (toklen < i)	418	while (toklen < i)
415	token[toklen++] = rand_char ();	419	token[toklen++] = rand_char ();
416		420
417	sha_init (&ctx1);	421	sha_init (&ctx1);
…		…
424		428
425	for (;;)	429	for (;;)
426	{	430	{
427	ctx = ctx1; // this "optimization" can help a lot for longer resource strings	431	ctx = ctx1; // this "optimization" can help a lot for longer resource strings
428	sha_update (&ctx, seq, 8);	432	sha_update (&ctx, seq, 8);
429	sha_final (&ctx);	433	i = sha_final (&ctx);
430		434
431	i = zprefix (ctx.digest[0]);
432
433	if (i >= collisions)	435	if (i >= size)
434	break;	436	break;
435		437
436	s = seq;	438	s = seq;
437	do {	439	do {
438	s = nextenc [s];	440	s = nextenc [s];
439	} while (*s++ == 'a');	441	} while (*s++ == 'a');
440	}	442	}
441		443
		444	perlinterp_acquire ();
		445
442	RETVAL = newSVpvn (token, toklen);	446	RETVAL = newSVpvn (token, toklen);
		447	}
443	OUTPUT:	448	OUTPUT:
444	RETVAL	449	RETVAL
445		450
446	int	451	int
447	_prefixlen (SV *tok)	452	_prefixlen (SV *tok)
448	CODE:	453	CODE:
		454	{
449	STRLEN toklen;	455	STRLEN toklen;
450	char *token = SvPV (tok, toklen);	456	char *token = SvPV (tok, toklen);
451	SHA_INFO ctx;	457	SHA_INFO ctx;
452		458
453	sha_init (&ctx);	459	sha_init (&ctx);
454	sha_update (&ctx, token, toklen);	460	sha_update (&ctx, token, toklen);
455	sha_final (&ctx);	461	RETVAL = sha_final (&ctx);
456		462	}
457	RETVAL = zprefix (ctx.digest[0]);
458	OUTPUT:	463	OUTPUT:
459	RETVAL	464	RETVAL
460		465
461		466

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing Digest-Hashcash/Hashcash.xs (file contents): Revision 1.1 by root, Sat Sep 6 22:12:00 2003 UTC vs. Revision 1.7 by root, Tue Jul 21 05:01:01 2015 UTC

Diff Legend

Comparing Digest-Hashcash/Hashcash.xs (file contents):
Revision 1.1 by root, Sat Sep 6 22:12:00 2003 UTC vs.
Revision 1.7 by root, Tue Jul 21 05:01:01 2015 UTC