Commit 2a90bfe087b2c1c1b0396a48dd371fc11f33927c - libcryptx-perl

+14

-12

src/ltc/ciphers/aes/aes.c less more

280	280	@return CRYPT_OK if successful
281	281	*/
282	282	#ifdef LTC_CLEAN_STACK
283		static int _rijndael_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	283	static int _rijndael_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
284	284	#else
285		int ECB_ENC(const unsigned char pt, unsigned char ct, symmetric_key *skey)
286		#endif
287		{
288		ulong32 s0, s1, s2, s3, t0, t1, t2, t3, *rk;
	285	int ECB_ENC(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
	286	#endif
	287	{
	288	ulong32 s0, s1, s2, s3, t0, t1, t2, t3;
	289	const ulong32 *rk;
289	290	int Nr, r;
290	291
291	292	LTC_ARGCHK(pt != NULL);

441	442	}
442	443
443	444	#ifdef LTC_CLEAN_STACK
444		int ECB_ENC(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	445	int ECB_ENC(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
445	446	{
446	447	int err = _rijndael_ecb_encrypt(pt, ct, skey);
447	448	burn_stack(sizeof(unsigned long)8 + sizeof(unsigned long) + sizeof(int)*2);

459	460	@return CRYPT_OK if successful
460	461	*/
461	462	#ifdef LTC_CLEAN_STACK
462		static int _rijndael_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	463	static int _rijndael_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
463	464	#else
464		int ECB_DEC(const unsigned char ct, unsigned char pt, symmetric_key *skey)
465		#endif
466		{
467		ulong32 s0, s1, s2, s3, t0, t1, t2, t3, *rk;
	465	int ECB_DEC(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
	466	#endif
	467	{
	468	ulong32 s0, s1, s2, s3, t0, t1, t2, t3;
	469	const ulong32 *rk;
468	470	int Nr, r;
469	471
470	472	LTC_ARGCHK(pt != NULL);

621	623
622	624
623	625	#ifdef LTC_CLEAN_STACK
624		int ECB_DEC(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	626	int ECB_DEC(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
625	627	{
626	628	int err = _rijndael_ecb_decrypt(ct, pt, skey);
627	629	burn_stack(sizeof(unsigned long)8 + sizeof(unsigned long) + sizeof(int)*2);

+3

-1

src/ltc/ciphers/aes/aes_tab.c less more

93	93	0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL,
94	94	};
95	95
96		#ifndef PELI_TAB
	96	#if !defined(PELI_TAB) && defined(LTC_SMALL_CODE)
97	97	static const ulong32 Te4[256] = {
98	98	0x63636363UL, 0x7c7c7c7cUL, 0x77777777UL, 0x7b7b7b7bUL,
99	99	0xf2f2f2f2UL, 0x6b6b6b6bUL, 0x6f6f6f6fUL, 0xc5c5c5c5UL,

1016	1016
1017	1017	#endif /* SMALL CODE */
1018	1018
	1019	#ifndef PELI_TAB
1019	1020	static const ulong32 rcon[] = {
1020	1021	0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL,
1021	1022	0x10000000UL, 0x20000000UL, 0x40000000UL, 0x80000000UL,
1022	1023	0x1B000000UL, 0x36000000UL, /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
1023	1024	};
	1025	#endif
1024	1026
1025	1027	#endif /* __LTC_AES_TAB_C__ */
1026	1028

+3

-3

src/ltc/ciphers/anubis.c less more

1034	1034
1035	1035
1036	1036	static void anubis_crypt(const unsigned char plaintext, unsigned char ciphertext,
1037		ulong32 roundKey[18 + 1][4], int R) {
	1037	const ulong32 roundKey[18 + 1][4], int R) {
1038	1038	int i, pos, r;
1039	1039	ulong32 state[4];
1040	1040	ulong32 inter[4];

1133	1133	@param skey The key as scheduled
1134	1134	@return CRYPT_OK if successful
1135	1135	*/
1136		int anubis_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	1136	int anubis_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
1137	1137	{
1138	1138	LTC_ARGCHK(pt != NULL);
1139	1139	LTC_ARGCHK(ct != NULL);

1149	1149	@param skey The key as scheduled
1150	1150	@return CRYPT_OK if successful
1151	1151	*/
1152		int anubis_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	1152	int anubis_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
1153	1153	{
1154	1154	LTC_ARGCHK(pt != NULL);
1155	1155	LTC_ARGCHK(ct != NULL);

+6

-6

src/ltc/ciphers/blowfish.c less more

385	385	@return CRYPT_OK if successful
386	386	*/
387	387	#ifdef LTC_CLEAN_STACK
388		static int _blowfish_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	388	static int _blowfish_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
389	389	#else
390		int blowfish_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	390	int blowfish_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
391	391	#endif
392	392	{
393	393	ulong32 L, R;

431	431	}
432	432
433	433	#ifdef LTC_CLEAN_STACK
434		int blowfish_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	434	int blowfish_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
435	435	{
436	436	int err = _blowfish_ecb_encrypt(pt, ct, skey);
437	437	burn_stack(sizeof(ulong32) * 2 + sizeof(int));

447	447	@return CRYPT_OK if successful
448	448	*/
449	449	#ifdef LTC_CLEAN_STACK
450		static int _blowfish_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	450	static int _blowfish_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
451	451	#else
452		int blowfish_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	452	int blowfish_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
453	453	#endif
454	454	{
455	455	ulong32 L, R;

492	492	}
493	493
494	494	#ifdef LTC_CLEAN_STACK
495		int blowfish_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	495	int blowfish_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
496	496	{
497	497	int err = _blowfish_ecb_decrypt(ct, pt, skey);
498	498	burn_stack(sizeof(ulong32) * 2 + sizeof(int));

+3

-3

src/ltc/ciphers/camellia.c less more

192	192	return ((ulong64)U) \| (((ulong64)D) << CONST64(32));
193	193	}
194	194
195		static void rot_128(unsigned char in, unsigned count, unsigned char out)
	195	static void rot_128(const unsigned char in, unsigned count, unsigned char out)
196	196	{
197	197	unsigned x, w, b;
198	198

435	435	return CRYPT_OK;
436	436	}
437	437
438		int camellia_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	438	int camellia_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
439	439	{
440	440	ulong64 L, R;
441	441	ulong32 a, b;

529	529	return CRYPT_OK;
530	530	}
531	531
532		int camellia_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	532	int camellia_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
533	533	{
534	534	ulong64 L, R;
535	535	ulong32 a, b;

+6

-6

src/ltc/ciphers/cast5.c less more

533	533	@param skey The key as scheduled
534	534	*/
535	535	#ifdef LTC_CLEAN_STACK
536		static int _cast5_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	536	static int _cast5_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
537	537	#else
538		int cast5_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	538	int cast5_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
539	539	#endif
540	540	{
541	541	ulong32 R, L;

571	571
572	572
573	573	#ifdef LTC_CLEAN_STACK
574		int cast5_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	574	int cast5_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
575	575	{
576	576	int err =_cast5_ecb_encrypt(pt,ct,skey);
577	577	burn_stack(sizeof(ulong32)*3);

586	586	@param skey The key as scheduled
587	587	*/
588	588	#ifdef LTC_CLEAN_STACK
589		static int _cast5_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	589	static int _cast5_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
590	590	#else
591		int cast5_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	591	int cast5_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
592	592	#endif
593	593	{
594	594	ulong32 R, L;

624	624	}
625	625
626	626	#ifdef LTC_CLEAN_STACK
627		int cast5_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	627	int cast5_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
628	628	{
629	629	int err = _cast5_ecb_decrypt(ct,pt,skey);
630	630	burn_stack(sizeof(ulong32)*3);

+4

-4

src/ltc/ciphers/des.c less more

1591	1591	@param skey The key as scheduled
1592	1592	@return CRYPT_OK if successful
1593	1593	*/
1594		int des_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	1594	int des_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
1595	1595	{
1596	1596	ulong32 work[2];
1597	1597	LTC_ARGCHK(pt != NULL);

1612	1612	@param skey The key as scheduled
1613	1613	@return CRYPT_OK if successful
1614	1614	*/
1615		int des_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	1615	int des_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
1616	1616	{
1617	1617	ulong32 work[2];
1618	1618	LTC_ARGCHK(pt != NULL);

1633	1633	@param skey The key as scheduled
1634	1634	@return CRYPT_OK if successful
1635	1635	*/
1636		int des3_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	1636	int des3_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
1637	1637	{
1638	1638	ulong32 work[2];
1639	1639

1657	1657	@param skey The key as scheduled
1658	1658	@return CRYPT_OK if successful
1659	1659	*/
1660		int des3_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	1660	int des3_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
1661	1661	{
1662	1662	ulong32 work[2];
1663	1663	LTC_ARGCHK(pt != NULL);

+3

-3

src/ltc/ciphers/idea.c less more

103	103	return CRYPT_OK;
104	104	}
105	105
106		static int _process_block(const unsigned char in, unsigned char out, ushort16 *m_key)
	106	static int _process_block(const unsigned char in, unsigned char out, const ushort16 *m_key)
107	107	{
108	108	int i;
109	109	ushort16 x0, x1, x2, x3, t0, t1;

154	154	return _setup_key(key, skey);
155	155	}
156	156
157		int idea_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	157	int idea_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
158	158	{
159	159	int err = _process_block(pt, ct, skey->idea.ek);
160	160	#ifdef LTC_CLEAN_STACK

163	163	return err;
164	164	}
165	165
166		int idea_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	166	int idea_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
167	167	{
168	168	int err = _process_block(ct, pt, skey->idea.dk);
169	169	#ifdef LTC_CLEAN_STACK

+4

-4

src/ltc/ciphers/kasumi.c less more

95	95	return (u16)(seven<<9) + nine;
96	96	}
97	97
98		static ulong32 FO( ulong32 in, int round_no, symmetric_key *key)
	98	static ulong32 FO( ulong32 in, int round_no, const symmetric_key *key)
99	99	{
100	100	u16 left, right;
101	101

119	119	return (((ulong32)right)<<16)+left;
120	120	}
121	121
122		static ulong32 FL( ulong32 in, int round_no, symmetric_key *key )
	122	static ulong32 FL( ulong32 in, int round_no, const symmetric_key *key )
123	123	{
124	124	u16 l, r, a, b;
125	125	/* split out the left and right halves */

135	135	return (((ulong32)l)<<16) + r;
136	136	}
137	137
138		int kasumi_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	138	int kasumi_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
139	139	{
140	140	ulong32 left, right, temp;
141	141	int n;

162	162	return CRYPT_OK;
163	163	}
164	164
165		int kasumi_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	165	int kasumi_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
166	166	{
167	167	ulong32 left, right, temp;
168	168	int n;

+2

-2

src/ltc/ciphers/khazad.c less more

740	740	@param skey The key as scheduled
741	741	@return CRYPT_OK if successful
742	742	*/
743		int khazad_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	743	int khazad_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
744	744	{
745	745	LTC_ARGCHK(pt != NULL);
746	746	LTC_ARGCHK(ct != NULL);

756	756	@param skey The key as scheduled
757	757	@return CRYPT_OK if successful
758	758	*/
759		int khazad_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	759	int khazad_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
760	760	{
761	761	LTC_ARGCHK(pt != NULL);
762	762	LTC_ARGCHK(ct != NULL);

+3

-3

src/ltc/ciphers/kseed.c less more

235	235	return CRYPT_OK;
236	236	}
237	237
238		static void rounds(ulong32 P, ulong32 K)
	238	static void rounds(ulong32 P, const ulong32 K)
239	239	{
240	240	ulong32 T, T2;
241	241	int i;

253	253	@param skey The key as scheduled
254	254	@return CRYPT_OK if successful
255	255	*/
256		int kseed_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	256	int kseed_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
257	257	{
258	258	ulong32 P[4];
259	259	LOAD32H(P[0], pt);

275	275	@param skey The key as scheduled
276	276	@return CRYPT_OK if successful
277	277	*/
278		int kseed_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	278	int kseed_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
279	279	{
280	280	ulong32 P[4];
281	281	LOAD32H(P[0], ct);

+8

-8

src/ltc/ciphers/multi2.c less more

19	19	p[1] ^= p[0];
20	20	}
21	21
22		static void pi2(ulong32 p, ulong32 k)
	22	static void pi2(ulong32 p, const ulong32 k)
23	23	{
24	24	ulong32 t;
25	25	t = (p[1] + k[0]) & 0xFFFFFFFFUL;

28	28	p[0] ^= t;
29	29	}
30	30
31		static void pi3(ulong32 p, ulong32 k)
	31	static void pi3(ulong32 p, const ulong32 k)
32	32	{
33	33	ulong32 t;
34	34	t = p[0] + k[1];

40	40	p[1] ^= t;
41	41	}
42	42
43		static void pi4(ulong32 p, ulong32 k)
	43	static void pi4(ulong32 p, const ulong32 k)
44	44	{
45	45	ulong32 t;
46	46	t = (p[1] + k[3]) & 0xFFFFFFFFUL;

48	48	p[0] ^= t;
49	49	}
50	50
51		static void setup(ulong32 dk, ulong32 k, ulong32 *uk)
	51	static void setup(const ulong32 dk, const ulong32 k, ulong32 *uk)
52	52	{
53	53	int n, t;
54	54	ulong32 p[2];

76	76	uk[n++] = p[1];
77	77	}
78	78
79		static void encrypt(ulong32 p, int N, ulong32 uk)
	79	static void encrypt(ulong32 p, int N, const ulong32 uk)
80	80	{
81	81	int n, t;
82	82	for (t = n = 0; ; ) {

88	88	}
89	89	}
90	90
91		static void decrypt(ulong32 p, int N, ulong32 uk)
	91	static void decrypt(ulong32 p, int N, const ulong32 uk)
92	92	{
93	93	int n, t;
94	94	for (t = 4*(((N-1)>>2)&1), n = N; ; ) {

147	147	@param skey The key as scheduled
148	148	@return CRYPT_OK if successful
149	149	*/
150		int multi2_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	150	int multi2_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
151	151	{
152	152	ulong32 p[2];
153	153	LTC_ARGCHK(pt != NULL);

168	168	@param skey The key as scheduled
169	169	@return CRYPT_OK if successful
170	170	*/
171		int multi2_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	171	int multi2_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
172	172	{
173	173	ulong32 p[2];
174	174	LTC_ARGCHK(pt != NULL);

+6

-6

src/ltc/ciphers/noekeon.c less more

107	107	@return CRYPT_OK if successful
108	108	*/
109	109	#ifdef LTC_CLEAN_STACK
110		static int _noekeon_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	110	static int _noekeon_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
111	111	#else
112		int noekeon_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	112	int noekeon_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
113	113	#endif
114	114	{
115	115	ulong32 a,b,c,d,temp;

145	145	}
146	146
147	147	#ifdef LTC_CLEAN_STACK
148		int noekeon_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	148	int noekeon_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
149	149	{
150	150	int err = _noekeon_ecb_encrypt(pt, ct, skey);
151	151	burn_stack(sizeof(ulong32) * 5 + sizeof(int));

161	161	@return CRYPT_OK if successful
162	162	*/
163	163	#ifdef LTC_CLEAN_STACK
164		static int _noekeon_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	164	static int _noekeon_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
165	165	#else
166		int noekeon_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	166	int noekeon_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
167	167	#endif
168	168	{
169	169	ulong32 a,b,c,d, temp;

198	198	}
199	199
200	200	#ifdef LTC_CLEAN_STACK
201		int noekeon_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	201	int noekeon_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
202	202	{
203	203	int err = _noekeon_ecb_decrypt(ct, pt, skey);
204	204	burn_stack(sizeof(ulong32) * 5 + sizeof(int));

+10

-10

src/ltc/ciphers/rc2.c less more

146	146	#ifdef LTC_CLEAN_STACK
147	147	static int _rc2_ecb_encrypt( const unsigned char *pt,
148	148	unsigned char *ct,
149		symmetric_key *skey)
	149	const symmetric_key *skey)
150	150	#else
151	151	int rc2_ecb_encrypt( const unsigned char *pt,
152	152	unsigned char *ct,
153		symmetric_key *skey)
154		#endif
155		{
156		unsigned *xkey;
	153	const symmetric_key *skey)
	154	#endif
	155	{
	156	const unsigned *xkey;
157	157	unsigned x76, x54, x32, x10, i;
158	158
159	159	LTC_ARGCHK(pt != NULL);

203	203	#ifdef LTC_CLEAN_STACK
204	204	int rc2_ecb_encrypt( const unsigned char *pt,
205	205	unsigned char *ct,
206		symmetric_key *skey)
	206	const symmetric_key *skey)
207	207	{
208	208	int err = _rc2_ecb_encrypt(pt, ct, skey);
209	209	burn_stack(sizeof(unsigned ) + sizeof(unsigned) 5);

224	224	#ifdef LTC_CLEAN_STACK
225	225	static int _rc2_ecb_decrypt( const unsigned char *ct,
226	226	unsigned char *pt,
227		symmetric_key *skey)
	227	const symmetric_key *skey)
228	228	#else
229	229	int rc2_ecb_decrypt( const unsigned char *ct,
230	230	unsigned char *pt,
231		symmetric_key *skey)
	231	const symmetric_key *skey)
232	232	#endif
233	233	{
234	234	unsigned x76, x54, x32, x10;
235		unsigned *xkey;
	235	const unsigned *xkey;
236	236	int i;
237	237
238	238	LTC_ARGCHK(pt != NULL);

282	282	#ifdef LTC_CLEAN_STACK
283	283	int rc2_ecb_decrypt( const unsigned char *ct,
284	284	unsigned char *pt,
285		symmetric_key *skey)
	285	const symmetric_key *skey)
286	286	{
287	287	int err = _rc2_ecb_decrypt(ct, pt, skey);
288	288	burn_stack(sizeof(unsigned ) + sizeof(unsigned) 4 + sizeof(int));

+14

-12

src/ltc/ciphers/rc5.c less more

123	123	@return CRYPT_OK if successful
124	124	*/
125	125	#ifdef LTC_CLEAN_STACK
126		static int _rc5_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	126	static int _rc5_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
127	127	#else
128		int rc5_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
129		#endif
130		{
131		ulong32 A, B, *K;
	128	int rc5_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
	129	#endif
	130	{
	131	ulong32 A, B;
	132	const ulong32 *K;
132	133	int r;
133	134	LTC_ARGCHK(skey != NULL);
134	135	LTC_ARGCHK(pt != NULL);

162	163	}
163	164
164	165	#ifdef LTC_CLEAN_STACK
165		int rc5_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	166	int rc5_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
166	167	{
167	168	int err = _rc5_ecb_encrypt(pt, ct, skey);
168	169	burn_stack(sizeof(ulong32) * 2 + sizeof(int));

178	179	@return CRYPT_OK if successful
179	180	*/
180	181	#ifdef LTC_CLEAN_STACK
181		static int _rc5_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	182	static int _rc5_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
182	183	#else
183		int rc5_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
184		#endif
185		{
186		ulong32 A, B, *K;
	184	int rc5_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
	185	#endif
	186	{
	187	ulong32 A, B;
	188	const ulong32 *K;
187	189	int r;
188	190	LTC_ARGCHK(skey != NULL);
189	191	LTC_ARGCHK(pt != NULL);

218	220	}
219	221
220	222	#ifdef LTC_CLEAN_STACK
221		int rc5_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	223	int rc5_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
222	224	{
223	225	int err = _rc5_ecb_decrypt(ct, pt, skey);
224	226	burn_stack(sizeof(ulong32) * 2 + sizeof(int));

+14

-12

src/ltc/ciphers/rc6.c less more

117	117	@param skey The key as scheduled
118	118	*/
119	119	#ifdef LTC_CLEAN_STACK
120		static int _rc6_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	120	static int _rc6_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
121	121	#else
122		int rc6_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
123		#endif
124		{
125		ulong32 a,b,c,d,t,u, *K;
	122	int rc6_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
	123	#endif
	124	{
	125	ulong32 a,b,c,d,t,u;
	126	const ulong32 *K;
126	127	int r;
127	128
128	129	LTC_ARGCHK(skey != NULL);

156	157	}
157	158
158	159	#ifdef LTC_CLEAN_STACK
159		int rc6_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	160	int rc6_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
160	161	{
161	162	int err = _rc6_ecb_encrypt(pt, ct, skey);
162	163	burn_stack(sizeof(ulong32) * 6 + sizeof(int));

171	172	@param skey The key as scheduled
172	173	*/
173	174	#ifdef LTC_CLEAN_STACK
174		static int _rc6_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	175	static int _rc6_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
175	176	#else
176		int rc6_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
177		#endif
178		{
179		ulong32 a,b,c,d,t,u, *K;
	177	int rc6_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
	178	#endif
	179	{
	180	ulong32 a,b,c,d,t,u;
	181	const ulong32 *K;
180	182	int r;
181	183
182	184	LTC_ARGCHK(skey != NULL);

212	214	}
213	215
214	216	#ifdef LTC_CLEAN_STACK
215		int rc6_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	217	int rc6_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
216	218	{
217	219	int err = _rc6_ecb_decrypt(ct, pt, skey);
218	220	burn_stack(sizeof(ulong32) * 6 + sizeof(int));

+8

-8

src/ltc/ciphers/safer/safer.c less more

246	246	#ifdef LTC_CLEAN_STACK
247	247	static int _safer_ecb_encrypt(const unsigned char *block_in,
248	248	unsigned char *block_out,
249		symmetric_key *skey)
	249	const symmetric_key *skey)
250	250	#else
251	251	int safer_ecb_encrypt(const unsigned char *block_in,
252	252	unsigned char *block_out,
253		symmetric_key *skey)
	253	const symmetric_key *skey)
254	254	#endif
255	255	{ unsigned char a, b, c, d, e, f, g, h, t;
256	256	unsigned int round;
257		unsigned char *key;
	257	const unsigned char *key;
258	258
259	259	LTC_ARGCHK(block_in != NULL);
260	260	LTC_ARGCHK(block_out != NULL);

289	289	#ifdef LTC_CLEAN_STACK
290	290	int safer_ecb_encrypt(const unsigned char *block_in,
291	291	unsigned char *block_out,
292		symmetric_key *skey)
	292	const symmetric_key *skey)
293	293	{
294	294	int err = _safer_ecb_encrypt(block_in, block_out, skey);
295	295	burn_stack(sizeof(unsigned char) * 9 + sizeof(unsigned int) + sizeof(unsigned char *));

300	300	#ifdef LTC_CLEAN_STACK
301	301	static int _safer_ecb_decrypt(const unsigned char *block_in,
302	302	unsigned char *block_out,
303		symmetric_key *skey)
	303	const symmetric_key *skey)
304	304	#else
305	305	int safer_ecb_decrypt(const unsigned char *block_in,
306	306	unsigned char *block_out,
307		symmetric_key *skey)
	307	const symmetric_key *skey)
308	308	#endif
309	309	{ unsigned char a, b, c, d, e, f, g, h, t;
310	310	unsigned int round;
311		unsigned char *key;
	311	const unsigned char *key;
312	312
313	313	LTC_ARGCHK(block_in != NULL);
314	314	LTC_ARGCHK(block_out != NULL);

344	344	#ifdef LTC_CLEAN_STACK
345	345	int safer_ecb_decrypt(const unsigned char *block_in,
346	346	unsigned char *block_out,
347		symmetric_key *skey)
	347	const symmetric_key *skey)
348	348	{
349	349	int err = _safer_ecb_decrypt(block_in, block_out, skey);
350	350	burn_stack(sizeof(unsigned char) * 9 + sizeof(unsigned int) + sizeof(unsigned char *));

+4

-4

src/ltc/ciphers/safer/saferp.c less more

142	142
143	143	#ifdef LTC_SMALL_CODE
144	144
145		static void _round(unsigned char b, int i, symmetric_key skey)
	145	static void _round(unsigned char b, int i, const symmetric_key skey)
146	146	{
147	147	ROUND(b, i);
148	148	}
149	149
150		static void _iround(unsigned char b, int i, symmetric_key skey)
	150	static void _iround(unsigned char b, int i, const symmetric_key skey)
151	151	{
152	152	iROUND(b, i);
153	153	}

337	337	@param skey The key as scheduled
338	338	@return CRYPT_OK if successful
339	339	*/
340		int saferp_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	340	int saferp_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
341	341	{
342	342	unsigned char b[16];
343	343	int x;

401	401	@param skey The key as scheduled
402	402	@return CRYPT_OK if successful
403	403	*/
404		int saferp_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	404	int saferp_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
405	405	{
406	406	unsigned char b[16];
407	407	int x;

+4

-4

src/ltc/ciphers/serpent.c less more

487	487	return CRYPT_OK;
488	488	}
489	489
490		static int _enc_block(const unsigned char in, unsigned char out, ulong32 *k)
	490	static int _enc_block(const unsigned char in, unsigned char out, const ulong32 *k)
491	491	{
492	492	ulong32 a, b, c, d, e;
493	493	unsigned int i = 1;

529	529	return CRYPT_OK;
530	530	}
531	531
532		static int _dec_block(const unsigned char in, unsigned char out, ulong32 *k)
	532	static int _dec_block(const unsigned char in, unsigned char out, const ulong32 *k)
533	533	{
534	534	ulong32 a, b, c, d, e;
535	535	unsigned int i;

587	587	return err;
588	588	}
589	589
590		int serpent_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	590	int serpent_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
591	591	{
592	592	int err = _enc_block(pt, ct, skey->serpent.k);
593	593	#ifdef LTC_CLEAN_STACK

596	596	return err;
597	597	}
598	598
599		int serpent_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	599	int serpent_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
600	600	{
601	601	int err = _dec_block(ct, pt, skey->serpent.k);
602	602	#ifdef LTC_CLEAN_STACK

+8

-8

src/ltc/ciphers/skipjack.c less more

106	106	w2 = tmp ^ w3 ^ x; \
107	107	w3 = w4; w4 = w1; w1 = tmp;
108	108
109		static unsigned g_func(unsigned w, int kp, unsigned char key)
	109	static unsigned g_func(unsigned w, int kp, const unsigned char key)
110	110	{
111	111	unsigned char g1,g2;
112	112

118	118	return ((unsigned)g1<<8)\|(unsigned)g2;
119	119	}
120	120
121		static unsigned ig_func(unsigned w, int kp, unsigned char key)
	121	static unsigned ig_func(unsigned w, int kp, const unsigned char key)
122	122	{
123	123	unsigned char g1,g2;
124	124

138	138	@return CRYPT_OK if successful
139	139	*/
140	140	#ifdef LTC_CLEAN_STACK
141		static int _skipjack_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	141	static int _skipjack_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
142	142	#else
143		int skipjack_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	143	int skipjack_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
144	144	#endif
145	145	{
146	146	unsigned w1,w2,w3,w4,tmp,tmp1;

186	186	}
187	187
188	188	#ifdef LTC_CLEAN_STACK
189		int skipjack_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	189	int skipjack_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
190	190	{
191	191	int err = _skipjack_ecb_encrypt(pt, ct, skey);
192	192	burn_stack(sizeof(unsigned) * 8 + sizeof(int) * 2);

202	202	@return CRYPT_OK if successful
203	203	*/
204	204	#ifdef LTC_CLEAN_STACK
205		static int _skipjack_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	205	static int _skipjack_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
206	206	#else
207		int skipjack_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	207	int skipjack_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
208	208	#endif
209	209	{
210	210	unsigned w1,w2,w3,w4,tmp;

254	254	}
255	255
256	256	#ifdef LTC_CLEAN_STACK
257		int skipjack_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	257	int skipjack_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
258	258	{
259	259	int err = _skipjack_ecb_decrypt(ct, pt, skey);
260	260	burn_stack(sizeof(unsigned) * 7 + sizeof(int) * 2);

+21

-19

src/ltc/ciphers/twofish/twofish.c less more

236	236	#endif
237	237
238	238	/* computes h(x) */
239		static void h_func(const unsigned char in, unsigned char out, unsigned char *M, int k, int offset)
	239	static void h_func(const unsigned char in, unsigned char out, const unsigned char *M, int k, int offset)
240	240	{
241	241	int x;
242	242	unsigned char y[4];

283	283	#else
284	284
285	285	#ifdef LTC_CLEAN_STACK
286		static ulong32 _g_func(ulong32 x, symmetric_key *key)
287		#else
288		static ulong32 g_func(ulong32 x, symmetric_key *key)
	286	static ulong32 _g_func(ulong32 x, const symmetric_key *key)
	287	#else
	288	static ulong32 g_func(ulong32 x, const symmetric_key *key)
289	289	#endif
290	290	{
291	291	unsigned char g, i, y, z;

316	316	#define g1_func(x, key) g_func(ROLc(x, 8), key)
317	317
318	318	#ifdef LTC_CLEAN_STACK
319		static ulong32 g_func(ulong32 x, symmetric_key *key)
	319	static ulong32 g_func(ulong32 x, const symmetric_key *key)
320	320	{
321	321	ulong32 y;
322	322	y = _g_func(x, key);

463	463	@return CRYPT_OK if successful
464	464	*/
465	465	#ifdef LTC_CLEAN_STACK
466		static int _twofish_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
467		#else
468		int twofish_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
469		#endif
470		{
471		ulong32 a,b,c,d,ta,tb,tc,td,t1,t2, *k;
	466	static int _twofish_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
	467	#else
	468	int twofish_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
	469	#endif
	470	{
	471	ulong32 a,b,c,d,ta,tb,tc,td,t1,t2;
	472	const ulong32 *k;
472	473	int r;
473	474	#if !defined(LTC_TWOFISH_SMALL) && !defined(__GNUC__)
474	475	ulong32 S1, S2, S3, S4;

520	521	}
521	522
522	523	#ifdef LTC_CLEAN_STACK
523		int twofish_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	524	int twofish_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
524	525	{
525	526	int err = _twofish_ecb_encrypt(pt, ct, skey);
526	527	burn_stack(sizeof(ulong32) * 10 + sizeof(int));

536	537	@return CRYPT_OK if successful
537	538	*/
538	539	#ifdef LTC_CLEAN_STACK
539		static int _twofish_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
540		#else
541		int twofish_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
542		#endif
543		{
544		ulong32 a,b,c,d,ta,tb,tc,td,t1,t2, *k;
	540	static int _twofish_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
	541	#else
	542	int twofish_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
	543	#endif
	544	{
	545	ulong32 a,b,c,d,ta,tb,tc,td,t1,t2;
	546	const ulong32 *k;
545	547	int r;
546	548	#if !defined(LTC_TWOFISH_SMALL) && !defined(__GNUC__)
547	549	ulong32 S1, S2, S3, S4;

595	597	}
596	598
597	599	#ifdef LTC_CLEAN_STACK
598		int twofish_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	600	int twofish_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
599	601	{
600	602	int err =_twofish_ecb_decrypt(ct, pt, skey);
601	603	burn_stack(sizeof(ulong32) * 10 + sizeof(int));

+2

-2

src/ltc/ciphers/xtea.c less more

70	70	@param skey The key as scheduled
71	71	@return CRYPT_OK if successful
72	72	*/
73		int xtea_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey)
	73	int xtea_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey)
74	74	{
75	75	ulong32 y, z;
76	76	int r;

106	106	@param skey The key as scheduled
107	107	@return CRYPT_OK if successful
108	108	*/
109		int xtea_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey)
	109	int xtea_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey)
110	110	{
111	111	ulong32 y, z;
112	112	int r;

+1

-1

src/ltc/encauth/eax/eax_decrypt_verify_memory.c less more

37	37	const unsigned char *header, unsigned long headerlen,
38	38	const unsigned char *ct, unsigned long ctlen,
39	39	unsigned char *pt,
40		unsigned char *tag, unsigned long taglen,
	40	const unsigned char *tag, unsigned long taglen,
41	41	int *stat)
42	42	{
43	43	int err;

+1

-1

src/ltc/encauth/gcm/gcm_mult_h.c less more

18	18	@param gcm The GCM state which holds the H value
19	19	@param I The value to multiply H by
20	20	*/
21		void gcm_mult_h(gcm_state gcm, unsigned char I)
	21	void gcm_mult_h(const gcm_state gcm, unsigned char I)
22	22	{
23	23	unsigned char T[16];
24	24	#ifdef LTC_GCM_TABLES

+1

-1

src/ltc/hashes/chc/chc.c less more

126	126	T0 <= encrypt T0
127	127	state <= state xor T0 xor T1
128	128	*/
129		static int chc_compress(hash_state md, unsigned char buf)
	129	static int chc_compress(hash_state md, const unsigned char buf)
130	130	{
131	131	unsigned char T[2][MAXBLOCKSIZE];
132	132	symmetric_key *key;

+1

-1

src/ltc/hashes/md4.c less more

72	72	#ifdef LTC_CLEAN_STACK
73	73	static int _md4_compress(hash_state md, unsigned char buf)
74	74	#else
75		static int md4_compress(hash_state md, unsigned char buf)
	75	static int md4_compress(hash_state md, const unsigned char buf)
76	76	#endif
77	77	{
78	78	ulong32 x[16], a, b, c, d;

+1

-1

src/ltc/hashes/md5.c less more

97	97	#ifdef LTC_CLEAN_STACK
98	98	static int _md5_compress(hash_state md, unsigned char buf)
99	99	#else
100		static int md5_compress(hash_state md, unsigned char buf)
	100	static int md5_compress(hash_state md, const unsigned char buf)
101	101	#endif
102	102	{
103	103	ulong32 i, W[16], a, b, c, d;

+1

-1

src/ltc/hashes/rmd128.c less more

80	80	#ifdef LTC_CLEAN_STACK
81	81	static int _rmd128_compress(hash_state md, unsigned char buf)
82	82	#else
83		static int rmd128_compress(hash_state md, unsigned char buf)
	83	static int rmd128_compress(hash_state md, const unsigned char buf)
84	84	#endif
85	85	{
86	86	ulong32 aa,bb,cc,dd,aaa,bbb,ccc,ddd,X[16];

+1

-1

src/ltc/hashes/rmd160.c less more

100	100	#ifdef LTC_CLEAN_STACK
101	101	static int _rmd160_compress(hash_state md, unsigned char buf)
102	102	#else
103		static int rmd160_compress(hash_state md, unsigned char buf)
	103	static int rmd160_compress(hash_state md, const unsigned char buf)
104	104	#endif
105	105	{
106	106	ulong32 aa,bb,cc,dd,ee,aaa,bbb,ccc,ddd,eee,X[16];

+1

-1

src/ltc/hashes/rmd256.c less more

74	74	#ifdef LTC_CLEAN_STACK
75	75	static int _rmd256_compress(hash_state md, unsigned char buf)
76	76	#else
77		static int rmd256_compress(hash_state md, unsigned char buf)
	77	static int rmd256_compress(hash_state md, const unsigned char buf)
78	78	#endif
79	79	{
80	80	ulong32 aa,bb,cc,dd,aaa,bbb,ccc,ddd,tmp,X[16];

+1

-1

src/ltc/hashes/rmd320.c less more

95	95	#ifdef LTC_CLEAN_STACK
96	96	static int _rmd320_compress(hash_state md, unsigned char buf)
97	97	#else
98		static int rmd320_compress(hash_state md, unsigned char buf)
	98	static int rmd320_compress(hash_state md, const unsigned char buf)
99	99	#endif
100	100	{
101	101	ulong32 aa,bb,cc,dd,ee,aaa,bbb,ccc,ddd,eee,tmp,X[16];

+1

-1

src/ltc/hashes/sha1.c less more

41	41	#ifdef LTC_CLEAN_STACK
42	42	static int _sha1_compress(hash_state md, unsigned char buf)
43	43	#else
44		static int sha1_compress(hash_state md, unsigned char buf)
	44	static int sha1_compress(hash_state md, const unsigned char buf)
45	45	#endif
46	46	{
47	47	ulong32 a,b,c,d,e,W[80],i;

+1

-1

src/ltc/hashes/sha2/sha256.c less more

65	65	#ifdef LTC_CLEAN_STACK
66	66	static int _sha256_compress(hash_state * md, unsigned char *buf)
67	67	#else
68		static int sha256_compress(hash_state * md, unsigned char *buf)
	68	static int sha256_compress(hash_state * md, const unsigned char *buf)
69	69	#endif
70	70	{
71	71	ulong32 S[8], W[64], t0, t1;

+1

-1

src/ltc/hashes/sha2/sha512.c less more

90	90	#ifdef LTC_CLEAN_STACK
91	91	static int _sha512_compress(hash_state * md, unsigned char *buf)
92	92	#else
93		static int sha512_compress(hash_state * md, unsigned char *buf)
	93	static int sha512_compress(hash_state * md, const unsigned char *buf)
94	94	#endif
95	95	{
96	96	ulong64 S[8], W[80], t0, t1;

+1

-1

src/ltc/hashes/sha3.c less more

363	363	return CRYPT_OK;
364	364	}
365	365
366		int sha3_shake_memory(int num, const unsigned char in, unsigned long inlen, unsigned char out, unsigned long *outlen)
	366	int sha3_shake_memory(int num, const unsigned char in, unsigned long inlen, unsigned char out, const unsigned long *outlen)
367	367	{
368	368	hash_state md;
369	369	int err;

+3

-3

src/ltc/hashes/tiger.c less more

573	573	}
574	574
575	575	/* one complete pass */
576		static void pass(ulong64 a, ulong64 b, ulong64 c, ulong64 x, int mul)
	576	static void pass(ulong64 a, ulong64 b, ulong64 c, const ulong64 x, int mul)
577	577	{
578	578	tiger_round(a,b,c,x[0],mul);
579	579	tiger_round(b,c,a,x[1],mul);

607	607	}
608	608
609	609	#ifdef LTC_CLEAN_STACK
610		static int _tiger_compress(hash_state md, unsigned char buf)
	610	static int _tiger_compress(hash_state md, const unsigned char buf)
611	611	#else
612		static int tiger_compress(hash_state md, unsigned char buf)
	612	static int tiger_compress(hash_state md, const unsigned char buf)
613	613	#endif
614	614	{
615	615	ulong64 a, b, c, x[8];

+2

-2

src/ltc/hashes/whirl/whirl.c less more

52	52	SB7(GB(a, i-7, 0)))
53	53
54	54	#ifdef LTC_CLEAN_STACK
55		static int _whirlpool_compress(hash_state md, unsigned char buf)
	55	static int _whirlpool_compress(hash_state md, const unsigned char buf)
56	56	#else
57		static int whirlpool_compress(hash_state md, unsigned char buf)
	57	static int whirlpool_compress(hash_state md, const unsigned char buf)
58	58	#endif
59	59	{
60	60	ulong64 K[2][8], T[3][8];

+61

-61

src/ltc/headers/tomcrypt_cipher.h less more

396	396	@param skey The scheduled key
397	397	@return CRYPT_OK if successful
398	398	*/
399		int (ecb_encrypt)(const unsigned char pt, unsigned char ct, symmetric_key skey);
	399	int (ecb_encrypt)(const unsigned char pt, unsigned char ct, const symmetric_key skey);
400	400	/** Decrypt a block
401	401	@param ct The ciphertext
402	402	@param pt [out] The plaintext
403	403	@param skey The scheduled key
404	404	@return CRYPT_OK if successful
405	405	*/
406		int (ecb_decrypt)(const unsigned char ct, unsigned char pt, symmetric_key skey);
	406	int (ecb_decrypt)(const unsigned char ct, unsigned char pt, const symmetric_key skey);
407	407	/** Test the block cipher
408	408	@return CRYPT_OK if successful, CRYPT_NOP if self-testing has been disabled
409	409	*/

597	597	@return CRYPT_OK if successful
598	598	*/
599	599	int (accel_xts_encrypt)(const unsigned char pt, unsigned char *ct,
600		unsigned long blocks, unsigned char tweak, symmetric_key skey1,
601		symmetric_key *skey2);
	600	unsigned long blocks, unsigned char *tweak,
	601	const symmetric_key skey1, const symmetric_key skey2);
602	602
603	603	/** Accelerated XTS decryption
604	604	@param ct Ciphertext

612	612	@return CRYPT_OK if successful
613	613	*/
614	614	int (accel_xts_decrypt)(const unsigned char ct, unsigned char *pt,
615		unsigned long blocks, unsigned char tweak, symmetric_key skey1,
616		symmetric_key *skey2);
	615	unsigned long blocks, unsigned char *tweak,
	616	const symmetric_key skey1, const symmetric_key skey2);
617	617	} cipher_descriptor[];
618	618
619	619	#ifdef LTC_BLOWFISH
620	620	int blowfish_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
621		int blowfish_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
622		int blowfish_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	621	int blowfish_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	622	int blowfish_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
623	623	int blowfish_test(void);
624	624	void blowfish_done(symmetric_key *skey);
625	625	int blowfish_keysize(int *keysize);

628	628
629	629	#ifdef LTC_RC5
630	630	int rc5_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
631		int rc5_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
632		int rc5_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	631	int rc5_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	632	int rc5_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
633	633	int rc5_test(void);
634	634	void rc5_done(symmetric_key *skey);
635	635	int rc5_keysize(int *keysize);

638	638
639	639	#ifdef LTC_RC6
640	640	int rc6_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
641		int rc6_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
642		int rc6_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	641	int rc6_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	642	int rc6_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
643	643	int rc6_test(void);
644	644	void rc6_done(symmetric_key *skey);
645	645	int rc6_keysize(int *keysize);

649	649	#ifdef LTC_RC2
650	650	int rc2_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
651	651	int rc2_setup_ex(const unsigned char key, int keylen, int bits, int num_rounds, symmetric_key skey);
652		int rc2_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
653		int rc2_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	652	int rc2_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	653	int rc2_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
654	654	int rc2_test(void);
655	655	void rc2_done(symmetric_key *skey);
656	656	int rc2_keysize(int *keysize);

659	659
660	660	#ifdef LTC_SAFERP
661	661	int saferp_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
662		int saferp_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
663		int saferp_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	662	int saferp_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	663	int saferp_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
664	664	int saferp_test(void);
665	665	void saferp_done(symmetric_key *skey);
666	666	int saferp_keysize(int *keysize);

672	672	int safer_sk64_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
673	673	int safer_k128_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
674	674	int safer_sk128_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
675		int safer_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *key);
676		int safer_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *key);
	675	int safer_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *key);
	676	int safer_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *key);
677	677	int safer_k64_test(void);
678	678	int safer_sk64_test(void);
679	679	int safer_sk128_test(void);

698	698	#define aes_enc_keysize rijndael_enc_keysize
699	699
700	700	int rijndael_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
701		int rijndael_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
702		int rijndael_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	701	int rijndael_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	702	int rijndael_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
703	703	int rijndael_test(void);
704	704	void rijndael_done(symmetric_key *skey);
705	705	int rijndael_keysize(int *keysize);
706	706	int rijndael_enc_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
707		int rijndael_enc_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
	707	int rijndael_enc_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
708	708	void rijndael_enc_done(symmetric_key *skey);
709	709	int rijndael_enc_keysize(int *keysize);
710	710	extern const struct ltc_cipher_descriptor rijndael_desc, aes_desc;

713	713
714	714	#ifdef LTC_XTEA
715	715	int xtea_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
716		int xtea_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
717		int xtea_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	716	int xtea_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	717	int xtea_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
718	718	int xtea_test(void);
719	719	void xtea_done(symmetric_key *skey);
720	720	int xtea_keysize(int *keysize);

723	723
724	724	#ifdef LTC_TWOFISH
725	725	int twofish_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
726		int twofish_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
727		int twofish_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	726	int twofish_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	727	int twofish_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
728	728	int twofish_test(void);
729	729	void twofish_done(symmetric_key *skey);
730	730	int twofish_keysize(int *keysize);

733	733
734	734	#ifdef LTC_DES
735	735	int des_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
736		int des_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
737		int des_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	736	int des_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	737	int des_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
738	738	int des_test(void);
739	739	void des_done(symmetric_key *skey);
740	740	int des_keysize(int *keysize);
741	741	int des3_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
742		int des3_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
743		int des3_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	742	int des3_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	743	int des3_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
744	744	int des3_test(void);
745	745	void des3_done(symmetric_key *skey);
746	746	int des3_keysize(int *keysize);

749	749
750	750	#ifdef LTC_CAST5
751	751	int cast5_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
752		int cast5_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
753		int cast5_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	752	int cast5_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	753	int cast5_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
754	754	int cast5_test(void);
755	755	void cast5_done(symmetric_key *skey);
756	756	int cast5_keysize(int *keysize);

759	759
760	760	#ifdef LTC_NOEKEON
761	761	int noekeon_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
762		int noekeon_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
763		int noekeon_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	762	int noekeon_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	763	int noekeon_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
764	764	int noekeon_test(void);
765	765	void noekeon_done(symmetric_key *skey);
766	766	int noekeon_keysize(int *keysize);

769	769
770	770	#ifdef LTC_SKIPJACK
771	771	int skipjack_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
772		int skipjack_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
773		int skipjack_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	772	int skipjack_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	773	int skipjack_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
774	774	int skipjack_test(void);
775	775	void skipjack_done(symmetric_key *skey);
776	776	int skipjack_keysize(int *keysize);

779	779
780	780	#ifdef LTC_KHAZAD
781	781	int khazad_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
782		int khazad_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
783		int khazad_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	782	int khazad_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	783	int khazad_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
784	784	int khazad_test(void);
785	785	void khazad_done(symmetric_key *skey);
786	786	int khazad_keysize(int *keysize);

789	789
790	790	#ifdef LTC_ANUBIS
791	791	int anubis_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
792		int anubis_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
793		int anubis_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	792	int anubis_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	793	int anubis_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
794	794	int anubis_test(void);
795	795	void anubis_done(symmetric_key *skey);
796	796	int anubis_keysize(int *keysize);

799	799
800	800	#ifdef LTC_KSEED
801	801	int kseed_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
802		int kseed_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
803		int kseed_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	802	int kseed_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	803	int kseed_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
804	804	int kseed_test(void);
805	805	void kseed_done(symmetric_key *skey);
806	806	int kseed_keysize(int *keysize);

809	809
810	810	#ifdef LTC_KASUMI
811	811	int kasumi_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
812		int kasumi_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
813		int kasumi_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	812	int kasumi_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	813	int kasumi_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
814	814	int kasumi_test(void);
815	815	void kasumi_done(symmetric_key *skey);
816	816	int kasumi_keysize(int *keysize);

820	820
821	821	#ifdef LTC_MULTI2
822	822	int multi2_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
823		int multi2_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
824		int multi2_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	823	int multi2_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	824	int multi2_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
825	825	int multi2_test(void);
826	826	void multi2_done(symmetric_key *skey);
827	827	int multi2_keysize(int *keysize);

830	830
831	831	#ifdef LTC_CAMELLIA
832	832	int camellia_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
833		int camellia_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
834		int camellia_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	833	int camellia_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	834	int camellia_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
835	835	int camellia_test(void);
836	836	void camellia_done(symmetric_key *skey);
837	837	int camellia_keysize(int *keysize);

840	840
841	841	#ifdef LTC_IDEA
842	842	int idea_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
843		int idea_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
844		int idea_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	843	int idea_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	844	int idea_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
845	845	int idea_test(void);
846	846	void idea_done(symmetric_key *skey);
847	847	int idea_keysize(int *keysize);

850	850
851	851	#ifdef LTC_SERPENT
852	852	int serpent_setup(const unsigned char key, int keylen, int num_rounds, symmetric_key skey);
853		int serpent_ecb_encrypt(const unsigned char pt, unsigned char ct, symmetric_key *skey);
854		int serpent_ecb_decrypt(const unsigned char ct, unsigned char pt, symmetric_key *skey);
	853	int serpent_ecb_encrypt(const unsigned char pt, unsigned char ct, const symmetric_key *skey);
	854	int serpent_ecb_decrypt(const unsigned char ct, unsigned char pt, const symmetric_key *skey);
855	855	int serpent_test(void);
856	856	void serpent_done(symmetric_key *skey);
857	857	int serpent_keysize(int *keysize);

871	871	int keylen, int num_rounds, symmetric_CFB *cfb);
872	872	int cfb_encrypt(const unsigned char pt, unsigned char ct, unsigned long len, symmetric_CFB *cfb);
873	873	int cfb_decrypt(const unsigned char ct, unsigned char pt, unsigned long len, symmetric_CFB *cfb);
874		int cfb_getiv(unsigned char IV, unsigned long len, symmetric_CFB *cfb);
	874	int cfb_getiv(unsigned char IV, unsigned long len, const symmetric_CFB *cfb);
875	875	int cfb_setiv(const unsigned char IV, unsigned long len, symmetric_CFB cfb);
876	876	int cfb_done(symmetric_CFB *cfb);
877	877	#endif

881	881	int keylen, int num_rounds, symmetric_OFB *ofb);
882	882	int ofb_encrypt(const unsigned char pt, unsigned char ct, unsigned long len, symmetric_OFB *ofb);
883	883	int ofb_decrypt(const unsigned char ct, unsigned char pt, unsigned long len, symmetric_OFB *ofb);
884		int ofb_getiv(unsigned char IV, unsigned long len, symmetric_OFB *ofb);
	884	int ofb_getiv(unsigned char IV, unsigned long len, const symmetric_OFB *ofb);
885	885	int ofb_setiv(const unsigned char IV, unsigned long len, symmetric_OFB ofb);
886	886	int ofb_done(symmetric_OFB *ofb);
887	887	#endif

891	891	int keylen, int num_rounds, symmetric_CBC *cbc);
892	892	int cbc_encrypt(const unsigned char pt, unsigned char ct, unsigned long len, symmetric_CBC *cbc);
893	893	int cbc_decrypt(const unsigned char ct, unsigned char pt, unsigned long len, symmetric_CBC *cbc);
894		int cbc_getiv(unsigned char IV, unsigned long len, symmetric_CBC *cbc);
	894	int cbc_getiv(unsigned char IV, unsigned long len, const symmetric_CBC *cbc);
895	895	int cbc_setiv(const unsigned char IV, unsigned long len, symmetric_CBC cbc);
896	896	int cbc_done(symmetric_CBC *cbc);
897	897	#endif

909	909	symmetric_CTR *ctr);
910	910	int ctr_encrypt(const unsigned char pt, unsigned char ct, unsigned long len, symmetric_CTR *ctr);
911	911	int ctr_decrypt(const unsigned char ct, unsigned char pt, unsigned long len, symmetric_CTR *ctr);
912		int ctr_getiv(unsigned char IV, unsigned long len, symmetric_CTR *ctr);
	912	int ctr_getiv(unsigned char IV, unsigned long len, const symmetric_CTR *ctr);
913	913	int ctr_setiv(const unsigned char IV, unsigned long len, symmetric_CTR ctr);
914	914	int ctr_done(symmetric_CTR *ctr);
915	915	int ctr_test(void);

928	928	symmetric_LRW *lrw);
929	929	int lrw_encrypt(const unsigned char pt, unsigned char ct, unsigned long len, symmetric_LRW *lrw);
930	930	int lrw_decrypt(const unsigned char ct, unsigned char pt, unsigned long len, symmetric_LRW *lrw);
931		int lrw_getiv(unsigned char IV, unsigned long len, symmetric_LRW *lrw);
	931	int lrw_getiv(unsigned char IV, unsigned long len, const symmetric_LRW *lrw);
932	932	int lrw_setiv(const unsigned char IV, unsigned long len, symmetric_LRW lrw);
933	933	int lrw_done(symmetric_LRW *lrw);
934	934	int lrw_test(void);

944	944	int num_rounds, symmetric_F8 *f8);
945	945	int f8_encrypt(const unsigned char pt, unsigned char ct, unsigned long len, symmetric_F8 *f8);
946	946	int f8_decrypt(const unsigned char ct, unsigned char pt, unsigned long len, symmetric_F8 *f8);
947		int f8_getiv(unsigned char IV, unsigned long len, symmetric_F8 *f8);
	947	int f8_getiv(unsigned char IV, unsigned long len, const symmetric_F8 *f8);
948	948	int f8_setiv(const unsigned char IV, unsigned long len, symmetric_F8 f8);
949	949	int f8_done(symmetric_F8 *f8);
950	950	int f8_test_mode(void);

967	967	const unsigned char *pt, unsigned long ptlen,
968	968	unsigned char *ct,
969	969	unsigned char *tweak,
970		symmetric_xts *xts);
	970	const symmetric_xts *xts);
971	971	int xts_decrypt(
972	972	const unsigned char *ct, unsigned long ptlen,
973	973	unsigned char *pt,
974	974	unsigned char *tweak,
975		symmetric_xts *xts);
	975	const symmetric_xts *xts);
976	976
977	977	void xts_done(symmetric_xts *xts);
978	978	int xts_test(void);

1045	1045	unsigned ptr;
1046	1046	} sosemanuk_state;
1047	1047
1048		int sosemanuk_setup(sosemanuk_state ss, unsigned char key, unsigned long keylen);
1049		int sosemanuk_setiv(sosemanuk_state ss, unsigned char iv, unsigned long ivlen);
	1048	int sosemanuk_setup(sosemanuk_state ss, const unsigned char key, unsigned long keylen);
	1049	int sosemanuk_setiv(sosemanuk_state ss, const unsigned char iv, unsigned long ivlen);
1050	1050	int sosemanuk_crypt(sosemanuk_state ss, const unsigned char in, unsigned long datalen, unsigned char *out);
1051	1051	int sosemanuk_keystream(sosemanuk_state ss, unsigned char out, unsigned long outlen);
1052	1052	int sosemanuk_done(sosemanuk_state *ss);

+21

-0

src/ltc/headers/tomcrypt_custom.h less more

357	357
358	358	#ifdef LTC_FORTUNA
359	359
	360	#if !defined(LTC_FORTUNA_RESEED_RATELIMIT_STATIC) && \
	361	((defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) \|\| defined(_WIN32))
	362
	363	/* time-based rate limit of the reseeding */
	364	#define LTC_FORTUNA_RESEED_RATELIMIT_TIMED
	365
	366	#else
	367
360	368	#ifndef LTC_FORTUNA_WD
361	369	/* reseed every N calls to the read function */
362	370	#define LTC_FORTUNA_WD 10
	371	#endif
	372
	373	#ifdef LTC_FORTUNA_RESEED_RATELIMIT_TIMED
	374	/* make sure only one of
	375	* LTC_FORTUNA_RESEED_RATELIMIT_STATIC
	376	* and
	377	* LTC_FORTUNA_RESEED_RATELIMIT_TIMED
	378	* is defined.
	379	*/
	380	#undef LTC_FORTUNA_RESEED_RATELIMIT_TIMED
	381	#warning "undef'ed LTC_FORTUNA_RESEED_RATELIMIT_TIMED, looks like your architecture doesn't support it"
	382	#endif
	383
363	384	#endif
364	385
365	386	#ifndef LTC_FORTUNA_POOLS

+1

-1

src/ltc/headers/tomcrypt_hash.h less more

287	287	#define sha3_shake_process(a,b,c) sha3_process(a,b,c)
288	288	int sha3_shake_done(hash_state md, unsigned char out, unsigned long outlen);
289	289	int sha3_shake_test(void);
290		int sha3_shake_memory(int num, const unsigned char in, unsigned long inlen, unsigned char out, unsigned long *outlen);
	290	int sha3_shake_memory(int num, const unsigned char in, unsigned long inlen, unsigned char out, const unsigned long *outlen);
291	291	#endif
292	292
293	293	#ifdef LTC_KECCAK

+2

-2

src/ltc/headers/tomcrypt_mac.h less more

273	273	const unsigned char *header, unsigned long headerlen,
274	274	const unsigned char *ct, unsigned long ctlen,
275	275	unsigned char *pt,
276		unsigned char *tag, unsigned long taglen,
	276	const unsigned char *tag, unsigned long taglen,
277	277	int *stat);
278	278
279	279	int eax_test(void);

499	499	#endif
500	500	} gcm_state;
501	501
502		void gcm_mult_h(gcm_state gcm, unsigned char I);
	502	void gcm_mult_h(const gcm_state gcm, unsigned char I);
503	503
504	504	int gcm_init(gcm_state *gcm, int cipher,
505	505	const unsigned char *key, int keylen);

+1

-1

src/ltc/headers/tomcrypt_math.h less more

473	473	*/
474	474	int (rsa_me)(const unsigned char in, unsigned long inlen,
475	475	unsigned char out, unsigned long outlen, int which,
476		rsa_key *key);
	476	const rsa_key *key);
477	477
478	478	/* ---- basic math continued ---- */
479	479

+3

-3

src/ltc/headers/tomcrypt_misc.h less more

122	122
123	123	void adler32_init(adler32_state *ctx);
124	124	void adler32_update(adler32_state ctx, const unsigned char input, unsigned long length);
125		void adler32_finish(adler32_state ctx, void hash, unsigned long size);
	125	void adler32_finish(const adler32_state ctx, void hash, unsigned long size);
126	126	int adler32_test(void);
127	127	#endif
128	128

134	134
135	135	void crc32_init(crc32_state *ctx);
136	136	void crc32_update(crc32_state ctx, const unsigned char input, unsigned long length);
137		void crc32_finish(crc32_state ctx, void hash, unsigned long size);
	137	void crc32_finish(const crc32_state ctx, void hash, unsigned long size);
138	138	int crc32_test(void);
139	139	#endif
140	140

153	153	};
154	154
155	155	int padding_pad(unsigned char data, unsigned long length, unsigned long padded_length, unsigned long mode);
156		int padding_depad(unsigned char data, unsigned long length, unsigned long mode);
	156	int padding_depad(const unsigned char data, unsigned long length, unsigned long mode);
157	157
158	158	#ifdef LTC_SOURCE
159	159	/* internal helper functions */

+61

-59

src/ltc/headers/tomcrypt_pk.h less more

44	44
45	45	int pk_get_oid(int pk, oid_st *st);
46	46	int pk_oid_str_to_num(const char OID, unsigned long oid, unsigned long *oidlen);
47		int pk_oid_num_to_str(unsigned long oid, unsigned long oidlen, char OID, unsigned long *outlen);
	47	int pk_oid_num_to_str(const unsigned long oid, unsigned long oidlen, char OID, unsigned long *outlen);
48	48	#endif /* LTC_SOURCE */
49	49
50	50	/* ---- RSA ---- */

74	74
75	75	int rsa_make_key(prng_state prng, int wprng, int size, long e, rsa_key key);
76	76
77		int rsa_get_size(rsa_key *key);
	77	int rsa_get_size(const rsa_key *key);
78	78
79	79	int rsa_exptmod(const unsigned char *in, unsigned long inlen,
80	80	unsigned char out, unsigned long outlen, int which,
81		rsa_key *key);
	81	const rsa_key *key);
82	82
83	83	void rsa_free(rsa_key *key);
84	84

99	99	rsa_sign_saltlen_get_max_ex(LTC_PKCS_1_PSS, _hash_idx, _key)
100	100
101	101	/* These can be switched between PKCS #1 v2.x and PKCS #1 v1.5 paddings */
102		int rsa_encrypt_key_ex(const unsigned char *in, unsigned long inlen,
103		unsigned char out, unsigned long outlen,
104		const unsigned char *lparam, unsigned long lparamlen,
105		prng_state prng, int prng_idx, int hash_idx, int padding, rsa_key key);
106
107		int rsa_decrypt_key_ex(const unsigned char *in, unsigned long inlen,
	102	int rsa_encrypt_key_ex(const unsigned char *in, unsigned long inlen,
108	103	unsigned char out, unsigned long outlen,
109	104	const unsigned char *lparam, unsigned long lparamlen,
	105	prng_state *prng, int prng_idx,
110	106	int hash_idx, int padding,
111		int stat, rsa_key key);
	107	const rsa_key *key);
	108
	109	int rsa_decrypt_key_ex(const unsigned char *in, unsigned long inlen,
	110	unsigned char out, unsigned long outlen,
	111	const unsigned char *lparam, unsigned long lparamlen,
	112	int hash_idx, int padding,
	113	int stat, const rsa_key key);
112	114
113	115	int rsa_sign_hash_ex(const unsigned char *in, unsigned long inlen,
114	116	unsigned char out, unsigned long outlen,
115	117	int padding,
116	118	prng_state *prng, int prng_idx,
117	119	int hash_idx, unsigned long saltlen,
118		rsa_key *key);
119
120		int rsa_verify_hash_ex(const unsigned char *sig, unsigned long siglen,
121		const unsigned char *hash, unsigned long hashlen,
	120	const rsa_key *key);
	121
	122	int rsa_verify_hash_ex(const unsigned char *sig, unsigned long siglen,
	123	const unsigned char *hash, unsigned long hashlen,
122	124	int padding,
123		int hash_idx, unsigned long saltlen,
124		int stat, rsa_key key);
125
126		int rsa_sign_saltlen_get_max_ex(int padding, int hash_idx, rsa_key *key);
	125	int hash_idx, unsigned long saltlen,
	126	int stat, const rsa_key key);
	127
	128	int rsa_sign_saltlen_get_max_ex(int padding, int hash_idx, const rsa_key *key);
127	129
128	130	/* PKCS #1 import/export */
129		int rsa_export(unsigned char out, unsigned long outlen, int type, rsa_key *key);
	131	int rsa_export(unsigned char out, unsigned long outlen, int type, const rsa_key *key);
130	132	int rsa_import(const unsigned char in, unsigned long inlen, rsa_key key);
131	133
132	134	int rsa_import_x509(const unsigned char in, unsigned long inlen, rsa_key key);

212	214	void *prime;
213	215	} dh_key;
214	216
215		int dh_get_groupsize(dh_key *key);
216
217		int dh_export(unsigned char out, unsigned long outlen, int type, dh_key *key);
	217	int dh_get_groupsize(const dh_key *key);
	218
	219	int dh_export(unsigned char out, unsigned long outlen, int type, const dh_key *key);
218	220	int dh_import(const unsigned char in, unsigned long inlen, dh_key key);
219	221
220	222	int dh_set_pg(const unsigned char *p, unsigned long plen,

226	228	int dh_set_key(const unsigned char in, unsigned long inlen, int type, dh_key key);
227	229	int dh_generate_key(prng_state prng, int wprng, dh_key key);
228	230
229		int dh_shared_secret(dh_key private_key, dh_key public_key,
	231	int dh_shared_secret(const dh_key private_key, const dh_key public_key,
230	232	unsigned char out, unsigned long outlen);
231	233
232	234	void dh_free(dh_key *key);
233	235
234		int dh_export_key(void out, unsigned long outlen, int type, dh_key *key);
	236	int dh_export_key(void out, unsigned long outlen, int type, const dh_key *key);
235	237
236	238	#ifdef LTC_SOURCE
237	239	typedef struct {

242	244	extern const ltc_dh_set_type ltc_dh_sets[];
243	245
244	246	/* internal helper functions */
245		int dh_check_pubkey(dh_key *key);
	247	int dh_check_pubkey(const dh_key *key);
246	248	#endif
247	249
248	250	#endif /* LTC_MDH */

510	512
511	513	int dsa_sign_hash_raw(const unsigned char *in, unsigned long inlen,
512	514	void r, void s,
513		prng_state prng, int wprng, dsa_key key);
	515	prng_state prng, int wprng, const dsa_key key);
514	516
515	517	int dsa_sign_hash(const unsigned char *in, unsigned long inlen,
516	518	unsigned char out, unsigned long outlen,
517		prng_state prng, int wprng, dsa_key key);
	519	prng_state prng, int wprng, const dsa_key key);
518	520
519	521	int dsa_verify_hash_raw( void r, void s,
520	522	const unsigned char *hash, unsigned long hashlen,
521		int stat, dsa_key key);
522
523		int dsa_verify_hash(const unsigned char *sig, unsigned long siglen,
524		const unsigned char *hash, unsigned long hashlen,
525		int stat, dsa_key key);
	523	int stat, const dsa_key key);
	524
	525	int dsa_verify_hash(const unsigned char *sig, unsigned long siglen,
	526	const unsigned char *hash, unsigned long hashlen,
	527	int stat, const dsa_key key);
526	528
527	529	int dsa_encrypt_key(const unsigned char *in, unsigned long inlen,
528	530	unsigned char out, unsigned long outlen,
529		prng_state *prng, int wprng, int hash,
530		dsa_key *key);
	531	prng_state *prng, int wprng, int hash,
	532	const dsa_key *key);
531	533
532	534	int dsa_decrypt_key(const unsigned char *in, unsigned long inlen,
533	535	unsigned char out, unsigned long outlen,
534		dsa_key *key);
	536	const dsa_key *key);
535	537
536	538	int dsa_import(const unsigned char in, unsigned long inlen, dsa_key key);
537		int dsa_export(unsigned char out, unsigned long outlen, int type, dsa_key *key);
538		int dsa_verify_key(dsa_key key, int stat);
	539	int dsa_export(unsigned char out, unsigned long outlen, int type, const dsa_key *key);
	540	int dsa_verify_key(const dsa_key key, int stat);
539	541	#ifdef LTC_SOURCE
540	542	/* internal helper functions */
541		int dsa_int_validate_xy(dsa_key key, int stat);
542		int dsa_int_validate_pqg(dsa_key key, int stat);
543		int dsa_int_validate_primes(dsa_key key, int stat);
	543	int dsa_int_validate_xy(const dsa_key key, int stat);
	544	int dsa_int_validate_pqg(const dsa_key key, int stat);
	545	int dsa_int_validate_primes(const dsa_key key, int stat);
544	546	#endif
545	547	int dsa_shared_secret(void private_key, void base,
546		dsa_key *public_key,
	548	const dsa_key *public_key,
547	549	unsigned char out, unsigned long outlen);
548	550	#endif
549	551

661	663	extern const unsigned long der_asn1_tag_to_string_map_sz;
662	664
663	665	/* SEQUENCE */
664		int der_encode_sequence_ex(ltc_asn1_list *list, unsigned long inlen,
665		unsigned char out, unsigned long outlen, int type_of);
	666	int der_encode_sequence_ex(const ltc_asn1_list *list, unsigned long inlen,
	667	unsigned char out, unsigned long outlen, int type_of);
666	668
667	669	#define der_encode_sequence(list, inlen, out, outlen) der_encode_sequence_ex(list, inlen, out, outlen, LTC_ASN1_SEQUENCE)
668	670

693	695	#define der_decode_sequence(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, LTC_DER_SEQ_SEQUENCE \| LTC_DER_SEQ_RELAXED)
694	696	#define der_decode_sequence_strict(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, LTC_DER_SEQ_SEQUENCE \| LTC_DER_SEQ_STRICT)
695	697
696		int der_length_sequence(ltc_asn1_list *list, unsigned long inlen,
	698	int der_length_sequence(const ltc_asn1_list *list, unsigned long inlen,
697	699	unsigned long *outlen);
698	700
699	701

722	724	int der_decode_asn1_length(const unsigned char* len, unsigned long* lenlen, unsigned long* outlen);
723	725	int der_length_asn1_length(unsigned long len, unsigned long *outlen);
724	726
725		int der_length_sequence_ex(ltc_asn1_list *list, unsigned long inlen,
	727	int der_length_sequence_ex(const ltc_asn1_list *list, unsigned long inlen,
726	728	unsigned long outlen, unsigned long payloadlen);
727	729
728	730	extern const ltc_asn1_type der_asn1_tag_to_type_map[];

735	737	/* SET */
736	738	#define der_decode_set(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, LTC_DER_SEQ_SET)
737	739	#define der_length_set der_length_sequence
738		int der_encode_set(ltc_asn1_list *list, unsigned long inlen,
739		unsigned char out, unsigned long outlen);
740
741		int der_encode_setof(ltc_asn1_list *list, unsigned long inlen,
742		unsigned char out, unsigned long outlen);
	740	int der_encode_set(const ltc_asn1_list *list, unsigned long inlen,
	741	unsigned char out, unsigned long outlen);
	742
	743	int der_encode_setof(const ltc_asn1_list *list, unsigned long inlen,
	744	unsigned char out, unsigned long outlen);
743	745
744	746	/* VA list handy helpers with triplets of <type, size, data> */
745	747	int der_encode_sequence_multi(unsigned char out, unsigned long outlen, ...);

790	792	int der_length_octet_string(unsigned long noctets, unsigned long *outlen);
791	793
792	794	/* OBJECT IDENTIFIER */
793		int der_encode_object_identifier(unsigned long *words, unsigned long nwords,
794		unsigned char out, unsigned long outlen);
	795	int der_encode_object_identifier(const unsigned long *words, unsigned long nwords,
	796	unsigned char out, unsigned long outlen);
795	797	int der_decode_object_identifier(const unsigned char *in, unsigned long inlen,
796	798	unsigned long words, unsigned long outlen);
797		int der_length_object_identifier(unsigned long words, unsigned long nwords, unsigned long outlen);
	799	int der_length_object_identifier(const unsigned long words, unsigned long nwords, unsigned long outlen);
798	800	unsigned long der_object_identifier_bits(unsigned long x);
799	801
800	802	/* IA5 STRING */

873	875	off_mm; /* timezone offset minutes */
874	876	} ltc_utctime;
875	877
876		int der_encode_utctime(ltc_utctime *utctime,
877		unsigned char out, unsigned long outlen);
	878	int der_encode_utctime(const ltc_utctime *utctime,
	879	unsigned char out, unsigned long outlen);
878	880
879	881	int der_decode_utctime(const unsigned char in, unsigned long inlen,
880	882	ltc_utctime *out);
881	883
882		int der_length_utctime(ltc_utctime utctime, unsigned long outlen);
	884	int der_length_utctime(const ltc_utctime utctime, unsigned long outlen);
883	885
884	886	/* GeneralizedTime */
885	887	typedef struct {

895	897	off_mm; /* timezone offset minutes */
896	898	} ltc_generalizedtime;
897	899
898		int der_encode_generalizedtime(ltc_generalizedtime *gtime,
899		unsigned char out, unsigned long outlen);
	900	int der_encode_generalizedtime(const ltc_generalizedtime *gtime,
	901	unsigned char out, unsigned long outlen);
900	902
901	903	int der_decode_generalizedtime(const unsigned char in, unsigned long inlen,
902	904	ltc_generalizedtime *out);
903	905
904		int der_length_generalizedtime(ltc_generalizedtime gtime, unsigned long outlen);
	906	int der_length_generalizedtime(const ltc_generalizedtime gtime, unsigned long outlen);
905	907
906	908	#ifdef LTC_SOURCE
907	909	/* internal helper functions */

+6

-4

src/ltc/headers/tomcrypt_prng.h less more

42	42	pool0_len, /* length of 0'th pool */
43	43	wd;
44	44
45		ulong64 reset_cnt; /* number of times we have reset */
	45	ulong64 reset_cnt; /* number of times we have reseeded */
46	46	};
47	47	#endif
48	48

147	147	#ifdef LTC_FORTUNA
148	148	int fortuna_start(prng_state *prng);
149	149	int fortuna_add_entropy(const unsigned char in, unsigned long inlen, prng_state prng);
	150	int fortuna_add_random_event(unsigned long source, unsigned long pool, const unsigned char in, unsigned long inlen, prng_state prng);
150	151	int fortuna_ready(prng_state *prng);
151	152	unsigned long fortuna_read(unsigned char out, unsigned long outlen, prng_state prng);
152	153	int fortuna_done(prng_state *prng);
153		int fortuna_export(unsigned char out, unsigned long outlen, prng_state *prng);
154		int fortuna_import(const unsigned char in, unsigned long inlen, prng_state prng);
155		int fortuna_test(void);
	154	int fortuna_export(unsigned char out, unsigned long outlen, prng_state *prng);
	155	int fortuna_import(const unsigned char in, unsigned long inlen, prng_state prng);
	156	int fortuna_update_seed(const unsigned char in, unsigned long inlen, prng_state prng);
	157	int fortuna_test(void);
156	158	extern const struct ltc_prng_descriptor fortuna_desc;
157	159	#endif
158	160

+0

-1

src/ltc/math/multi.c less more

66	66	cur = va_arg(args, void**);
67	67	}
68	68	va_end(args);
69		return;
70	69	}
71	70
72	71	#endif

+1

-1

src/ltc/misc/adler32.c less more

78	78	ctx->s[1] = (unsigned short)s2;
79	79	}
80	80
81		void adler32_finish(adler32_state ctx, void hash, unsigned long size)
	81	void adler32_finish(const adler32_state ctx, void hash, unsigned long size)
82	82	{
83	83	unsigned char* h;
84	84

+1

-1

src/ltc/misc/copy_or_zeromem.c less more

24	24	unsigned long y;
25	25	#ifdef LTC_FAST
26	26	unsigned long z;
27		LTC_FAST_TYPE fastMask = ~0; /* initialize fastMask at all ones */
	27	LTC_FAST_TYPE fastMask = ~(LTC_FAST_TYPE)0; /* initialize fastMask at all ones */
28	28	#endif
29	29	unsigned char mask = 0xff; /* initialize mask at all ones */
30	30

+1

-1

src/ltc/misc/crc32.c less more

158	158	ctx->crc = crc;
159	159	}
160	160
161		void crc32_finish(crc32_state ctx, void hash, unsigned long size)
	161	void crc32_finish(const crc32_state ctx, void hash, unsigned long size)
162	162	{
163	163	unsigned long i;
164	164	unsigned char* h;

+7

-1

src/ltc/misc/crypt/crypt.c less more

312	312	" ChaCha20\n"
313	313	#endif
314	314	#if defined(LTC_FORTUNA)
315		" Fortuna (" NAME_VALUE(LTC_FORTUNA_POOLS) ", " NAME_VALUE(LTC_FORTUNA_WD) ")\n"
	315	" Fortuna (" NAME_VALUE(LTC_FORTUNA_POOLS) ", "
	316	#if defined(LTC_FORTUNA_RESEED_RATELIMIT_TIMED)
	317	"LTC_FORTUNA_RESEED_RATELIMIT_TIMED, "
	318	#else
	319	"LTC_FORTUNA_RESEED_RATELIMIT_STATIC, " NAME_VALUE(LTC_FORTUNA_WD)
	320	#endif
	321	")\n"
316	322	#endif
317	323	#if defined(LTC_SOBER128)
318	324	" SOBER128\n"

+1

-1

src/ltc/misc/padding/padding_depad.c less more

19	19	@param mode One of the LTC_PAD_xx flags
20	20	@return CRYPT_OK on success
21	21	*/
22		int padding_depad(unsigned char data, unsigned long length, unsigned long mode)
	22	int padding_depad(const unsigned char data, unsigned long length, unsigned long mode)
23	23	{
24	24	unsigned long padded_length, unpadded_length, n;
25	25	unsigned char pad;

+1

-1

src/ltc/misc/pk_oid_str.c less more

37	37	return CRYPT_OK;
38	38	}
39	39
40		int pk_oid_num_to_str(unsigned long oid, unsigned long oidlen, char OID, unsigned long *outlen)
	40	int pk_oid_num_to_str(const unsigned long oid, unsigned long oidlen, char OID, unsigned long *outlen)
41	41	{
42	42	int i;
43	43	unsigned long j, k;

+1

-1

src/ltc/modes/cbc/cbc_getiv.c less more

21	21	@param cbc The CBC state
22	22	@return CRYPT_OK if successful
23	23	*/
24		int cbc_getiv(unsigned char IV, unsigned long len, symmetric_CBC *cbc)
	24	int cbc_getiv(unsigned char IV, unsigned long len, const symmetric_CBC *cbc)
25	25	{
26	26	LTC_ARGCHK(IV != NULL);
27	27	LTC_ARGCHK(len != NULL);

+1

-1

src/ltc/modes/cfb/cfb_getiv.c less more

21	21	@param cfb The CFB state
22	22	@return CRYPT_OK if successful
23	23	*/
24		int cfb_getiv(unsigned char IV, unsigned long len, symmetric_CFB *cfb)
	24	int cfb_getiv(unsigned char IV, unsigned long len, const symmetric_CFB *cfb)
25	25	{
26	26	LTC_ARGCHK(IV != NULL);
27	27	LTC_ARGCHK(len != NULL);

+1

-1

src/ltc/modes/ctr/ctr_getiv.c less more

21	21	@param ctr The CTR state
22	22	@return CRYPT_OK if successful
23	23	*/
24		int ctr_getiv(unsigned char IV, unsigned long len, symmetric_CTR *ctr)
	24	int ctr_getiv(unsigned char IV, unsigned long len, const symmetric_CTR *ctr)
25	25	{
26	26	LTC_ARGCHK(IV != NULL);
27	27	LTC_ARGCHK(len != NULL);

+1

-1

src/ltc/modes/ofb/ofb_getiv.c less more

21	21	@param ofb The OFB state
22	22	@return CRYPT_OK if successful
23	23	*/
24		int ofb_getiv(unsigned char IV, unsigned long len, symmetric_OFB *ofb)
	24	int ofb_getiv(unsigned char IV, unsigned long len, const symmetric_OFB *ofb)
25	25	{
26	26	LTC_ARGCHK(IV != NULL);
27	27	LTC_ARGCHK(len != NULL);

+2

-2

src/ltc/pk/asn1/der/generalizedtime/der_encode_generalizedtime.c less more

36	36	@param outlen [in/out] The length of the DER encoding
37	37	@return CRYPT_OK if successful
38	38	*/
39		int der_encode_generalizedtime(ltc_generalizedtime *gtime,
40		unsigned char out, unsigned long outlen)
	39	int der_encode_generalizedtime(const ltc_generalizedtime *gtime,
	40	unsigned char out, unsigned long outlen)
41	41	{
42	42	unsigned long x, tmplen;
43	43	int err;

+1

-1

src/ltc/pk/asn1/der/generalizedtime/der_length_generalizedtime.c less more

21	21	@param outlen [out] The length of the DER encoding
22	22	@return CRYPT_OK if successful
23	23	*/
24		int der_length_generalizedtime(ltc_generalizedtime gtime, unsigned long outlen)
	24	int der_length_generalizedtime(const ltc_generalizedtime gtime, unsigned long outlen)
25	25	{
26	26	LTC_ARGCHK(outlen != NULL);
27	27	LTC_ARGCHK(gtime != NULL);

+2

-2

src/ltc/pk/asn1/der/object_identifier/der_encode_object_identifier.c less more

21	21	@param outlen [in/out] The max and resulting size of the OID
22	22	@return CRYPT_OK if successful
23	23	*/
24		int der_encode_object_identifier(unsigned long *words, unsigned long nwords,
25		unsigned char out, unsigned long outlen)
	24	int der_encode_object_identifier(const unsigned long *words, unsigned long nwords,
	25	unsigned char out, unsigned long outlen)
26	26	{
27	27	unsigned long i, x, y, z, t, mask, wordbuf;
28	28	int err;

+1

-1

src/ltc/pk/asn1/der/object_identifier/der_length_object_identifier.c less more

34	34	@param outlen [out] The length of the DER encoding for the given string
35	35	@return CRYPT_OK if successful
36	36	*/
37		int der_length_object_identifier(unsigned long words, unsigned long nwords, unsigned long outlen)
	37	int der_length_object_identifier(const unsigned long words, unsigned long nwords, unsigned long outlen)
38	38	{
39	39	unsigned long y, z, t, wordbuf;
40	40

+2

-2

src/ltc/pk/asn1/der/sequence/der_encode_sequence_ex.c less more

24	24	@param type_of LTC_ASN1_SEQUENCE or LTC_ASN1_SET/LTC_ASN1_SETOF
25	25	@return CRYPT_OK on success
26	26	*/
27		int der_encode_sequence_ex(ltc_asn1_list *list, unsigned long inlen,
28		unsigned char out, unsigned long outlen, int type_of)
	27	int der_encode_sequence_ex(const ltc_asn1_list *list, unsigned long inlen,
	28	unsigned char out, unsigned long outlen, int type_of)
29	29	{
30	30	int err;
31	31	ltc_asn1_type type;

+2

-2

src/ltc/pk/asn1/der/sequence/der_length_sequence.c less more

21	21	@param outlen [out] The length required in octets to store it
22	22	@return CRYPT_OK on success
23	23	*/
24		int der_length_sequence(ltc_asn1_list *list, unsigned long inlen,
	24	int der_length_sequence(const ltc_asn1_list *list, unsigned long inlen,
25	25	unsigned long *outlen)
26	26	{
27	27	return der_length_sequence_ex(list, inlen, outlen, NULL);
28	28	}
29	29
30		int der_length_sequence_ex(ltc_asn1_list *list, unsigned long inlen,
	30	int der_length_sequence_ex(const ltc_asn1_list *list, unsigned long inlen,
31	31	unsigned long outlen, unsigned long payloadlen)
32	32	{
33	33	int err;

+2

-2

src/ltc/pk/asn1/der/set/der_encode_set.c less more

45	45	@param outlen [in/out] The size of the output
46	46	@return CRYPT_OK on success
47	47	*/
48		int der_encode_set(ltc_asn1_list *list, unsigned long inlen,
49		unsigned char out, unsigned long outlen)
	48	int der_encode_set(const ltc_asn1_list *list, unsigned long inlen,
	49	unsigned char out, unsigned long outlen)
50	50	{
51	51	ltc_asn1_list *copy;
52	52	unsigned long x;

+2

-2

src/ltc/pk/asn1/der/set/der_encode_setof.c less more

55	55	@param outlen [in/out] The size of the output
56	56	@return CRYPT_OK on success
57	57	*/
58		int der_encode_setof(ltc_asn1_list *list, unsigned long inlen,
59		unsigned char out, unsigned long outlen)
	58	int der_encode_setof(const ltc_asn1_list *list, unsigned long inlen,
	59	unsigned char out, unsigned long outlen)
60	60	{
61	61	unsigned long x, y, z;
62	62	ptrdiff_t hdrlen;

+2

-2

src/ltc/pk/asn1/der/utctime/der_encode_utctime.c less more

27	27	@param outlen [in/out] The length of the DER encoding
28	28	@return CRYPT_OK if successful
29	29	*/
30		int der_encode_utctime(ltc_utctime *utctime,
31		unsigned char out, unsigned long outlen)
	30	int der_encode_utctime(const ltc_utctime *utctime,
	31	unsigned char out, unsigned long outlen)
32	32	{
33	33	unsigned long x, tmplen;
34	34	int err;

+1

-1

src/ltc/pk/asn1/der/utctime/der_length_utctime.c less more

20	20	@param outlen [out] The length of the DER encoding
21	21	@return CRYPT_OK if successful
22	22	*/
23		int der_length_utctime(ltc_utctime utctime, unsigned long outlen)
	23	int der_length_utctime(const ltc_utctime utctime, unsigned long outlen)
24	24	{
25	25	LTC_ARGCHK(outlen != NULL);
26	26	LTC_ARGCHK(utctime != NULL);

+1

-1

src/ltc/pk/asn1/x509/x509_decode_subject_public_key_info.c less more

92	92	}
93	93
94	94	if ((alg_id[0].size != oid.OIDlen) \|\|
95		XMEMCMP(oid.OID, alg_id[0].data, oid.OIDlen * sizeof(oid.OID[0]))) {
	95	XMEMCMP(oid.OID, alg_id[0].data, oid.OIDlen * sizeof(oid.OID[0])) != 0) {
96	96	/* OID mismatch */
97	97	err = CRYPT_PK_INVALID_TYPE;
98	98	goto LBL_ERR;

+1

-1

src/ltc/pk/dh/dh.c less more

223	223	@param key The DH key to get the size of
224	224	@return The group size in octets (0 on error)
225	225	*/
226		int dh_get_groupsize(dh_key *key)
	226	int dh_get_groupsize(const dh_key *key)
227	227	{
228	228	if (key == NULL) return 0;
229	229	return mp_unsigned_bin_size(key->prime);

+1

-1

src/ltc/pk/dh/dh_check_pubkey.c less more

15	15	@param key The key you wish to test
16	16	@return CRYPT_OK if successful
17	17	*/
18		int dh_check_pubkey(dh_key *key)
	18	int dh_check_pubkey(const dh_key *key)
19	19	{
20	20	void *p_minus1;
21	21	ltc_mp_digit digit;

+1

-1

src/ltc/pk/dh/dh_export.c less more

18	18	@param key The key you wish to export
19	19	@return CRYPT_OK if successful
20	20	*/
21		int dh_export(unsigned char out, unsigned long outlen, int type, dh_key *key)
	21	int dh_export(unsigned char out, unsigned long outlen, int type, const dh_key *key)
22	22	{
23	23	unsigned char flags[1];
24	24	int err;

+1

-1

src/ltc/pk/dh/dh_export_key.c less more

18	18	@param key The key you wish to export
19	19	@return CRYPT_OK if successful
20	20	*/
21		int dh_export_key(void out, unsigned long outlen, int type, dh_key *key)
	21	int dh_export_key(void out, unsigned long outlen, int type, const dh_key *key)
22	22	{
23	23	unsigned long len;
24	24	void *k;

+1

-1

src/ltc/pk/dh/dh_shared_secret.c less more

18	18	@param outlen [in/out] The max size and resulting size of the shared data.
19	19	@return CRYPT_OK if successful
20	20	*/
21		int dh_shared_secret(dh_key private_key, dh_key public_key,
	21	int dh_shared_secret(const dh_key private_key, const dh_key public_key,
22	22	unsigned char out, unsigned long outlen)
23	23	{
24	24	void *tmp;

+1

-1

src/ltc/pk/dsa/dsa_decrypt_key.c less more

25	25	*/
26	26	int dsa_decrypt_key(const unsigned char *in, unsigned long inlen,
27	27	unsigned char out, unsigned long outlen,
28		dsa_key *key)
	28	const dsa_key *key)
29	29	{
30	30	unsigned char skey, expt;
31	31	void *g_pub;

+2

-2

src/ltc/pk/dsa/dsa_encrypt_key.c less more

28	28	*/
29	29	int dsa_encrypt_key(const unsigned char *in, unsigned long inlen,
30	30	unsigned char out, unsigned long outlen,
31		prng_state *prng, int wprng, int hash,
32		dsa_key *key)
	31	prng_state *prng, int wprng, int hash,
	32	const dsa_key *key)
33	33	{
34	34	unsigned char expt, skey;
35	35	void g_pub, g_priv;

+2

-2

src/ltc/pk/dsa/dsa_export.c less more

22	22	@param key The key to export
23	23	@return CRYPT_OK if successful
24	24	*/
25		int dsa_export(unsigned char out, unsigned long outlen, int type, dsa_key *key)
	25	int dsa_export(unsigned char out, unsigned long outlen, int type, const dsa_key *key)
26	26	{
27	27	unsigned long zero=0;
28	28	int err, std;

68	68	}
69	69	} else {
70	70	if (std) {
71		unsigned long tmplen = (mp_count_bits(key->y) / 8) + 8;
	71	unsigned long tmplen = (unsigned long)(mp_count_bits(key->y) / 8) + 8;
72	72	unsigned char* tmp = XMALLOC(tmplen);
73	73	ltc_asn1_list int_list[3];
74	74

+2

-2

src/ltc/pk/dsa/dsa_generate_pqg.c less more

71	71	*/
72	72
73	73	seedbytes = group_size;
74		L = modulus_size * 8;
75		N = group_size * 8;
	74	L = (unsigned long)modulus_size * 8;
	75	N = (unsigned long)group_size * 8;
76	76
77	77	/* XXX-TODO no Lucas test */
78	78	#ifdef LTC_MPI_HAS_LUCAS_TEST

+1

-1

src/ltc/pk/dsa/dsa_shared_secret.c less more

24	24	@return CRYPT_OK if successful
25	25	*/
26	26	int dsa_shared_secret(void private_key, void base,
27		dsa_key *public_key,
	27	const dsa_key *public_key,
28	28	unsigned char out, unsigned long outlen)
29	29	{
30	30	unsigned long x;

+2

-2

src/ltc/pk/dsa/dsa_sign_hash.c less more

27	27	*/
28	28	int dsa_sign_hash_raw(const unsigned char *in, unsigned long inlen,
29	29	void r, void s,
30		prng_state prng, int wprng, dsa_key key)
	30	prng_state prng, int wprng, const dsa_key key)
31	31	{
32	32	void k, kinv, *tmp;
33	33	unsigned char *buf;

116	116	*/
117	117	int dsa_sign_hash(const unsigned char *in, unsigned long inlen,
118	118	unsigned char out, unsigned long outlen,
119		prng_state prng, int wprng, dsa_key key)
	119	prng_state prng, int wprng, const dsa_key key)
120	120	{
121	121	void r, s;
122	122	int err;

+4

-4

src/ltc/pk/dsa/dsa_verify_hash.c less more

27	27	*/
28	28	int dsa_verify_hash_raw( void r, void s,
29	29	const unsigned char *hash, unsigned long hashlen,
30		int stat, dsa_key key)
	30	int stat, const dsa_key key)
31	31	{
32	32	void w, v, u1, u2;
33	33	int err;

91	91	@param key The corresponding public DSA key
92	92	@return CRYPT_OK if successful (even if the signature is invalid)
93	93	*/
94		int dsa_verify_hash(const unsigned char *sig, unsigned long siglen,
95		const unsigned char *hash, unsigned long hashlen,
96		int stat, dsa_key key)
	94	int dsa_verify_hash(const unsigned char *sig, unsigned long siglen,
	95	const unsigned char *hash, unsigned long hashlen,
	96	int stat, const dsa_key key)
97	97	{
98	98	int err;
99	99	void r, s;

+4

-4

src/ltc/pk/dsa/dsa_verify_key.c less more

25	25	@param stat [out] Result of test, 1==valid, 0==invalid
26	26	@return CRYPT_OK if successful
27	27	*/
28		int dsa_verify_key(dsa_key key, int stat)
	28	int dsa_verify_key(const dsa_key key, int stat)
29	29	{
30	30	int err;
31	31

46	46	@param stat [out] Result of test, 1==valid, 0==invalid
47	47	@return CRYPT_OK if successful
48	48	*/
49		int dsa_int_validate_pqg(dsa_key key, int stat)
	49	int dsa_int_validate_pqg(const dsa_key key, int stat)
50	50	{
51	51	void tmp1, tmp2;
52	52	int err;

100	100	@param stat [out] Result of test, 1==valid, 0==invalid
101	101	@return CRYPT_OK if successful
102	102	*/
103		int dsa_int_validate_primes(dsa_key key, int stat)
	103	int dsa_int_validate_primes(const dsa_key key, int stat)
104	104	{
105	105	int err, res;
106	106

135	135	@param stat [out] Result of test, 1==valid, 0==invalid
136	136	@return CRYPT_OK if successful
137	137	*/
138		int dsa_int_validate_xy(dsa_key key, int stat)
	138	int dsa_int_validate_xy(const dsa_key key, int stat)
139	139	{
140	140	void *tmp;
141	141	int err;

+5

-5

src/ltc/pk/rsa/rsa_decrypt_key.c less more

28	28	@param key The corresponding private RSA key
29	29	@return CRYPT_OK if succcessul (even if invalid)
30	30	*/
31		int rsa_decrypt_key_ex(const unsigned char *in, unsigned long inlen,
32		unsigned char out, unsigned long outlen,
33		const unsigned char *lparam, unsigned long lparamlen,
34		int hash_idx, int padding,
35		int stat, rsa_key key)
	31	int rsa_decrypt_key_ex(const unsigned char *in, unsigned long inlen,
	32	unsigned char out, unsigned long outlen,
	33	const unsigned char *lparam, unsigned long lparamlen,
	34	int hash_idx, int padding,
	35	int stat, const rsa_key key)
36	36	{
37	37	unsigned long modulus_bitlen, modulus_bytelen, x;
38	38	int err;

+6

-4

src/ltc/pk/rsa/rsa_encrypt_key.c less more

29	29	@param key The RSA key to encrypt to
30	30	@return CRYPT_OK if successful
31	31	*/
32		int rsa_encrypt_key_ex(const unsigned char *in, unsigned long inlen,
33		unsigned char out, unsigned long outlen,
34		const unsigned char *lparam, unsigned long lparamlen,
35		prng_state prng, int prng_idx, int hash_idx, int padding, rsa_key key)
	32	int rsa_encrypt_key_ex(const unsigned char *in, unsigned long inlen,
	33	unsigned char out, unsigned long outlen,
	34	const unsigned char *lparam, unsigned long lparamlen,
	35	prng_state *prng, int prng_idx,
	36	int hash_idx, int padding,
	37	const rsa_key *key)
36	38	{
37	39	unsigned long modulus_bitlen, modulus_bytelen, x;
38	40	int err;

+2

-2

src/ltc/pk/rsa/rsa_export.c less more

22	22	@param key The RSA key to export
23	23	@return CRYPT_OK if successful
24	24	*/
25		int rsa_export(unsigned char out, unsigned long outlen, int type, rsa_key *key)
	25	int rsa_export(unsigned char out, unsigned long outlen, int type, const rsa_key *key)
26	26	{
27	27	unsigned long zero=0;
28	28	int err;

57	57	unsigned char* tmp = NULL;
58	58
59	59	if (type & PK_STD) {
60		tmplen = (mp_count_bits(key->N)/8)*2+8;
	60	tmplen = (unsigned long)(mp_count_bits(key->N) / 8) * 2 + 8;
61	61	tmp = XMALLOC(tmplen);
62	62	ptmplen = &tmplen;
63	63	if (tmp == NULL) {

+1

-1

src/ltc/pk/rsa/rsa_exptmod.c less more

27	27	*/
28	28	int rsa_exptmod(const unsigned char *in, unsigned long inlen,
29	29	unsigned char out, unsigned long outlen, int which,
30		rsa_key *key)
	30	const rsa_key *key)
31	31	{
32	32	void tmp, tmpa, *tmpb;
33	33	#ifdef LTC_RSA_BLINDING

+1

-1

src/ltc/pk/rsa/rsa_get_size.c less more

19	19	@param key The RSA key
20	20	@return The size in bytes of the RSA key or INT_MAX on error.
21	21	*/
22		int rsa_get_size(rsa_key *key)
	22	int rsa_get_size(const rsa_key *key)
23	23	{
24	24	int ret = INT_MAX;
25	25	LTC_ARGCHK(key != NULL);

+1

-1

src/ltc/pk/rsa/rsa_import_pkcs8.c less more

113	113
114	114	/* check alg oid */
115	115	if ((alg_seq[0].size != rsaoid.OIDlen) \|\|
116		XMEMCMP(rsaoid.OID, alg_seq[0].data, rsaoid.OIDlen * sizeof(rsaoid.OID[0]))) {
	116	XMEMCMP(rsaoid.OID, alg_seq[0].data, rsaoid.OIDlen * sizeof(rsaoid.OID[0])) != 0) {
117	117	err = CRYPT_PK_INVALID_TYPE;
118	118	goto LBL_ERR;
119	119	}

+1

-1

src/ltc/pk/rsa/rsa_sign_hash.c less more

33	33	int padding,
34	34	prng_state *prng, int prng_idx,
35	35	int hash_idx, unsigned long saltlen,
36		rsa_key *key)
	36	const rsa_key *key)
37	37	{
38	38	unsigned long modulus_bitlen, modulus_bytelen, x, y;
39	39	int err;

+1

-1

src/ltc/pk/rsa/rsa_sign_saltlen_get.c less more

21	21	@param key The RSA key
22	22	@return The maximum salt length in bytes or INT_MAX on error.
23	23	*/
24		int rsa_sign_saltlen_get_max_ex(int padding, int hash_idx, rsa_key *key)
	24	int rsa_sign_saltlen_get_max_ex(int padding, int hash_idx, const rsa_key *key)
25	25	{
26	26	int ret = INT_MAX;
27	27	LTC_ARGCHK(key != NULL);

+4

-4

src/ltc/pk/rsa/rsa_verify_hash.c less more

27	27	@param key The public RSA key corresponding to the key that performed the signature
28	28	@return CRYPT_OK on success (even if the signature is invalid)
29	29	*/
30		int rsa_verify_hash_ex(const unsigned char *sig, unsigned long siglen,
31		const unsigned char *hash, unsigned long hashlen,
	30	int rsa_verify_hash_ex(const unsigned char *sig, unsigned long siglen,
	31	const unsigned char *hash, unsigned long hashlen,
32	32	int padding,
33		int hash_idx, unsigned long saltlen,
34		int stat, rsa_key key)
	33	int hash_idx, unsigned long saltlen,
	34	int stat, const rsa_key key)
35	35	{
36	36	unsigned long modulus_bitlen, modulus_bytelen, x;
37	37	int err;

+109

-29

src/ltc/prngs/fortuna.c less more

60	60	}
61	61	}
62	62
	63	#ifdef LTC_FORTUNA_RESEED_RATELIMIT_TIMED
	64	/* get the current time in 100ms steps */
	65	static ulong64 _fortuna_current_time(void)
	66	{
	67	ulong64 cur_time;
	68	#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L
	69	struct timespec ts;
	70	clock_gettime(CLOCK_MONOTONIC, &ts);
	71	cur_time = (ulong64)(ts.tv_sec) * 1000000 + (ulong64)(ts.tv_nsec) / 1000; /* get microseconds */
	72	#elif defined(_WIN32)
	73	FILETIME CurrentTime;
	74	ULARGE_INTEGER ul;
	75	GetSystemTimeAsFileTime(&CurrentTime);
	76	ul.LowPart = CurrentTime.dwLowDateTime;
	77	ul.HighPart = CurrentTime.dwHighDateTime;
	78	cur_time = ul.QuadPart;
	79	cur_time -= CONST64(116444736000000000); /* subtract epoch in microseconds */
	80	cur_time /= 1000; /* nanoseconds -> microseconds */
	81	#endif
	82	return cur_time / 100;
	83	}
	84	#endif
	85
63	86	/* reseed the PRNG */
64	87	static int _fortuna_reseed(prng_state *prng)
65	88	{

68	91	ulong64 reset_cnt;
69	92	int err, x;
70	93
	94	#ifdef LTC_FORTUNA_RESEED_RATELIMIT_TIMED
	95	unsigned long now = _fortuna_current_time();
	96	if (now == prng->fortuna.wd)
	97	return CRYPT_OK;
	98	#else
	99	if (++prng->fortuna.wd < LTC_FORTUNA_WD)
	100	return CRYPT_OK;
	101	#endif
71	102
72	103	/* new K == LTC_SHA256(K \|\| s) where s == LTC_SHA256(P0) \|\| LTC_SHA256(P1) ... */
73	104	sha256_init(&md);

111	142
112	143	/* reset/update internals */
113	144	prng->fortuna.pool0_len = 0;
	145	#ifdef LTC_FORTUNA_RESEED_RATELIMIT_TIMED
	146	prng->fortuna.wd = now;
	147	#else
114	148	prng->fortuna.wd = 0;
	149	#endif
115	150	prng->fortuna.reset_cnt = reset_cnt;
116	151
117	152

131	166	@param prng The PRNG to import
132	167	@return CRYPT_OK if successful
133	168	*/
134		static int _fortuna_update_seed(const unsigned char in, unsigned long inlen, prng_state prng)
	169	int fortuna_update_seed(const unsigned char in, unsigned long inlen, prng_state prng)
135	170	{
136	171	int err;
137	172	unsigned char tmp[MAXBLOCKSIZE];

203	238	return CRYPT_OK;
204	239	}
205	240
	241	static int _fortuna_add(unsigned long source, unsigned long pool, const unsigned char in, unsigned long inlen, prng_state prng)
	242	{
	243	unsigned char tmp[2];
	244	int err;
	245
	246	/* ensure inlen <= 32 */
	247	if (inlen > 32) {
	248	inlen = 32;
	249	}
	250
	251	/* add s \|\| length(in) \|\| in to pool[pool_idx] */
	252	tmp[0] = (unsigned char)source;
	253	tmp[1] = (unsigned char)inlen;
	254
	255	if ((err = sha256_process(&prng->fortuna.pool[pool], tmp, 2)) != CRYPT_OK) {
	256	return err;
	257	}
	258	if ((err = sha256_process(&prng->fortuna.pool[pool], in, inlen)) != CRYPT_OK) {
	259	return err;
	260	}
	261	if (pool == 0) {
	262	prng->fortuna.pool0_len += inlen;
	263	}
	264	return CRYPT_OK; /* success */
	265	}
	266
	267	/**
	268	Add random event to the PRNG state as proposed by the original paper.
	269	@param source The source this random event comes from (0 .. 255)
	270	@param pool The pool where to add the data to (0 .. LTC_FORTUNA_POOLS)
	271	@param in The data to add
	272	@param inlen Length of the data to add
	273	@param prng PRNG state to update
	274	@return CRYPT_OK if successful
	275	*/
	276	int fortuna_add_random_event(unsigned long source, unsigned long pool, const unsigned char in, unsigned long inlen, prng_state prng)
	277	{
	278	int err;
	279
	280	LTC_ARGCHK(prng != NULL);
	281	LTC_ARGCHK(in != NULL);
	282	LTC_ARGCHK(inlen > 0);
	283	LTC_ARGCHK(source <= 255);
	284	LTC_ARGCHK(pool < LTC_FORTUNA_POOLS);
	285
	286	LTC_MUTEX_LOCK(&prng->lock);
	287
	288	err = _fortuna_add(source, pool, in, inlen, prng);
	289
	290	LTC_MUTEX_UNLOCK(&prng->lock);
	291
	292	return err;
	293	}
	294
206	295	/**
207	296	Add entropy to the PRNG state
208	297	@param in The data to add

212	301	*/
213	302	int fortuna_add_entropy(const unsigned char in, unsigned long inlen, prng_state prng)
214	303	{
215		unsigned char tmp[2];
216		int err;
	304	int err;
217	305
218	306	LTC_ARGCHK(prng != NULL);
219	307	LTC_ARGCHK(in != NULL);
220	308	LTC_ARGCHK(inlen > 0);
221	309
222		/* ensure inlen <= 32 */
223		if (inlen > 32) {
224		inlen = 32;
225		}
226
227		/* add s \|\| length(in) \|\| in to pool[pool_idx] */
228		tmp[0] = 0;
229		tmp[1] = (unsigned char)inlen;
230
231	310	LTC_MUTEX_LOCK(&prng->lock);
232		if ((err = sha256_process(&prng->fortuna.pool[prng->fortuna.pool_idx], tmp, 2)) != CRYPT_OK) {
233		goto LBL_UNLOCK;
234		}
235		if ((err = sha256_process(&prng->fortuna.pool[prng->fortuna.pool_idx], in, inlen)) != CRYPT_OK) {
236		goto LBL_UNLOCK;
237		}
238		if (prng->fortuna.pool_idx == 0) {
239		prng->fortuna.pool0_len += inlen;
240		}
241		if (++(prng->fortuna.pool_idx) == LTC_FORTUNA_POOLS) {
242		prng->fortuna.pool_idx = 0;
243		}
244		err = CRYPT_OK; /* success */
245
246		LBL_UNLOCK:
	311
	312	err = _fortuna_add(0, prng->fortuna.pool_idx, in, inlen, prng);
	313
	314	if (err == CRYPT_OK) {
	315	++(prng->fortuna.pool_idx);
	316	prng->fortuna.pool_idx %= LTC_FORTUNA_POOLS;
	317	}
	318
247	319	LTC_MUTEX_UNLOCK(&prng->lock);
	320
248	321	return err;
249	322	}
250	323

259	332	LTC_ARGCHK(prng != NULL);
260	333
261	334	LTC_MUTEX_LOCK(&prng->lock);
	335	/* make sure the reseed doesn't fail because
	336	* of the chosen rate limit */
	337	#ifdef LTC_FORTUNA_RESEED_RATELIMIT_TIMED
	338	prng->fortuna.wd = _fortuna_current_time() - 1;
	339	#else
	340	prng->fortuna.wd = LTC_FORTUNA_WD;
	341	#endif
262	342	err = _fortuna_reseed(prng);
263	343	prng->ready = (err == CRYPT_OK) ? 1 : 0;
264	344

287	367	}
288	368
289	369	/* do we have to reseed? */
290		if (++prng->fortuna.wd == LTC_FORTUNA_WD \|\| prng->fortuna.pool0_len >= 64) {
	370	if (prng->fortuna.pool0_len >= 64) {
291	371	if (_fortuna_reseed(prng) != CRYPT_OK) {
292	372	goto LBL_UNLOCK;
293	373	}

400	480	return err;
401	481	}
402	482
403		if ((err = _fortuna_update_seed(in, inlen, prng)) != CRYPT_OK) {
	483	if ((err = fortuna_update_seed(in, inlen, prng)) != CRYPT_OK) {
404	484	return err;
405	485	}
406	486

+2

-2

src/ltc/stream/sober128/sober128_stream.c less more

27	27
28	28	#define B(x,i) ((unsigned char)(((x) >> (8*i)) & 0xFF))
29	29
30		static ulong32 BYTE2WORD(unsigned char *b)
	30	static ulong32 BYTE2WORD(const unsigned char *b)
31	31	{
32	32	ulong32 t;
33	33	LOAD32L(t, b);

77	77	t = t + c->R[OFF(z,13)]; \
78	78	}
79	79
80		static ulong32 nltap(sober128_state *c)
	80	static ulong32 nltap(const sober128_state *c)
81	81	{
82	82	ulong32 t;
83	83	NLFUNC(c, 0);

+2

-2

src/ltc/stream/sosemanuk/sosemanuk.c less more

200	200	* @param keylen Length of key in bytes
201	201	* @return CRYPT_OK on success
202	202	*/
203		int sosemanuk_setup(sosemanuk_state ss, unsigned char key, unsigned long keylen)
	203	int sosemanuk_setup(sosemanuk_state ss, const unsigned char key, unsigned long keylen)
204	204	{
205	205	/*
206	206	* This key schedule is actually a truncated Serpent key schedule.

340	340	* @param ivlen Length of iv in bytes
341	341	* @return CRYPT_OK on success
342	342	*/
343		int sosemanuk_setiv(sosemanuk_state ss, unsigned char iv, unsigned long ivlen)
	343	int sosemanuk_setiv(sosemanuk_state ss, const unsigned char iv, unsigned long ivlen)
344	344	{
345	345
346	346	/*