Context Navigation

Back to Ticket #41

Ticket #41: hmac.dpatch

File hmac.dpatch, 55.6 KB (added by dragonxue, at 2010-07-04T04:45:04Z)
hmac patch

Line
1	3 patches for repository http://tahoe-lafs.org/source/pycryptopp/trunk:
2
3	Sat Jul 3 10:21:28 ÖÐ¹ú±ê×¼Ê±¼ä 2010 xueyu7452@gmail.com
4	* part1.dpatch
5
6	Sun Jul 4 12:11:06 ÖÐ¹ú±ê×¼Ê±¼ä 2010 xueyu7452@gmail.com
7	* xsalsa20.dpatch
8
9	Sun Jul 4 12:30:39 ÖÐ¹ú±ê×¼Ê±¼ä 2010 xueyu7452@gmail.com
10	* hmac.dpatch
11
12	New patches:
13
14	[part1.dpatch
15	xueyu7452@gmail.com**20100703022128
16	Ignore-this: e06eb0269745dc3eaf711891749dcbd0
17	] {
18	hunk ./pycryptopp/_pycryptoppmodule.cpp 8
19	#include "publickey/rsamodule.hpp"
20	#include "hash/sha256module.hpp"
21	#include "cipher/aesmodule.hpp"
22	+#include "cipher/xsalsamodule.hpp"
23
24	PyDoc_STRVAR(_pycryptopp__doc__,
25	"_pycryptopp -- Python wrappers for a few algorithms from Crypto++\n\
26	hunk ./pycryptopp/_pycryptoppmodule.cpp 18
27	from pycryptopp.publickey import rsa\n\
28	from pycryptopp import cipher\n\
29	from pycryptopp.cipher import aes\n\
30	+from pycryptopp.cipher import xsalsa\n\
31	from pycryptopp import hash\n\
32	from pycryptopp.hash import sha256");
33
34	hunk ./pycryptopp/_pycryptoppmodule.cpp 44
35	init_rsa(module);
36	init_sha256(module);
37	init_aes(module);
38	+ init_xsalsa(module);
39	}
40
41	hunk ./pycryptopp/cipher/__init__.py 2
42	import aes
43	+import xsalsa
44	+#import ciphercombiner
45
46	quiet_pyflakes=[aes]
47	}
48	[xsalsa20.dpatch
49	xueyu7452@gmail.com**20100704041106
50	Ignore-this: bad22988183fb1ef8d387aaf0aecd8e5
51	] {
52	addfile ./cryptopp/salsa.cpp
53	hunk ./cryptopp/salsa.cpp 1
54	+// salsa.cpp - written and placed in the public domain by Wei Dai
55	+
56	+// use "cl /EP /P /DCRYPTOPP_GENERATE_X64_MASM salsa.cpp" to generate MASM code
57	+
58	+#include "pch.h"
59	+
60	+#ifndef CRYPTOPP_GENERATE_X64_MASM
61	+
62	+#include "salsa.h"
63	+#include "misc.h"
64	+#include "argnames.h"
65	+#include "cpu.h"
66	+
67	+NAMESPACE_BEGIN(CryptoPP)
68	+
69	+void Salsa20_TestInstantiations()
70	+{
71	+ Salsa20::Encryption x;
72	+}
73	+
74	+void Salsa20_Policy::CipherSetKey(const NameValuePairs &params, const byte *key, size_t length)
75	+{
76	+ m_rounds = params.GetIntValueWithDefault(Name::Rounds(), 20);
77	+
78	+ if (!(m_rounds == 8 \|\| m_rounds == 12 \|\| m_rounds == 20))
79	+ throw InvalidRounds(Salsa20::StaticAlgorithmName(), m_rounds);
80	+
81	+ // m_state is reordered for SSE2
82	+ GetBlock<word32, LittleEndian> get1(key);
83	+ get1(m_state[13])(m_state[10])(m_state[7])(m_state[4]);
84	+ GetBlock<word32, LittleEndian> get2(key + length - 16);
85	+ get2(m_state[15])(m_state[12])(m_state[9])(m_state[6]);
86	+
87	+ // "expand 16-byte k" or "expand 32-byte k"
88	+ m_state[0] = 0x61707865;
89	+ m_state[1] = (length == 16) ? 0x3120646e : 0x3320646e;
90	+ m_state[2] = (length == 16) ? 0x79622d36 : 0x79622d32;
91	+ m_state[3] = 0x6b206574;
92	+}
93	+
94	+void Salsa20_Policy::CipherResynchronize(byte keystreamBuffer, const byte IV, size_t length)
95	+{
96	+ assert(length==8);
97	+ GetBlock<word32, LittleEndian> get(IV);
98	+ get(m_state[14])(m_state[11]);
99	+ m_state[8] = m_state[5] = 0;
100	+}
101	+
102	+void Salsa20_Policy::SeekToIteration(lword iterationCount)
103	+{
104	+ m_state[8] = (word32)iterationCount;
105	+ m_state[5] = (word32)SafeRightShift<32>(iterationCount);
106	+}
107	+
108	+#if CRYPTOPP_BOOL_X86 \|\| CRYPTOPP_BOOL_X64
109	+unsigned int Salsa20_Policy::GetAlignment() const
110	+{
111	+#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
112	+ if (HasSSE2())
113	+ return 16;
114	+ else
115	+#endif
116	+ return GetAlignmentOf<word32>();
117	+}
118	+
119	+unsigned int Salsa20_Policy::GetOptimalBlockSize() const
120	+{
121	+#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
122	+ if (HasSSE2())
123	+ return 4*BYTES_PER_ITERATION;
124	+ else
125	+#endif
126	+ return BYTES_PER_ITERATION;
127	+}
128	+#endif
129	+
130	+#ifdef CRYPTOPP_X64_MASM_AVAILABLE
131	+extern "C" {
132	+void Salsa20_OperateKeystream(byte output, const byte input, size_t iterationCount, int rounds, void *state);
133	+}
134	+#endif
135	+
136	+#pragma warning(disable: 4731) // frame pointer register 'ebp' modified by inline assembly code
137	+
138	+void Salsa20_Policy::OperateKeystream(KeystreamOperation operation, byte output, const byte input, size_t iterationCount)
139	+{
140	+#endif // #ifdef CRYPTOPP_GENERATE_X64_MASM
141	+
142	+#ifdef CRYPTOPP_X64_MASM_AVAILABLE
143	+ Salsa20_OperateKeystream(output, input, iterationCount, m_rounds, m_state.data());
144	+ return;
145	+#endif
146	+
147	+#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
148	+#ifdef CRYPTOPP_GENERATE_X64_MASM
149	+ ALIGN 8
150	+ Salsa20_OperateKeystream PROC FRAME
151	+ mov r10, [rsp + 5*8] ; state
152	+ alloc_stack(1016 + 3216 + 8)
153	+ save_xmm128 xmm6, 0200h
154	+ save_xmm128 xmm7, 0210h
155	+ save_xmm128 xmm8, 0220h
156	+ save_xmm128 xmm9, 0230h
157	+ save_xmm128 xmm10, 0240h
158	+ save_xmm128 xmm11, 0250h
159	+ save_xmm128 xmm12, 0260h
160	+ save_xmm128 xmm13, 0270h
161	+ save_xmm128 xmm14, 0280h
162	+ save_xmm128 xmm15, 0290h
163	+ .endprolog
164	+
165	+ #define REG_output rcx
166	+ #define REG_input rdx
167	+ #define REG_iterationCount r8
168	+ #define REG_state r10
169	+ #define REG_rounds e9d
170	+ #define REG_roundsLeft eax
171	+ #define REG_temp32 r11d
172	+ #define REG_temp r11
173	+ #define SSE2_WORKSPACE rsp
174	+#else
175	+ if (HasSSE2())
176	+ {
177	+ #if CRYPTOPP_BOOL_X64
178	+ #define REG_output %4
179	+ #define REG_input %1
180	+ #define REG_iterationCount %2
181	+ #define REG_state %3
182	+ #define REG_rounds %0
183	+ #define REG_roundsLeft eax
184	+ #define REG_temp32 edx
185	+ #define REG_temp rdx
186	+ #define SSE2_WORKSPACE %5
187	+
188	+ FixedSizeAlignedSecBlock<byte, 32*16> workspace;
189	+ #else
190	+ #define REG_output edi
191	+ #define REG_input eax
192	+ #define REG_iterationCount ecx
193	+ #define REG_state esi
194	+ #define REG_rounds edx
195	+ #define REG_roundsLeft ebx
196	+ #define REG_temp32 ebp
197	+ #define REG_temp ebp
198	+ #define SSE2_WORKSPACE esp + WORD_SZ
199	+ #endif
200	+
201	+ #ifdef __GNUC__
202	+ __asm__ __volatile__
203	+ (
204	+ ".intel_syntax noprefix;"
205	+ AS_PUSH_IF86( bx)
206	+ #else
207	+ void *s = m_state.data();
208	+ word32 r = m_rounds;
209	+
210	+ AS2( mov REG_iterationCount, iterationCount)
211	+ AS2( mov REG_input, input)
212	+ AS2( mov REG_output, output)
213	+ AS2( mov REG_state, s)
214	+ AS2( mov REG_rounds, r)
215	+ #endif
216	+#endif // #ifndef CRYPTOPP_GENERATE_X64_MASM
217	+
218	+ AS_PUSH_IF86( bp)
219	+ AS2( cmp REG_iterationCount, 4)
220	+ ASJ( jl, 5, f)
221	+
222	+#if CRYPTOPP_BOOL_X86
223	+ AS2( mov ebx, esp)
224	+ AS2( and esp, -16)
225	+ AS2( sub esp, 32*16)
226	+ AS1( push ebx)
227	+#endif
228	+
229	+#define SSE2_EXPAND_S(i, j) \
230	+ ASS( pshufd xmm4, xmm##i, j, j, j, j) \
231	+ AS2( movdqa [SSE2_WORKSPACE + (i4+j)16 + 256], xmm4)
232	+
233	+ AS2( movdqa xmm0, [REG_state + 0*16])
234	+ AS2( movdqa xmm1, [REG_state + 1*16])
235	+ AS2( movdqa xmm2, [REG_state + 2*16])
236	+ AS2( movdqa xmm3, [REG_state + 3*16])
237	+ SSE2_EXPAND_S(0, 0)
238	+ SSE2_EXPAND_S(0, 1)
239	+ SSE2_EXPAND_S(0, 2)
240	+ SSE2_EXPAND_S(0, 3)
241	+ SSE2_EXPAND_S(1, 0)
242	+ SSE2_EXPAND_S(1, 2)
243	+ SSE2_EXPAND_S(1, 3)
244	+ SSE2_EXPAND_S(2, 1)
245	+ SSE2_EXPAND_S(2, 2)
246	+ SSE2_EXPAND_S(2, 3)
247	+ SSE2_EXPAND_S(3, 0)
248	+ SSE2_EXPAND_S(3, 1)
249	+ SSE2_EXPAND_S(3, 2)
250	+ SSE2_EXPAND_S(3, 3)
251	+
252	+#define SSE2_EXPAND_S85(i) \
253	+ AS2( mov dword ptr [SSE2_WORKSPACE + 816 + i4 + 256], REG_roundsLeft) \
254	+ AS2( mov dword ptr [SSE2_WORKSPACE + 516 + i4 + 256], REG_temp32) \
255	+ AS2( add REG_roundsLeft, 1) \
256	+ AS2( adc REG_temp32, 0)
257	+
258	+ ASL(1)
259	+ AS2( mov REG_roundsLeft, dword ptr [REG_state + 8*4])
260	+ AS2( mov REG_temp32, dword ptr [REG_state + 5*4])
261	+ SSE2_EXPAND_S85(0)
262	+ SSE2_EXPAND_S85(1)
263	+ SSE2_EXPAND_S85(2)
264	+ SSE2_EXPAND_S85(3)
265	+ AS2( mov dword ptr [REG_state + 8*4], REG_roundsLeft)
266	+ AS2( mov dword ptr [REG_state + 5*4], REG_temp32)
267	+
268	+#define SSE2_QUARTER_ROUND(a, b, d, i) \
269	+ AS2( movdqa xmm4, xmm##d) \
270	+ AS2( paddd xmm4, xmm##a) \
271	+ AS2( movdqa xmm5, xmm4) \
272	+ AS2( pslld xmm4, i) \
273	+ AS2( psrld xmm5, 32-i) \
274	+ AS2( pxor xmm##b, xmm4) \
275	+ AS2( pxor xmm##b, xmm5)
276	+
277	+#define L01(A,B,C,D,a,b,c,d,i) AS2( movdqa xmm##A, [SSE2_WORKSPACE + d16 + i256]) /* y3 */
278	+#define L02(A,B,C,D,a,b,c,d,i) AS2( movdqa xmm##C, [SSE2_WORKSPACE + a16 + i256]) /* y0 */
279	+#define L03(A,B,C,D,a,b,c,d,i) AS2( paddd xmm##A, xmm##C) /* y0+y3 */
280	+#define L04(A,B,C,D,a,b,c,d,i) AS2( movdqa xmm##B, xmm##A)
281	+#define L05(A,B,C,D,a,b,c,d,i) AS2( pslld xmm##A, 7)
282	+#define L06(A,B,C,D,a,b,c,d,i) AS2( psrld xmm##B, 32-7)
283	+#define L07(A,B,C,D,a,b,c,d,i) AS2( pxor xmm##A, [SSE2_WORKSPACE + b16 + i256])
284	+#define L08(A,B,C,D,a,b,c,d,i) AS2( pxor xmm##A, xmm##B) /* z1 */
285	+#define L09(A,B,C,D,a,b,c,d,i) AS2( movdqa [SSE2_WORKSPACE + b*16], xmm##A)
286	+#define L10(A,B,C,D,a,b,c,d,i) AS2( movdqa xmm##B, xmm##A)
287	+#define L11(A,B,C,D,a,b,c,d,i) AS2( paddd xmm##A, xmm##C) /* z1+y0 */
288	+#define L12(A,B,C,D,a,b,c,d,i) AS2( movdqa xmm##D, xmm##A)
289	+#define L13(A,B,C,D,a,b,c,d,i) AS2( pslld xmm##A, 9)
290	+#define L14(A,B,C,D,a,b,c,d,i) AS2( psrld xmm##D, 32-9)
291	+#define L15(A,B,C,D,a,b,c,d,i) AS2( pxor xmm##A, [SSE2_WORKSPACE + c16 + i256])
292	+#define L16(A,B,C,D,a,b,c,d,i) AS2( pxor xmm##A, xmm##D) /* z2 */
293	+#define L17(A,B,C,D,a,b,c,d,i) AS2( movdqa [SSE2_WORKSPACE + c*16], xmm##A)
294	+#define L18(A,B,C,D,a,b,c,d,i) AS2( movdqa xmm##D, xmm##A)
295	+#define L19(A,B,C,D,a,b,c,d,i) AS2( paddd xmm##A, xmm##B) /* z2+z1 */
296	+#define L20(A,B,C,D,a,b,c,d,i) AS2( movdqa xmm##B, xmm##A)
297	+#define L21(A,B,C,D,a,b,c,d,i) AS2( pslld xmm##A, 13)
298	+#define L22(A,B,C,D,a,b,c,d,i) AS2( psrld xmm##B, 32-13)
299	+#define L23(A,B,C,D,a,b,c,d,i) AS2( pxor xmm##A, [SSE2_WORKSPACE + d16 + i256])
300	+#define L24(A,B,C,D,a,b,c,d,i) AS2( pxor xmm##A, xmm##B) /* z3 */
301	+#define L25(A,B,C,D,a,b,c,d,i) AS2( movdqa [SSE2_WORKSPACE + d*16], xmm##A)
302	+#define L26(A,B,C,D,a,b,c,d,i) AS2( paddd xmm##A, xmm##D) /* z3+z2 */
303	+#define L27(A,B,C,D,a,b,c,d,i) AS2( movdqa xmm##D, xmm##A)
304	+#define L28(A,B,C,D,a,b,c,d,i) AS2( pslld xmm##A, 18)
305	+#define L29(A,B,C,D,a,b,c,d,i) AS2( psrld xmm##D, 32-18)
306	+#define L30(A,B,C,D,a,b,c,d,i) AS2( pxor xmm##A, xmm##C) /* xor y0 */
307	+#define L31(A,B,C,D,a,b,c,d,i) AS2( pxor xmm##A, xmm##D) /* z0 */
308	+#define L32(A,B,C,D,a,b,c,d,i) AS2( movdqa [SSE2_WORKSPACE + a*16], xmm##A)
309	+
310	+#define SSE2_QUARTER_ROUND_X8(i, a, b, c, d, e, f, g, h) \
311	+ L01(0,1,2,3, a,b,c,d, i) L01(4,5,6,7, e,f,g,h, i) \
312	+ L02(0,1,2,3, a,b,c,d, i) L02(4,5,6,7, e,f,g,h, i) \
313	+ L03(0,1,2,3, a,b,c,d, i) L03(4,5,6,7, e,f,g,h, i) \
314	+ L04(0,1,2,3, a,b,c,d, i) L04(4,5,6,7, e,f,g,h, i) \
315	+ L05(0,1,2,3, a,b,c,d, i) L05(4,5,6,7, e,f,g,h, i) \
316	+ L06(0,1,2,3, a,b,c,d, i) L06(4,5,6,7, e,f,g,h, i) \
317	+ L07(0,1,2,3, a,b,c,d, i) L07(4,5,6,7, e,f,g,h, i) \
318	+ L08(0,1,2,3, a,b,c,d, i) L08(4,5,6,7, e,f,g,h, i) \
319	+ L09(0,1,2,3, a,b,c,d, i) L09(4,5,6,7, e,f,g,h, i) \
320	+ L10(0,1,2,3, a,b,c,d, i) L10(4,5,6,7, e,f,g,h, i) \
321	+ L11(0,1,2,3, a,b,c,d, i) L11(4,5,6,7, e,f,g,h, i) \
322	+ L12(0,1,2,3, a,b,c,d, i) L12(4,5,6,7, e,f,g,h, i) \
323	+ L13(0,1,2,3, a,b,c,d, i) L13(4,5,6,7, e,f,g,h, i) \
324	+ L14(0,1,2,3, a,b,c,d, i) L14(4,5,6,7, e,f,g,h, i) \
325	+ L15(0,1,2,3, a,b,c,d, i) L15(4,5,6,7, e,f,g,h, i) \
326	+ L16(0,1,2,3, a,b,c,d, i) L16(4,5,6,7, e,f,g,h, i) \
327	+ L17(0,1,2,3, a,b,c,d, i) L17(4,5,6,7, e,f,g,h, i) \
328	+ L18(0,1,2,3, a,b,c,d, i) L18(4,5,6,7, e,f,g,h, i) \
329	+ L19(0,1,2,3, a,b,c,d, i) L19(4,5,6,7, e,f,g,h, i) \
330	+ L20(0,1,2,3, a,b,c,d, i) L20(4,5,6,7, e,f,g,h, i) \
331	+ L21(0,1,2,3, a,b,c,d, i) L21(4,5,6,7, e,f,g,h, i) \
332	+ L22(0,1,2,3, a,b,c,d, i) L22(4,5,6,7, e,f,g,h, i) \
333	+ L23(0,1,2,3, a,b,c,d, i) L23(4,5,6,7, e,f,g,h, i) \
334	+ L24(0,1,2,3, a,b,c,d, i) L24(4,5,6,7, e,f,g,h, i) \
335	+ L25(0,1,2,3, a,b,c,d, i) L25(4,5,6,7, e,f,g,h, i) \
336	+ L26(0,1,2,3, a,b,c,d, i) L26(4,5,6,7, e,f,g,h, i) \
337	+ L27(0,1,2,3, a,b,c,d, i) L27(4,5,6,7, e,f,g,h, i) \
338	+ L28(0,1,2,3, a,b,c,d, i) L28(4,5,6,7, e,f,g,h, i) \
339	+ L29(0,1,2,3, a,b,c,d, i) L29(4,5,6,7, e,f,g,h, i) \
340	+ L30(0,1,2,3, a,b,c,d, i) L30(4,5,6,7, e,f,g,h, i) \
341	+ L31(0,1,2,3, a,b,c,d, i) L31(4,5,6,7, e,f,g,h, i) \
342	+ L32(0,1,2,3, a,b,c,d, i) L32(4,5,6,7, e,f,g,h, i)
343	+
344	+#define SSE2_QUARTER_ROUND_X16(i, a, b, c, d, e, f, g, h, A, B, C, D, E, F, G, H) \
345	+ L01(0,1,2,3, a,b,c,d, i) L01(4,5,6,7, e,f,g,h, i) L01(8,9,10,11, A,B,C,D, i) L01(12,13,14,15, E,F,G,H, i) \
346	+ L02(0,1,2,3, a,b,c,d, i) L02(4,5,6,7, e,f,g,h, i) L02(8,9,10,11, A,B,C,D, i) L02(12,13,14,15, E,F,G,H, i) \
347	+ L03(0,1,2,3, a,b,c,d, i) L03(4,5,6,7, e,f,g,h, i) L03(8,9,10,11, A,B,C,D, i) L03(12,13,14,15, E,F,G,H, i) \
348	+ L04(0,1,2,3, a,b,c,d, i) L04(4,5,6,7, e,f,g,h, i) L04(8,9,10,11, A,B,C,D, i) L04(12,13,14,15, E,F,G,H, i) \
349	+ L05(0,1,2,3, a,b,c,d, i) L05(4,5,6,7, e,f,g,h, i) L05(8,9,10,11, A,B,C,D, i) L05(12,13,14,15, E,F,G,H, i) \
350	+ L06(0,1,2,3, a,b,c,d, i) L06(4,5,6,7, e,f,g,h, i) L06(8,9,10,11, A,B,C,D, i) L06(12,13,14,15, E,F,G,H, i) \
351	+ L07(0,1,2,3, a,b,c,d, i) L07(4,5,6,7, e,f,g,h, i) L07(8,9,10,11, A,B,C,D, i) L07(12,13,14,15, E,F,G,H, i) \
352	+ L08(0,1,2,3, a,b,c,d, i) L08(4,5,6,7, e,f,g,h, i) L08(8,9,10,11, A,B,C,D, i) L08(12,13,14,15, E,F,G,H, i) \
353	+ L09(0,1,2,3, a,b,c,d, i) L09(4,5,6,7, e,f,g,h, i) L09(8,9,10,11, A,B,C,D, i) L09(12,13,14,15, E,F,G,H, i) \
354	+ L10(0,1,2,3, a,b,c,d, i) L10(4,5,6,7, e,f,g,h, i) L10(8,9,10,11, A,B,C,D, i) L10(12,13,14,15, E,F,G,H, i) \
355	+ L11(0,1,2,3, a,b,c,d, i) L11(4,5,6,7, e,f,g,h, i) L11(8,9,10,11, A,B,C,D, i) L11(12,13,14,15, E,F,G,H, i) \
356	+ L12(0,1,2,3, a,b,c,d, i) L12(4,5,6,7, e,f,g,h, i) L12(8,9,10,11, A,B,C,D, i) L12(12,13,14,15, E,F,G,H, i) \
357	+ L13(0,1,2,3, a,b,c,d, i) L13(4,5,6,7, e,f,g,h, i) L13(8,9,10,11, A,B,C,D, i) L13(12,13,14,15, E,F,G,H, i) \
358	+ L14(0,1,2,3, a,b,c,d, i) L14(4,5,6,7, e,f,g,h, i) L14(8,9,10,11, A,B,C,D, i) L14(12,13,14,15, E,F,G,H, i) \
359	+ L15(0,1,2,3, a,b,c,d, i) L15(4,5,6,7, e,f,g,h, i) L15(8,9,10,11, A,B,C,D, i) L15(12,13,14,15, E,F,G,H, i) \
360	+ L16(0,1,2,3, a,b,c,d, i) L16(4,5,6,7, e,f,g,h, i) L16(8,9,10,11, A,B,C,D, i) L16(12,13,14,15, E,F,G,H, i) \
361	+ L17(0,1,2,3, a,b,c,d, i) L17(4,5,6,7, e,f,g,h, i) L17(8,9,10,11, A,B,C,D, i) L17(12,13,14,15, E,F,G,H, i) \
362	+ L18(0,1,2,3, a,b,c,d, i) L18(4,5,6,7, e,f,g,h, i) L18(8,9,10,11, A,B,C,D, i) L18(12,13,14,15, E,F,G,H, i) \
363	+ L19(0,1,2,3, a,b,c,d, i) L19(4,5,6,7, e,f,g,h, i) L19(8,9,10,11, A,B,C,D, i) L19(12,13,14,15, E,F,G,H, i) \
364	+ L20(0,1,2,3, a,b,c,d, i) L20(4,5,6,7, e,f,g,h, i) L20(8,9,10,11, A,B,C,D, i) L20(12,13,14,15, E,F,G,H, i) \
365	+ L21(0,1,2,3, a,b,c,d, i) L21(4,5,6,7, e,f,g,h, i) L21(8,9,10,11, A,B,C,D, i) L21(12,13,14,15, E,F,G,H, i) \
366	+ L22(0,1,2,3, a,b,c,d, i) L22(4,5,6,7, e,f,g,h, i) L22(8,9,10,11, A,B,C,D, i) L22(12,13,14,15, E,F,G,H, i) \
367	+ L23(0,1,2,3, a,b,c,d, i) L23(4,5,6,7, e,f,g,h, i) L23(8,9,10,11, A,B,C,D, i) L23(12,13,14,15, E,F,G,H, i) \
368	+ L24(0,1,2,3, a,b,c,d, i) L24(4,5,6,7, e,f,g,h, i) L24(8,9,10,11, A,B,C,D, i) L24(12,13,14,15, E,F,G,H, i) \
369	+ L25(0,1,2,3, a,b,c,d, i) L25(4,5,6,7, e,f,g,h, i) L25(8,9,10,11, A,B,C,D, i) L25(12,13,14,15, E,F,G,H, i) \
370	+ L26(0,1,2,3, a,b,c,d, i) L26(4,5,6,7, e,f,g,h, i) L26(8,9,10,11, A,B,C,D, i) L26(12,13,14,15, E,F,G,H, i) \
371	+ L27(0,1,2,3, a,b,c,d, i) L27(4,5,6,7, e,f,g,h, i) L27(8,9,10,11, A,B,C,D, i) L27(12,13,14,15, E,F,G,H, i) \
372	+ L28(0,1,2,3, a,b,c,d, i) L28(4,5,6,7, e,f,g,h, i) L28(8,9,10,11, A,B,C,D, i) L28(12,13,14,15, E,F,G,H, i) \
373	+ L29(0,1,2,3, a,b,c,d, i) L29(4,5,6,7, e,f,g,h, i) L29(8,9,10,11, A,B,C,D, i) L29(12,13,14,15, E,F,G,H, i) \
374	+ L30(0,1,2,3, a,b,c,d, i) L30(4,5,6,7, e,f,g,h, i) L30(8,9,10,11, A,B,C,D, i) L30(12,13,14,15, E,F,G,H, i) \
375	+ L31(0,1,2,3, a,b,c,d, i) L31(4,5,6,7, e,f,g,h, i) L31(8,9,10,11, A,B,C,D, i) L31(12,13,14,15, E,F,G,H, i) \
376	+ L32(0,1,2,3, a,b,c,d, i) L32(4,5,6,7, e,f,g,h, i) L32(8,9,10,11, A,B,C,D, i) L32(12,13,14,15, E,F,G,H, i)
377	+
378	+#if CRYPTOPP_BOOL_X64
379	+ SSE2_QUARTER_ROUND_X16(1, 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15)
380	+#else
381	+ SSE2_QUARTER_ROUND_X8(1, 2, 6, 10, 14, 3, 7, 11, 15)
382	+ SSE2_QUARTER_ROUND_X8(1, 0, 4, 8, 12, 1, 5, 9, 13)
383	+#endif
384	+ AS2( mov REG_roundsLeft, REG_rounds)
385	+ ASJ( jmp, 2, f)
386	+
387	+ ASL(SSE2_Salsa_Output)
388	+ AS2( movdqa xmm0, xmm4)
389	+ AS2( punpckldq xmm4, xmm5)
390	+ AS2( movdqa xmm1, xmm6)
391	+ AS2( punpckldq xmm6, xmm7)
392	+ AS2( movdqa xmm2, xmm4)
393	+ AS2( punpcklqdq xmm4, xmm6) // e
394	+ AS2( punpckhqdq xmm2, xmm6) // f
395	+ AS2( punpckhdq xmm0, xmm5)
396	+ AS2( punpckhdq xmm1, xmm7)
397	+ AS2( movdqa xmm6, xmm0)
398	+ AS2( punpcklqdq xmm0, xmm1) // g
399	+ AS2( punpckhqdq xmm6, xmm1) // h
400	+ AS_XMM_OUTPUT4(SSE2_Salsa_Output_A, REG_input, REG_output, 4, 2, 0, 6, 1, 0, 4, 8, 12, 1)
401	+ AS1( ret)
402	+
403	+ ASL(6)
404	+#if CRYPTOPP_BOOL_X64
405	+ SSE2_QUARTER_ROUND_X16(0, 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15)
406	+ ASL(2)
407	+ SSE2_QUARTER_ROUND_X16(0, 0, 13, 10, 7, 1, 14, 11, 4, 2, 15, 8, 5, 3, 12, 9, 6)
408	+#else
409	+ SSE2_QUARTER_ROUND_X8(0, 2, 6, 10, 14, 3, 7, 11, 15)
410	+ SSE2_QUARTER_ROUND_X8(0, 0, 4, 8, 12, 1, 5, 9, 13)
411	+ ASL(2)
412	+ SSE2_QUARTER_ROUND_X8(0, 2, 15, 8, 5, 3, 12, 9, 6)
413	+ SSE2_QUARTER_ROUND_X8(0, 0, 13, 10, 7, 1, 14, 11, 4)
414	+#endif
415	+ AS2( sub REG_roundsLeft, 2)
416	+ ASJ( jnz, 6, b)
417	+
418	+#define SSE2_OUTPUT_4(a, b, c, d) \
419	+ AS2( movdqa xmm4, [SSE2_WORKSPACE + a*16 + 256])\
420	+ AS2( paddd xmm4, [SSE2_WORKSPACE + a*16])\
421	+ AS2( movdqa xmm5, [SSE2_WORKSPACE + b*16 + 256])\
422	+ AS2( paddd xmm5, [SSE2_WORKSPACE + b*16])\
423	+ AS2( movdqa xmm6, [SSE2_WORKSPACE + c*16 + 256])\
424	+ AS2( paddd xmm6, [SSE2_WORKSPACE + c*16])\
425	+ AS2( movdqa xmm7, [SSE2_WORKSPACE + d*16 + 256])\
426	+ AS2( paddd xmm7, [SSE2_WORKSPACE + d*16])\
427	+ ASC( call, SSE2_Salsa_Output)
428	+
429	+ SSE2_OUTPUT_4(0, 13, 10, 7)
430	+ SSE2_OUTPUT_4(4, 1, 14, 11)
431	+ SSE2_OUTPUT_4(8, 5, 2, 15)
432	+ SSE2_OUTPUT_4(12, 9, 6, 3)
433	+ AS2( test REG_input, REG_input)
434	+ ASJ( jz, 9, f)
435	+ AS2( add REG_input, 12*16)
436	+ ASL(9)
437	+ AS2( add REG_output, 12*16)
438	+ AS2( sub REG_iterationCount, 4)
439	+ AS2( cmp REG_iterationCount, 4)
440	+ ASJ( jge, 1, b)
441	+ AS_POP_IF86( sp)
442	+
443	+ ASL(5)
444	+ AS2( sub REG_iterationCount, 1)
445	+ ASJ( jl, 4, f)
446	+ AS2( movdqa xmm0, [REG_state + 0*16])
447	+ AS2( movdqa xmm1, [REG_state + 1*16])
448	+ AS2( movdqa xmm2, [REG_state + 2*16])
449	+ AS2( movdqa xmm3, [REG_state + 3*16])
450	+ AS2( mov REG_roundsLeft, REG_rounds)
451	+
452	+ ASL(0)
453	+ SSE2_QUARTER_ROUND(0, 1, 3, 7)
454	+ SSE2_QUARTER_ROUND(1, 2, 0, 9)
455	+ SSE2_QUARTER_ROUND(2, 3, 1, 13)
456	+ SSE2_QUARTER_ROUND(3, 0, 2, 18)
457	+ ASS( pshufd xmm1, xmm1, 2, 1, 0, 3)
458	+ ASS( pshufd xmm2, xmm2, 1, 0, 3, 2)
459	+ ASS( pshufd xmm3, xmm3, 0, 3, 2, 1)
460	+ SSE2_QUARTER_ROUND(0, 3, 1, 7)
461	+ SSE2_QUARTER_ROUND(3, 2, 0, 9)
462	+ SSE2_QUARTER_ROUND(2, 1, 3, 13)
463	+ SSE2_QUARTER_ROUND(1, 0, 2, 18)
464	+ ASS( pshufd xmm1, xmm1, 0, 3, 2, 1)
465	+ ASS( pshufd xmm2, xmm2, 1, 0, 3, 2)
466	+ ASS( pshufd xmm3, xmm3, 2, 1, 0, 3)
467	+ AS2( sub REG_roundsLeft, 2)
468	+ ASJ( jnz, 0, b)
469	+
470	+ AS2( paddd xmm0, [REG_state + 0*16])
471	+ AS2( paddd xmm1, [REG_state + 1*16])
472	+ AS2( paddd xmm2, [REG_state + 2*16])
473	+ AS2( paddd xmm3, [REG_state + 3*16])
474	+
475	+ AS2( add dword ptr [REG_state + 8*4], 1)
476	+ AS2( adc dword ptr [REG_state + 5*4], 0)
477	+
478	+ AS2( pcmpeqb xmm6, xmm6) // all ones
479	+ AS2( psrlq xmm6, 32) // lo32 mask
480	+ ASS( pshufd xmm7, xmm6, 0, 1, 2, 3) // hi32 mask
481	+ AS2( movdqa xmm4, xmm0)
482	+ AS2( movdqa xmm5, xmm3)
483	+ AS2( pand xmm0, xmm7)
484	+ AS2( pand xmm4, xmm6)
485	+ AS2( pand xmm3, xmm6)
486	+ AS2( pand xmm5, xmm7)
487	+ AS2( por xmm4, xmm5) // 0,13,2,15
488	+ AS2( movdqa xmm5, xmm1)
489	+ AS2( pand xmm1, xmm7)
490	+ AS2( pand xmm5, xmm6)
491	+ AS2( por xmm0, xmm5) // 4,1,6,3
492	+ AS2( pand xmm6, xmm2)
493	+ AS2( pand xmm2, xmm7)
494	+ AS2( por xmm1, xmm6) // 8,5,10,7
495	+ AS2( por xmm2, xmm3) // 12,9,14,11
496	+
497	+ AS2( movdqa xmm5, xmm4)
498	+ AS2( movdqa xmm6, xmm0)
499	+ AS3( shufpd xmm4, xmm1, 2) // 0,13,10,7
500	+ AS3( shufpd xmm0, xmm2, 2) // 4,1,14,11
501	+ AS3( shufpd xmm1, xmm5, 2) // 8,5,2,15
502	+ AS3( shufpd xmm2, xmm6, 2) // 12,9,6,3
503	+
504	+ // output keystream
505	+ AS_XMM_OUTPUT4(SSE2_Salsa_Output_B, REG_input, REG_output, 4, 0, 1, 2, 3, 0, 1, 2, 3, 4)
506	+ ASJ( jmp, 5, b)
507	+ ASL(4)
508	+
509	+ AS_POP_IF86( bp)
510	+#ifdef __GNUC__
511	+ AS_POP_IF86( bx)
512	+ ".att_syntax prefix;"
513	+ :
514	+ #if CRYPTOPP_BOOL_X64
515	+ : "r" (m_rounds), "r" (input), "r" (iterationCount), "r" (m_state.data()), "r" (output), "r" (workspace.m_ptr)
516	+ : "%eax", "%edx", "memory", "cc", "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7", "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15"
517	+ #else
518	+ : "d" (m_rounds), "a" (input), "c" (iterationCount), "S" (m_state.data()), "D" (output)
519	+ : "memory", "cc"
520	+ #endif
521	+ );
522	+#endif
523	+#ifdef CRYPTOPP_GENERATE_X64_MASM
524	+ movdqa xmm6, [rsp + 0200h]
525	+ movdqa xmm7, [rsp + 0210h]
526	+ movdqa xmm8, [rsp + 0220h]
527	+ movdqa xmm9, [rsp + 0230h]
528	+ movdqa xmm10, [rsp + 0240h]
529	+ movdqa xmm11, [rsp + 0250h]
530	+ movdqa xmm12, [rsp + 0260h]
531	+ movdqa xmm13, [rsp + 0270h]
532	+ movdqa xmm14, [rsp + 0280h]
533	+ movdqa xmm15, [rsp + 0290h]
534	+ add rsp, 1016 + 3216 + 8
535	+ ret
536	+Salsa20_OperateKeystream ENDP
537	+#else
538	+ }
539	+ else
540	+#endif
541	+#endif
542	+#ifndef CRYPTOPP_GENERATE_X64_MASM
543	+ {
544	+ word32 x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
545	+
546	+ while (iterationCount--)
547	+ {
548	+ x0 = m_state[0]; x1 = m_state[1]; x2 = m_state[2]; x3 = m_state[3];
549	+ x4 = m_state[4]; x5 = m_state[5]; x6 = m_state[6]; x7 = m_state[7];
550	+ x8 = m_state[8]; x9 = m_state[9]; x10 = m_state[10]; x11 = m_state[11];
551	+ x12 = m_state[12]; x13 = m_state[13]; x14 = m_state[14]; x15 = m_state[15];
552	+
553	+ for (int i=m_rounds; i>0; i-=2)
554	+ {
555	+ #define QUARTER_ROUND(a, b, c, d) \
556	+ b = b ^ rotlFixed(a + d, 7); \
557	+ c = c ^ rotlFixed(b + a, 9); \
558	+ d = d ^ rotlFixed(c + b, 13); \
559	+ a = a ^ rotlFixed(d + c, 18);
560	+
561	+ QUARTER_ROUND(x0, x4, x8, x12)
562	+ QUARTER_ROUND(x1, x5, x9, x13)
563	+ QUARTER_ROUND(x2, x6, x10, x14)
564	+ QUARTER_ROUND(x3, x7, x11, x15)
565	+
566	+ QUARTER_ROUND(x0, x13, x10, x7)
567	+ QUARTER_ROUND(x1, x14, x11, x4)
568	+ QUARTER_ROUND(x2, x15, x8, x5)
569	+ QUARTER_ROUND(x3, x12, x9, x6)
570	+ }
571	+
572	+ #define SALSA_OUTPUT(x) {\
573	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 0, x0 + m_state[0]);\
574	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 1, x13 + m_state[13]);\
575	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 2, x10 + m_state[10]);\
576	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 3, x7 + m_state[7]);\
577	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 4, x4 + m_state[4]);\
578	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 5, x1 + m_state[1]);\
579	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 6, x14 + m_state[14]);\
580	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 7, x11 + m_state[11]);\
581	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 8, x8 + m_state[8]);\
582	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 9, x5 + m_state[5]);\
583	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 10, x2 + m_state[2]);\
584	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 11, x15 + m_state[15]);\
585	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 12, x12 + m_state[12]);\
586	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 13, x9 + m_state[9]);\
587	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 14, x6 + m_state[6]);\
588	+ CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 15, x3 + m_state[3]);}
589	+
590	+#ifndef CRYPTOPP_DOXYGEN_PROCESSING
591	+ CRYPTOPP_KEYSTREAM_OUTPUT_SWITCH(SALSA_OUTPUT, BYTES_PER_ITERATION);
592	+#endif
593	+
594	+ if (++m_state[8] == 0)
595	+ ++m_state[5];
596	+ }
597	+ }
598	+} // see comment above if an internal compiler error occurs here
599	+
600	+void XSalsa20_Policy::CipherSetKey(const NameValuePairs &params, const byte *key, size_t length)
601	+{
602	+ m_rounds = params.GetIntValueWithDefault(Name::Rounds(), 20);
603	+
604	+ if (!(m_rounds == 8 \|\| m_rounds == 12 \|\| m_rounds == 20))
605	+ throw InvalidRounds(XSalsa20::StaticAlgorithmName(), m_rounds);
606	+
607	+ GetUserKey(LITTLE_ENDIAN_ORDER, m_key.begin(), m_key.size(), key, length);
608	+ if (length == 16)
609	+ memcpy(m_key.begin()+4, m_key.begin(), 16);
610	+
611	+ // "expand 32-byte k"
612	+ m_state[0] = 0x61707865;
613	+ m_state[1] = 0x3320646e;
614	+ m_state[2] = 0x79622d32;
615	+ m_state[3] = 0x6b206574;
616	+}
617	+
618	+void XSalsa20_Policy::CipherResynchronize(byte keystreamBuffer, const byte IV, size_t length)
619	+{
620	+ assert(length==24);
621	+
622	+ word32 x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
623	+
624	+ GetBlock<word32, LittleEndian> get(IV);
625	+ get(x14)(x11)(x8)(x5)(m_state[14])(m_state[11]);
626	+
627	+ x13 = m_key[0]; x10 = m_key[1]; x7 = m_key[2]; x4 = m_key[3];
628	+ x15 = m_key[4]; x12 = m_key[5]; x9 = m_key[6]; x6 = m_key[7];
629	+ x0 = m_state[0]; x1 = m_state[1]; x2 = m_state[2]; x3 = m_state[3];
630	+
631	+ for (int i=m_rounds; i>0; i-=2)
632	+ {
633	+ QUARTER_ROUND(x0, x4, x8, x12)
634	+ QUARTER_ROUND(x1, x5, x9, x13)
635	+ QUARTER_ROUND(x2, x6, x10, x14)
636	+ QUARTER_ROUND(x3, x7, x11, x15)
637	+
638	+ QUARTER_ROUND(x0, x13, x10, x7)
639	+ QUARTER_ROUND(x1, x14, x11, x4)
640	+ QUARTER_ROUND(x2, x15, x8, x5)
641	+ QUARTER_ROUND(x3, x12, x9, x6)
642	+ }
643	+
644	+ m_state[13] = x0; m_state[10] = x1; m_state[7] = x2; m_state[4] = x3;
645	+ m_state[15] = x14; m_state[12] = x11; m_state[9] = x8; m_state[6] = x5;
646	+ m_state[8] = m_state[5] = 0;
647	+}
648	+
649	+NAMESPACE_END
650	+
651	+#endif // #ifndef CRYPTOPP_GENERATE_X64_MASM
652	addfile ./cryptopp/salsa.h
653	hunk ./cryptopp/salsa.h 1
654	+// salsa.h - written and placed in the public domain by Wei Dai
655	+
656	+#ifndef CRYPTOPP_SALSA_H
657	+#define CRYPTOPP_SALSA_H
658	+
659	+#include "strciphr.h"
660	+
661	+NAMESPACE_BEGIN(CryptoPP)
662	+
663	+//! _
664	+struct Salsa20_Info : public VariableKeyLength<32, 16, 32, 16, SimpleKeyingInterface::UNIQUE_IV, 8>
665	+{
666	+ static const char *StaticAlgorithmName() {return "Salsa20";}
667	+};
668	+
669	+class CRYPTOPP_NO_VTABLE Salsa20_Policy : public AdditiveCipherConcretePolicy<word32, 16>
670	+{
671	+protected:
672	+ void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length);
673	+ void OperateKeystream(KeystreamOperation operation, byte output, const byte input, size_t iterationCount);
674	+ void CipherResynchronize(byte keystreamBuffer, const byte IV, size_t length);
675	+ bool CipherIsRandomAccess() const {return true;}
676	+ void SeekToIteration(lword iterationCount);
677	+#if CRYPTOPP_BOOL_X86 \|\| CRYPTOPP_BOOL_X64
678	+ unsigned int GetAlignment() const;
679	+ unsigned int GetOptimalBlockSize() const;
680	+#endif
681	+
682	+ FixedSizeAlignedSecBlock<word32, 16> m_state;
683	+ int m_rounds;
684	+};
685	+
686	+/// <a href="http://www.cryptolounge.org/wiki/Salsa20">Salsa20</a>, variable rounds: 8, 12 or 20 (default 20)
687	+struct Salsa20 : public Salsa20_Info, public SymmetricCipherDocumentation
688	+{
689	+ typedef SymmetricCipherFinal<ConcretePolicyHolder<Salsa20_Policy, AdditiveCipherTemplate<> >, Salsa20_Info> Encryption;
690	+ typedef Encryption Decryption;
691	+};
692	+
693	+//! _
694	+struct XSalsa20_Info : public FixedKeyLength<32, SimpleKeyingInterface::UNIQUE_IV, 24>
695	+{
696	+ static const char *StaticAlgorithmName() {return "XSalsa20";}
697	+};
698	+
699	+class CRYPTOPP_NO_VTABLE XSalsa20_Policy : public Salsa20_Policy
700	+{
701	+public:
702	+ void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length);
703	+ void CipherResynchronize(byte keystreamBuffer, const byte IV, size_t length);
704	+
705	+protected:
706	+ FixedSizeSecBlock<word32, 8> m_key;
707	+};
708	+
709	+/// <a href="http://www.cryptolounge.org/wiki/XSalsa20">XSalsa20</a>, variable rounds: 8, 12 or 20 (default 20)
710	+struct XSalsa20 : public XSalsa20_Info, public SymmetricCipherDocumentation
711	+{
712	+ typedef SymmetricCipherFinal<ConcretePolicyHolder<XSalsa20_Policy, AdditiveCipherTemplate<> >, XSalsa20_Info> Encryption;
713	+ typedef Encryption Decryption;
714	+};
715	+
716	+NAMESPACE_END
717	+
718	+#endif
719	addfile ./pycryptopp/cipher/xsalsa.py
720	hunk ./pycryptopp/cipher/xsalsa.py 1
721	+#!/usr/bin/env python
722	+from pycryptopp import _import_my_names
723	+
724	+_import_my_names(globals(), "xsalsa_")
725	+
726	+del _import_my_names
727	+
728	addfile ./pycryptopp/cipher/xsalsamodule.cpp
729	hunk ./pycryptopp/cipher/xsalsamodule.cpp 1
730	+/**
731	+ * xsalsamodule.cpp -- Python wrappers around Crypto++'s salsa
732	+ */
733	+
734	+#define PY_SSIZE_T_CLEAN
735	+#include <Python.h>
736	+#if (PY_VERSION_HEX < 0x02050000)
737	+typedef int Py_ssize_t;
738	+#endif
739	+
740	+#include "xsalsamodule.hpp"
741	+
742	+#ifdef USE_NAME_CRYPTO_PLUS_PLUS
743	+//#include <crypto++/modes.h>
744	+#include <crypto++/salsa.h>
745	+#else
746	+//#include <cryptopp/modes.h>
747	+#include <cryptopp/salsa.h>
748	+#endif
749	+
750	+static const char* const xsalsa__doc__ = "_xsalsa cipher";
751	+
752	+static PyObject *xsalsa_error;
753	+
754	+typedef struct {
755	+ PyObject_HEAD
756	+
757	+ /* internal */
758	+// CryptoPP::CTR_Mode<CryptoPP::XSalsa20>::Encryption *e;
759	+ CryptoPP::XSalsa20::Encryption *e;
760	+} XSalsa;
761	+
762	+PyDoc_STRVAR(XSalsa__doc__,
763	+"An XSalsa20 cipher object.\n\
764	+\n\
765	+This object encrypts/decrypts in CTR mode, using a counter that is initialized\n\
766	+to zero when you instantiate the object. Successive calls to .process() will \n\
767	+use the current counter and increment it.\n\
768	+\n\
769	+");
770	+
771	+static PyObject XSalsa_process(XSalsa self, PyObject* msgobj) {
772	+ if(!PyString_CheckExact(msgobj)) {
773	+ PyStringObject* typerepr = reinterpret_cast<PyStringObject>(PyObject_Repr(reinterpret_cast<PyObject>(msgobj->ob_type)));
774	+ if (typerepr) {
775	+ PyErr_Format(xsalsa_error, "Precondition violation: you are required to pass a Python string object (not a unicode, a subclass of string, or anything else), but you passed %s.", PyString_AS_STRING(reinterpret_cast<PyObject*>(typerepr)));
776	+ Py_DECREF(typerepr);
777	+ } else
778	+ PyErr_Format(xsalsa_error, "Precondition violation: you are required to pass a Python string object (not a unicode, a subclass of string, or anything else).");
779	+ return NULL;
780	+ }
781	+
782	+ const char* msg;
783	+ Py_ssize_t msgsize;
784	+ if (PyString_AsStringAndSize(msgobj, const_cast<char**>(&msg), &msgsize))
785	+ return NULL;
786	+ assert (msgsize >= 0);
787	+
788	+ PyStringObject* result = reinterpret_cast<PyStringObject*>(PyString_FromStringAndSize(NULL, msgsize));
789	+ if (!result)
790	+ return NULL;
791	+
792	+ self->e->ProcessString(reinterpret_cast<byte>(PyString_AS_STRING(result)), reinterpret_cast<const byte>(msg), msgsize);
793	+ return reinterpret_cast<PyObject*>(result);
794	+}
795	+
796	+PyDoc_STRVAR(XSalsa_process__doc__,
797	+"Encrypt or decrypt the next bytes, returning the result.");
798	+
799	+static PyMethodDef XSalsa_methods[] = {
800	+ {"process", reinterpret_cast<PyCFunction>(XSalsa_process), METH_O, XSalsa_process__doc__},
801	+ {NULL},
802	+};
803	+
804	+static PyObject* XSalsa_new(PyTypeObject* type, PyObject args, PyObject kwdict) {
805	+ XSalsa* self = reinterpret_cast<XSalsa*>(type->tp_alloc(type, 0));
806	+ if (!self)
807	+ return NULL;
808	+ self->e = NULL;
809	+ return reinterpret_cast<PyObject*>(self);
810	+}
811	+
812	+static void XSalsa_dealloc(PyObject* self) {
813	+ if (reinterpret_cast<XSalsa*>(self)->e)
814	+ delete reinterpret_cast<XSalsa*>(self)->e;
815	+ self->ob_type->tp_free(self);
816	+}
817	+
818	+static int XSalsa_init(PyObject* self, PyObject args, PyObject kwdict) {
819	+ static const char *kwlist[] = { "key", "iv", NULL};
820	+ const char *key = NULL;
821	+ Py_ssize_t keysize = 0;
822	+ const char *iv = NULL;
823	+ const char defaultiv[24] = {0};
824	+ Py_ssize_t ivsize = 0;
825	+ if (!PyArg_ParseTupleAndKeywords(args, kwdict, "t#\|t#:XSalsa.__init__", const_cast<char**>(kwlist), &key, &keysize, &iv, &ivsize))
826	+ return -1;
827	+ assert (keysize >= 0);
828	+ assert (ivsize >= 0);
829	+
830	+ if(!iv)
831	+ iv = defaultiv;
832	+ try {
833	+ reinterpret_cast<XSalsa>(self)->e = new CryptoPP::XSalsa20::Encryption(reinterpret_cast<const byte>(key), keysize, reinterpret_cast<const byte*>(iv));
834	+ }
835	+ catch (CryptoPP::InvalidKeyLength le)
836	+ {
837	+ PyErr_Format(xsalsa_error, "Precondition violation: you are required to pass a valid key size. Crypto++ gave this exception: %s", le.what());
838	+ return -1;
839	+ }
840	+ if (!reinterpret_cast<XSalsa*>(self)->e)
841	+ {
842	+ PyErr_NoMemory();
843	+ return -1;
844	+ }
845	+ return 0;
846	+}
847	+
848	+
849	+static PyTypeObject XSalsa_type = {
850	+ PyObject_HEAD_INIT(NULL)
851	+ 0, /ob_size/
852	+ "_xsalsa.XSalsa", /tp_name/
853	+ sizeof(XSalsa), /tp_basicsize/
854	+ 0, /tp_itemsize/
855	+ XSalsa_dealloc, /tp_dealloc/
856	+ 0, /tp_print/
857	+ 0, /tp_getattr/
858	+ 0, /tp_setattr/
859	+ 0, /tp_compare/
860	+ 0, /tp_repr/
861	+ 0, /tp_as_number/
862	+ 0, /tp_as_sequence/
863	+ 0, /tp_as_mapping/
864	+ 0, /tp_hash/
865	+ 0, /tp_call/
866	+ 0, /tp_str/
867	+ 0, /tp_getattro/
868	+ 0, /tp_setattro/
869	+ 0, /tp_as_buffer/
870	+ Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /tp_flags/
871	+ XSalsa__doc__, /tp_doc/
872	+ 0, /tp_traverse/
873	+ 0, /tp_clear/
874	+ 0, /tp_richcompare/
875	+ 0, /tp_weaklistoffset/
876	+ 0, /tp_iter/
877	+ 0, /tp_iternext/
878	+ XSalsa_methods, /tp_methods/
879	+ 0, /tp_members/
880	+ 0, /tp_getset/
881	+ 0, /tp_base/
882	+ 0, /tp_dict/
883	+ 0, /tp_descr_get/
884	+ 0, /tp_descr_set/
885	+ 0, /tp_dictoffset/
886	+ XSalsa_init, /tp_init/
887	+ 0, /tp_alloc/
888	+ XSalsa_new, /tp_new/
889	+};
890	+
891	+void init_xsalsa(PyObject*const module)
892	+{
893	+ if (PyType_Ready(&XSalsa_type) < 0)
894	+ return;
895	+ Py_INCREF(&XSalsa_type);
896	+ PyModule_AddObject(module, "xsalsa_XSalsa", (PyObject *)&XSalsa_type);
897	+
898	+ xsalsa_error = PyErr_NewException(const_cast<char*>("_xsalsa.Error"), NULL, NULL);
899	+ PyModule_AddObject(module, "xsalsa_Error", xsalsa_error);
900	+
901	+ PyModule_AddStringConstant(module, "xsalsa__doc__", const_cast<char*>(xsalsa__doc__));
902	+}
903	addfile ./pycryptopp/cipher/xsalsamodule.hpp
904	hunk ./pycryptopp/cipher/xsalsamodule.hpp 1
905	+#ifndef __INCL_XSALSAMODULE_HPP
906	+#define __INCL_XSALSAMODULE_HPP
907	+
908	+extern void init_xsalsa(PyObject* module);
909	+
910	+#endif; /#ifndef __INCL_XSALSAMODULE_HPP/
911	addfile ./pycryptopp/test/test_xsalsa.py
912	hunk ./pycryptopp/test/test_xsalsa.py 1
913	+#!/usr/bin/env python
914	+
915	+import random, re
916	+import unittest
917	+
918	+from binascii import a2b_hex, b2a_hex
919	+from pkg_resources import resource_string
920	+
921	+from pycryptopp.cipher import xsalsa
922	+TEST_XSALSA_RE=re.compile("\nCOUNT=([0-9]+)\nKEY=([0-9a-f]+)\nIV=([0-9a-f]+)\nPLAINTEXT=([0-9a-f]+)\nCIPHERTEXT=([0-9a-f]+)")
923	+
924	+class XSalsaTest(unittest.TestCase):
925	+
926	+ enc0="eea6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff880309e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d700c093c5e5585579625337bd3ab619d615760d8c5b224a85b1d0efe0eb8a7ee163abb0376529fcc09bab506c618e13ce777d82c3ae9d1a6f972d4160287cbfe60bf2130fc0a6ff6049d0a5c8a82f429231f0080"
927	+
928	+ def test_zero_XSalsa(self):
929	+ key="1b27556473e985d462cd51197a9a46c76009549eac6474f206c4ee0844f68389"
930	+ iv="69696ee955b62b73cd62bda875fc73d68219e0036b7a0b37"
931	+ computedcipher=xsalsa.XSalsa(a2b_hex(key),a2b_hex(iv)).process('\x00'*139)
932	+ self.failUnlessEqual(a2b_hex(self.enc0), computedcipher, "enc0: %s, computedciper: %s" % (self.enc0, b2a_hex(computedcipher)))
933	+
934	+ cryptor=xsalsa.XSalsa(a2b_hex(key),a2b_hex(iv))
935	+
936	+ computedcipher1=cryptor.process('\x00'*69)
937	+ computedcipher2=cryptor.process('\x00'*69)
938	+ computedcipher3=cryptor.process('\x00')
939	+ computedcipher12=b2a_hex(computedcipher1)+b2a_hex(computedcipher2)+b2a_hex(computedcipher3)
940	+ self.failUnlessEqual(self.enc0, computedcipher12)
941	+
942	+ def test_XSalsa(self):
943	+ curfile = open( '../testvectors/testx1.txt', 'r')
944	+ s = curfile.read()
945	+ print s,"\n"
946	+ return self._test_XSalsa(s)
947	+
948	+ def _test_XSalsa(self, vects_str):
949	+ for mo in TEST_XSALSA_RE.finditer(vects_str):
950	+ count = int(mo.group(1))
951	+ key = a2b_hex(mo.group(2))
952	+ iv = a2b_hex(mo.group(3))
953	+# plaintext = a2b_hex(mo.group(4))
954	+# ciphertext= a2b_hex(mo.group(5))
955	+ plaintext = mo.group(4)
956	+ ciphertext = mo.group(5)
957	+ computedcipher=xsalsa.XSalsa(key,iv).process(a2b_hex(plaintext))
958	+# print "ciphertext", b2a_hex(computedcipher), '\n'
959	+# print "computedtext", ciphertext, '\n'
960	+# print count, ": \n"
961	+ self.failUnlessEqual(computedcipher,a2b_hex(ciphertext),"computedcipher: %s, ciphertext: %s" % (b2a_hex(computedcipher), ciphertext))
962	+
963	+ #the random decomposing
964	+ plaintext1 = ""
965	+ plaintext2 = ""
966	+ length = len(plaintext)
967	+ rccipher = ""
968	+ cryptor = xsalsa.XSalsa(key,iv)
969	+ if length > 2:
970	+ point = random.randint(0,length-3)
971	+ if (point%2) !=0:
972	+ point -= 1
973	+ plaintext1 += plaintext[:point+2]
974	+ plaintext2 += plaintext[point+2:]
975	+ rccipher += b2a_hex(cryptor.process(a2b_hex(plaintext1)))
976	+ rccipher += b2a_hex(cryptor.process(a2b_hex(plaintext2)))
977	+ self.failUnlessEqual(rccipher, ciphertext, "random computed cipher: %s, ciphertext: %s" % (rccipher, ciphertext))
978	+
979	+ #every byte encrypted
980	+ cryptor = xsalsa.XSalsa(key,iv)
981	+ eccipher=""
982	+ l = 0
983	+ while l<=(length-2):
984	+ eccipher += b2a_hex(cryptor.process(a2b_hex(plaintext[l:l+2])))
985	+ l += 2
986	+ self.failUnlessEqual(eccipher, ciphertext, "every byte computed cipher: %s, ciphertext: %s" % (eccipher, ciphertext))
987	+
988	+
989	+ def test_init_type_check(self):
990	+ self.failUnlessRaises(TypeError, xsalsa.XSalsa, None)
991	+ self.failUnlessRaises(xsalsa.Error, xsalsa.XSalsa, "a"*1)
992	+ self.failUnlessRaises(xsalsa.Error, xsalsa.XSalsa, "a"*17)
993	+ self.failUnlessRaises(xsalsa.Error, xsalsa.XSalsa, "a"*18)
994	+# self.failUnlessRaises(xsalsa.Error, xsalsa.XSalsa, "a"*32)
995	+
996	+if __name__ == "__main__":
997	+ unittest.main()
998	addfile ./pycryptopp/testvectors/testx1.txt
999	hunk ./pycryptopp/testvectors/testx1.txt 1
1000	+
1001	+COUNT=1
1002	+KEY=a6a7251c1e72916d11c2cb214d3c252539121d8e234e652d651fa4c8cff88030
1003	+IV=9e645a74e9e0a60d8243acd9177ab51a1beb8d5a2f5d700c
1004	+PLAINTEXT=093c5e5585579625337bd3ab619d615760d8c5b224a85b1d0efe0eb8a7ee163abb0376529fcc09bab506c618e13ce777d82c3ae9d1a6f972d4160287cbfe60bf2130fc0a6ff6049d0a5c8a82f429231f008082e845d7e189d37f9ed2b464e6b919e6523a8c1210bd52a02a4c3fe406d3085f5068d1909eeeca6369abc981a42e87fe665583f0ab85ae71f6f84f528e6b397af86f6917d9754b7320dbdc2fea81496f2732f532ac78c4e9c6cfb18f8e9bdf74622eb126141416776971a84f94d156beaf67aecbf2ad412e76e66e8fad7633f5b6d7f3d64b5c6c69ce29003c6024465ae3b89be78e915d88b4b5621d
1005	+CIPHERTEXT=b2af688e7d8fc4b508c05cc39dd583d6714322c64d7f3e63147aede2d9534934b04ff6f337b031815cd094bdbc6d7a92077dce709412286822ef0737ee47f6b7ffa22f9d53f11dd2b0a3bb9fc01d9a88f9d53c26e9365c2c3c063bc4840bfc812e4b80463e69d179530b25c158f543191cff993106511aa036043bbc75866ab7e34afc57e2cce4934a5faae6eabe4f221770183dd060467827c27a354159a081275a291f69d946d6fe28ed0b9ce08206cf484925a51b9498dbde178ddd3ae91a8581b91682d860f840782f6eea49dbb9bd721501d2c67122dea3b7283848c5f13e0c0de876bd227a856e4de593a3
1006	+
1007	+COUNT=2
1008	+KEY=9e1da239d155f52ad37f75c7368a536668b051952923ad44f57e75ab588e475a
1009	+IV=af06f17859dffa799891c4288f6635b5c5a45eee9017fd72
1010	+PLAINTEXT=feac9d54fc8c115ae247d9a7e919dd76cfcbc72d32cae4944860817cbdfb8c04e6b1df76a16517cd33ccf1acda9206389e9e318f5966c093cfb3ec2d9ee2de856437ed581f552f26ac2907609df8c613b9e33d44bfc21ff79153e9ef81a9d66cc317857f752cc175fd8891fefebb7d041e6517c3162d197e2112837d3bc4104312ad35b75ea686e7c70d4ec04746b52ff09c421451459fb59f
1011	+CIPHERTEXT=2c261a2f4e61a62e1b27689916bf03453fcbc97bb2af6f329391ef063b5a219bf984d07d70f602d85f6db61474e9d9f5a2deecb4fcd90184d16f3b5b5e168ee03ea8c93f3933a22bc3d1a5ae8c2d8b02757c87c073409052a2a8a41e7f487e041f9a49a0997b540e18621cad3a24f0a56d9b19227929057ab3ba950f6274b121f193e32e06e5388781a1cb57317c0ba6305e910961d01002f0
1012	+
1013	+COUNT=3
1014	+KEY=d5c7f6797b7e7e9c1d7fd2610b2abf2bc5a7885fb3ff78092fb3abe8986d35e2
1015	+IV=744e17312b27969d826444640e9c4a378ae334f185369c95
1016	+PLAINTEXT=7758298c628eb3a4b6963c5445ef66971222be5d1a4ad839715d1188071739b77cc6e05d5410f963a64167629757
1017	+CIPHERTEXT=27b8cfe81416a76301fd1eec6a4d99675069b2da2776c360db1bdfea7c0aa613913e10f7a60fec04d11e65f2d64e
1018	+
1019	+COUNT=4
1020	+KEY=737d7811ce96472efed12258b78122f11deaec8759ccbd71eac6bbefa627785c
1021	+IV=6fb2ee3dda6dbd12f1274f126701ec75c35c86607adb3edd
1022	+PLAINTEXT=501325fb2645264864df11faa17bbd58312b77cad3d94ac8fb8542f0eb653ad73d7fce932bb874cb89ac39fc47f8267cf0f0c209f204b2d8578a3bdf461cb6a271a468bebaccd9685014ccbc9a73618c6a5e778a21cc8416c60ad24ddc417a130d53eda6dfbfe47d09170a7be1a708b7b5f3ad464310be36d9a2a95dc39e83d38667e842eb6411e8a23712297b165f690c2d7ca1b1346e3c1fccf5cafd4f8be0
1023	+CIPHERTEXT=6724c372d2e9074da5e27a6c54b2d703dc1d4c9b1f8d90f00c122e692ace7700eadca942544507f1375b6581d5a8fb39981c1c0e6e1ff2140b082e9ec016fce141d5199647d43b0b68bfd0fea5e00f468962c7384dd6129aea6a3fdfe75abb210ed5607cef8fa0e152833d5ac37d52e557b91098a322e76a45bbbcf4899e790618aa3f4c2e5e0fc3de93269a577d77a5502e8ea02f717b1dd2df1ec69d8b61ca
1024	+
1025	+COUNT=5
1026	+KEY=760158da09f89bbab2c99e6997f9523a95fcef10239bcca2573b7105f6898d34
1027	+IV=43636b2cc346fc8b7c85a19bf507bdc3dafe953b88c69dba
1028	+PLAINTEXT=d30a6d42dff49f0ed039a306bae9dec8d9e88366cc19e8c3642fd58fa0794ebf8029d949730339b0823a51f0f49f0d2c71f1051c1e0e2c86941f172789cdb1b0107413e70f982ff9761877bb526ef1c3eb1106a948d60ef21bd35d32cfd64f89b79ed63ecc5cca56246af736766f285d8e6b0da9cb1cd21020223ffacc5a32
1029	+CIPHERTEXT=c815b6b79b64f9369aec8dce8c753df8a50f2bc97c70ce2f014db33a65ac5816bac9e30ac08bdded308c65cb87e28e2e71b677dc25c5a6499c1553555daf1f55270a56959dffa0c66f24e0af00951ec4bb59ccc3a6c5f52e0981647e53e439313a52c40fa7004c855b6e6eb25b212a138e843a9ba46edb2a039ee82a263abe
1030	+
1031	+COUNT=6
1032	+KEY=27ba7e81e7edd4e71be53c07ce8e633138f287e155c7fa9e84c4ad804b7fa1b9
1033	+IV=ea05f4ebcd2fb6b000da0612861ba54ff5c176fb601391aa
1034	+PLAINTEXT=e09ff5d2cb050d69b2d42494bde5825238c756d6991d99d7a20d1ef0b83c371c89872690b2fc11d5369f4fc4971b6d3d6c078aef9b0f05c0e61ab89c025168054defeb03fef633858700c58b1262ce011300012673e893e44901dc18eee3105699c44c805897bdaf776af1833162a21a
1035	+CIPHERTEXT=a23e7ef93c5d0667c96d9e404dcbe6be62026fa98f7a3ff9ba5d458643a16a1cef7272dc6097a9b52f35983557c77a11b314b4f7d5dc2cca15ee47616f861873cbfed1d32372171a61e38e447f3cf362b3abbb2ed4170d89dcb28187b7bfd206a3e026f084a7e0ed63d319de6bc9afc0
1036	+
1037	+COUNT=7
1038	+KEY=6799d76e5ffb5b4920bc2768bafd3f8c16554e65efcf9a16f4683a7a06927c11
1039	+IV=61ab951921e54ff06d9b77f313a4e49df7a057d5fd627989
1040	+PLAINTEXT=472766
1041	+CIPHERTEXT=8fd7df
1042	+
1043	+COUNT=8
1044	+KEY=f68238c08365bb293d26980a606488d09c2f109edafa0bbae9937b5cc219a49c
1045	+IV=5190b51e9b708624820b5abdf4e40fad1fb950ad1adc2d26
1046	+PLAINTEXT=47ec6b1f73c4b7ff5274a0bfd7f45f864812c85a12fbcb3c2cf8a3e90cf66ccf2eacb521e748363c77f52eb426ae57a0c6c78f75af71284569e79d1a92f949a9d69c4efc0b69902f1e36d7562765543e2d3942d9f6ff5948d8a312cff72c1afd9ea3088aff7640bfd265f7a9946e606abc77bcedae6bddc75a0dba0bd917d73e3bd1268f727e0096345da1ed25cf553ea7a98fea6b6f285732de37431561ee1b3064887fbcbd71935e02
1047	+CIPHERTEXT=36160e88d3500529ba4edba17bc24d8cfaca9a0680b3b1fc97cf03f3675b7ac301c883a68c071bc54acdd3b63af4a2d72f985e51f9d60a4c7fd481af10b2fc75e252fdee7ea6b6453190617dcc6e2fe1cd56585fc2f0b0e97c5c3f8ad7eb4f31bc4890c03882aac24cc53acc1982296526690a220271c2f6e326750d3fbda5d5b63512c831f67830f59ac49aae330b3e0e02c9ea0091d19841f1b0e13d69c9fbfe8a12d6f30bb734d9d2
1048	+
1049	+COUNT=9
1050	+KEY=45b2bd0de4ed9293ec3e26c4840faaf64b7d619d51e9d7a2c7e36c83d584c3df
1051	+IV=546c8c5d6be8f90952cab3f36d7c1957baaa7a59abe3d7e5
1052	+PLAINTEXT=5007c8cd5b3c40e17d7fe423a87ae0ced86bec1c39dc07a25772f3e96dabd56cd3fd7319f6c9654925f2d87087a700e1b130da796895d1c9b9acd62b266144067d373ed51e787498b03c52faad16bb3826fa511b0ed2a19a8663f5ba2d6ea7c38e7212e9697d91486c49d8a000b9a1935d6a7ff7ef23e720a45855481440463b4ac8c4f6e7062adc1f1e1e25d3d65a31812f58a71160
1053	+CIPHERTEXT=8eacfba568898b10c0957a7d44100685e8763a71a69a8d16bc7b3f88085bb9a2f09642e4d09a9f0ad09d0aad66b22610c8bd02ff6679bb92c2c026a216bf425c6be35fb8dae7ff0c72b0efd6a18037c70eed0ca90062a49a3c97fdc90a8f9c2ea536bfdc41918a7582c9927fae47efaa3dc87967b7887dee1bf071734c7665901d9105dae2fdf66b4918e51d8f4a48c60d19fbfbbcba
1054	+
1055	+COUNT=10
1056	+KEY=fe559c9a282beb40814d016d6bfcb2c0c0d8bf077b1110b8703a3ce39d70e0e1
1057	+IV=b076200cc7011259805e18b304092754002723ebec5d6200
1058	+PLAINTEXT=6db65b9ec8b114a944137c821fd606be75478d928366d5284096cdef782fcff7e8f59cb8ffcda979757902c5ffa6bc477ceaa4cb5d5ea76f94d91e833f823a6bc78f1055dfa6a97bea8965c1cde67a668e001257334a585727d9e0f7c1a06e88d3d25a4e6d9096c968bf138e116a3ebeffd4bb4808adb1fd698164ba0a35c709a47f16f1f4435a2345a9194a00b95abd51851d505809a6077da9baca5831afff31578c487ee68f2767974a98a7e803aac788da98319c4ea8eaa3d394855651f484cef543f537e35158ee29
1059	+CIPHERTEXT=4dce9c8f97a028051b0727f34e1b9ef21f06f0760f36e71713204027902090ba2bb6b13436ee778d9f50530efbd7a32b0d41443f58ccaee781c7b716d3a96fdec0e3764ed7959f34c3941278591ea033b5cbadc0f1916032e9bebbd1a8395b83fb63b1454bd775bd20b3a2a96f951246ac14daf68166ba62f6cbff8bd121ac9498ff8852fd2be975df52b5daef3829d18eda42e715022dcbf930d0a789ee6a146c2c7088c35773c63c06b4af4559856ac199ced86863e4294707825337c5857970eb7fddeb263781309011
1060	+
1061	+COUNT=11
1062	+KEY=0ae10012d7e56614b03dcc89b14bae9242ffe630f3d7e35ce8bbb97bbc2c92c3
1063	+IV=f96b025d6cf46a8a12ac2af1e2aef1fb83590adadaa5c5ea
1064	+PLAINTEXT=ea0f354e96f12bc72bbaa3d12b4a8ed879b042f0689878f46b651cc4116d6f78409b11430b3aaa30b2076891e8e1fa528f2fd169ed93dc9f84e24409eec2101daf4d057be2492d11de640cbd7b355ad29fb70400fffd7cd6d425abeeb732a0eaa4330af4c656252c4173deab653eb85c58462d7ab0f35fd12b613d29d473d330310dc323d3c66348bbdbb68a326324657cae7b77a9e34358f2cec50c85609e73056856796e3be8d62b6e2fe9f953
1065	+CIPHERTEXT=e8abd48924b54e5b80866be7d4ebe5cf4274cafff08b39cb2d40a8f0b472398aedc776e0793812fbf1f60078635d2ed86b15efcdba60411ee23b07233592a44ec31b1013ce8964236675f8f183aef885e864f2a72edf4215b5338fa2b54653dfa1a8c55ce5d95cc605b9b311527f2e3463ffbec78a9d1d65dabad2f338769c9f43f133a791a11c7eca9af0b771a4ac32963dc8f631a2c11217ac6e1b9430c1aae1ceebe22703f429998a8fb8c641
1066	+
1067	+COUNT=12
1068	+KEY=082c539bc5b20f97d767cd3f229eda80b2adc4fe49c86329b5cd6250a9877450
1069	+IV=845543502e8b64912d8f2c8d9fffb3c69365686587c08d0c
1070	+PLAINTEXT=a96bb7e910281a6dfad7c8a9c370674f0ceec1ad8d4f0de32f9ae4a23ed329e3d6bc708f876640a229153ac0e7281a8188dd77695138f01cda5f41d5215fd5c6bdd46d982cb73b1efe2997970a9fdbdb1e768d7e5db712068d8ba1af6067b5753495e23e6e1963af012f9c7ce450bf2de619d3d59542fb55f3
1071	+CIPHERTEXT=835da74fc6de08cbda277a7966a07c8dcd627e7b17adde6d930b6581e3124b8baad096f693991fedb1572930601fc7709541839b8e3ffd5f033d2060d999c6c6e3048276613e648000acb5212cc632a916afce290e20ebdf612d08a6aa4c79a74b070d3f872a861f8dc6bb07614db515d363349d3a8e3336a3
1072	+
1073	+COUNT=13
1074	+KEY=3d02bff3375d403027356b94f514203737ee9a85d2052db3e4e5a217c259d18a
1075	+IV=74216c95031895f48c1dba651555ebfa3ca326a755237025
1076	+PLAINTEXT=0d4b0f54fd09ae39baa5fa4baccf2e6682e61b257e01f42b8f
1077	+CIPHERTEXT=16c4006c28365190411eb1593814cf15e74c22238f210afc3d
1078	+
1079	+COUNT=14
1080	+KEY=ad1a5c47688874e6663a0f3fa16fa7efb7ecadc175c468e5432914bdb480ffc6
1081	+IV=e489eed440f1aae1fac8fb7a9825635454f8f8f1f52e2fcc
1082	+PLAINTEXT=aa6c1e53580f03a9abb73bfdadedfecada4c6b0ebe020ef10db745e54ba861caf65f0e40dfc520203bb54d29e0a8f78f16b3f1aa525d6bfa33c54726e59988cfbec78056
1083	+CIPHERTEXT=02fe84ce81e178e7aabdd3ba925a766c3c24756eefae33942af75e8b464556b5997e616f3f2dfc7fce91848afd79912d9fb55201b5813a5a074d2c0d4292c1fd441807c5
1084	+
1085	+COUNT=15
1086	+KEY=053a02bedd6368c1fb8afc7a1b199f7f7ea2220c9a4b642a6850091c9d20ab9c
1087	+IV=c713eea5c26dad75ad3f52451e003a9cb0d649f917c89dde
1088	+PLAINTEXT=8f0a8a164760426567e388840276de3f95cb5e3fadc6ed3f3e4fe8bc169d9388804dcb94b6587dbb66cb0bd5f87b8e98b52af37ba290629b858e0e2aa7378047a26602
1089	+CIPHERTEXT=516710e59843e6fbd4f25d0d8ca0ec0d47d39d125e9dad987e0518d49107014cb0ae405e30c2eb3794750bca142ce95e290cf95abe15e822823e2e7d3ab21bc8fbd445
1090	+
1091	+COUNT=16
1092	+KEY=5b14ab0fbed4c58952548a6cb1e0000cf4481421f41288ea0aa84add9f7deb96
1093	+IV=54bf52b911231b952ba1a6af8e45b1c5a29d97e2abad7c83
1094	+PLAINTEXT=37fb44a675978b560ff9a4a87011d6f3ad2d37a2c3815b45a3c0e6d1b1d8b1784cd468927c2ee39e1dccd4765e1c3d676a335be1ccd6900a45f5d41a317648315d8a8c24adc64eb285f6aeba05b9029586353d303f17a807658b9ff790474e1737bd5fdc604aeff8dfcaf1427dcc3aacbb0256badcd183ed75a2dc52452f87d3c1ed2aa583472b0ab91cda20614e9b6fdbda3b49b098c95823cc72d8e5b717f2314b0324e9ce
1095	+CIPHERTEXT=ae6deb5d6ce43d4b09d0e6b1c0e9f46157bcd8ab50eaa3197ff9fa2bf7af649eb52c68544fd3adfe6b1eb316f1f23538d470c30dbfec7e57b60cbcd096c782e7736b669199c8253e70214cf2a098fda8eac5da79a9496a3aae754d03b17c6d70d1027f42bf7f95ce3d1d9c338854e158fcc803e4d6262fb639521e47116ef78a7a437ca9427ba645cd646832feab822a208278e45e93e118d780b988d65397eddfd7a819526e
1096	+
1097	+COUNT=17
1098	+KEY=d74636e3413a88d85f322ca80fb0bd650bd0bf0134e2329160b69609cd58a4b0
1099	+IV=efb606aa1d9d9f0f465eaa7f8165f1ac09f5cb46fecf2a57
1100	+PLAINTEXT=f85471b75f6ec81abac2799ec09e98e280b2ffd64ca285e5a0109cfb31ffab2d617b2c2952a2a8a788fc0da2af7f530758f74f1ab56391ab5ff2adbcc5be2d6c7f49fbe8118104c6ff9a23c6dfe52f57954e6a69dcee5db06f514f4a0a572a9a8525d961dae72269b987189d465df6107119c7fa790853e063cba0fab7800ca932e258880fd74c33c784675bedad0e7c09e9cc4d63dd5e9713d5d4a0196e6b562226ac31b4f57c04f90a181973737ddc7e80f364112a9fbb435ebdbcabf7d490ce52
1101	+CIPHERTEXT=b2b795fe6c1d4c83c1327e015a67d4465fd8e32813575cbab263e20ef05864d2dc17e0e4eb81436adfe9f638dcc1c8d78f6b0306baf938e5d2ab0b3e05e735cc6fff2d6e02e3d60484bea7c7a8e13e23197fea7b04d47d48f4a4e5944174539492800d3ef51e2ee5e4c8a0bdf050c2dd3dd74fce5e7e5c37364f7547a11480a3063b9a0a157b15b10a5a954de2731ced055aa2e2767f0891d4329c426f3808ee867bed0dc75b5922b7cfb895700fda016105a4c7b7f0bb90f029f6bbcb04ac36ac16
1102	}
1103	[hmac.dpatch
1104	xueyu7452@gmail.com**20100704043039
1105	Ignore-this: a39c389df18c12fd0ab09948535a9376
1106	] {
1107	addfile ./pycryptopp/hash/hmac.py
1108	hunk ./pycryptopp/hash/hmac.py 1
1109	+#!/usr/bin/env python
1110	+
1111	+#from pycryptopp import sha256
1112	+import sha256
1113	+
1114	+digest_size = None
1115	+
1116	+class HMAC(object):
1117	+ """RFC2104 HMAC class
1118	+ """
1119	+
1120	+ blocksize = 64
1121	+ def __init__(self, key, msg=None, digestmod = None):
1122	+ """Create a new HMAC object
1123	+
1124	+ key: key for the keyed hash object.
1125	+ msg: Initial input for the hash, if provided.
1126	+ digestmod: A module from pycrptopp hash package
1127	+ """
1128	+
1129	+ if digestmod is None:
1130	+ digestmod = sha256.SHA256
1131	+
1132	+ if callable(digestmod):
1133	+ self.digest_cons = digestmod
1134	+ else:
1135	+ self.digest_cons = lambda d='':digestmod.new(d)
1136	+
1137	+ self.outer = self.digest_cons()
1138	+ self.inner = self.digest_cons()
1139	+ self.digest_size = len(self.digest_cons().digest())
1140	+
1141	+ blocksize = self.blocksize
1142	+ if len(key) > blocksize:
1143	+ key = self.digest_cons(key).digest()
1144	+
1145	+ key = key + chr(0)*(blocksize - len(key))
1146	+# ikey = key ^ (imask*blocksize)
1147	+# okey = key ^ (omask*blocksize)
1148	+
1149	+ ikey = "".join(chr(ord(key[i])^0x5c) for i in xrange(blocksize))
1150	+ okey = "".join(chr(ord(key[i])^0x36) for i in xrange(blocksize))
1151	+ self.outer.update(ikey)
1152	+ self.inner.update(okey)
1153	+ if msg is not None:
1154	+ self.inner.update(msg)
1155	+
1156	+ def digest(self):
1157	+ """Return the hash value of this hashing object
1158	+ """
1159	+ self.outer.update(self.inner.digest())
1160	+# print "hi,xueyu coming\n"
1161	+ return self.outer.digest()
1162	+
1163	+ def hexdigest(self):
1164	+ """Like digest(), but returns a string of hexadecimal digits instead.
1165	+ """
1166	+ self.outer.update(self.inner.digest())
1167	+ return self.outer.hexdigest()
1168	+
1169	+
1170	+def new(key, msg = None, digestmod = None):
1171	+ """Create a new hashing object and return it.
1172	+
1173	+ key: The starting key for the hash
1174	+ msg: if available, will immediately be hashed into the object's starting
1175	+ state.
1176	+ """
1177	+ return HMAC(key, msg, digestmod)
1178	+
1179	+
1180	+
1181	+
1182	+
1183	+
1184	+
1185	+
1186	+
1187	addfile ./pycryptopp/test/hmac_bench.py
1188	hunk ./pycryptopp/test/hmac_bench.py 1
1189	+#!/usr/bin/env python
1190	+
1191	+import random, re, time
1192	+import unittest
1193	+
1194	+from binascii import a2b_hex, b2a_hex
1195	+from pycryptopp.hash import hmac, sha256
1196	+
1197	+def randstr(n):
1198	+ return ''.join(map(chr, map(random.randrange, [0]n, [256]n)))
1199	+
1200	+#multiple times hmac using different key and different messages
1201	+def HMAC_Bench1():
1202	+ print "HMAC_Bench1 starting\n"
1203	+ start_time = time.clock()
1204	+# i=1
1205	+ for keylen in xrange(100):
1206	+ for msglen in xrange(100):
1207	+# for times in xrange(10):
1208	+# print i, '\n'
1209	+# i+=1
1210	+ key = randstr(keylen)
1211	+ msg = randstr(msglen)
1212	+ h = hmac.new(key, msg, sha256.SHA256)
1213	+ h.digest()
1214	+
1215	+ stop_time = time.clock()
1216	+ print "multiple times hmac using different random key and different random messages, 100 random keys * 100 messages with lenth from 0 to 99, Bench1: ", stop_time-start_time,'sec \nHMAC_Bench1 ending\n'
1217	+
1218	+#using a key hmac a short message
1219	+def HMAC_Bench2():
1220	+ print "HMAC_Bench2 starting\n"
1221	+ start_time = time.clock()
1222	+ key = randstr(100)
1223	+ msg = randstr(10)
1224	+ h = hmac.new(key, msg, sha256.SHA256)
1225	+ h.digest()
1226	+ stop_time = time.clock()
1227	+ print "using a key hmac a short message, Bench2: ", stop_time-start_time,"sec \n"
1228	+ print "HMAC_Bench2 ending\n\n\n"
1229	+
1230	+def HMAC_Bench3():
1231	+ print "hmac bench3 starting\n"
1232	+ start_time = time.clock()
1233	+ k1 = "k"*100
1234	+ m1 = "a"*10000000
1235	+ h1 = hmac.new(k1, m1, sha256.SHA256)
1236	+ h1.digest()
1237	+ stop_time = time.clock()
1238	+ print "using a fixed 100 bytes key hmac a 10^7 bytes long fixed long message:\n", stop_time-start_time, 'sec \n'
1239	+ print "another one using a random string"
1240	+ start_time = time.clock()
1241	+ k2=randstr(100)
1242	+ m2=randstr(10000000)
1243	+ h2 = hmac.new(k2, m2, sha256.SHA256)
1244	+ h2.digest()
1245	+ stop_time = time.clock()
1246	+ print "using a random 100 bytes key hmac a 10^7 bytes long random message, Bench3: ", stop_time-start_time,"sec \n"
1247	+ print "As we can see, most of time is spent on random string generation \nhmac bench3 ending\n\n\n"
1248	+
1249	+def HMAC_Bench4():
1250	+ print "hmac bench4 starting\n"
1251	+ k = "k"*100
1252	+ m = "b"*10000000
1253	+ start_time = time.clock()
1254	+ for times in xrange(1000):
1255	+ h = hmac.new(k, m , sha256.SHA256)
1256	+ h.digest()
1257	+ stop_time = time.clock()
1258	+ print "hmac a 10^7 bytes long message 1000 times, Bench4: ", stop_time-start_time, "sec \n"
1259	+ print "hmac bench4 ending\n\n\n"
1260	+
1261	+
1262	+def main():
1263	+ HMAC_Bench4()
1264	+ HMAC_Bench3()
1265	+ HMAC_Bench2()
1266	+ HMAC_Bench1()
1267	+
1268	+if __name__=="__main__":
1269	+ main()
1270	+
1271	addfile ./pycryptopp/test/test_hmac.py
1272	hunk ./pycryptopp/test/test_hmac.py 1
1273	+#!/usr/bin/env python
1274	+
1275	+import random, re
1276	+import unittest
1277	+
1278	+from binascii import a2b_hex, b2a_hex
1279	+from pkg_resources import resource_string
1280	+
1281	+from pycryptopp.hash import hmac, sha256
1282	+TEST_HMAC_RE=re.compile("\nCOUNT=([0-9]+)\nKEY=([0-9a-f]+)\nDATA=([0-9a-f]+)\nHMAC-SHA256=([0-9a-f]+)")
1283	+
1284	+class HMACTest(unittest.TestCase):
1285	+ def test_HMAC(self):
1286	+ curfile = open('../testvectors/HMACMsg.txt', 'r')
1287	+ s = curfile.read()
1288	+ print s,"\n"
1289	+ return self._test_HMAC(s)
1290	+
1291	+ def _test_HMAC(self, vects_str):
1292	+ for mo in TEST_HMAC_RE.finditer(vects_str):
1293	+ count = int(mo.group(1))
1294	+# print "hello", count, "\n"
1295	+ key = a2b_hex(mo.group(2))
1296	+ data = a2b_hex(mo.group(3))
1297	+ hmacvalue = mo.group(4)
1298	+
1299	+ length = len(hmacvalue)
1300	+ h = hmac.new(key,data,sha256.SHA256)
1301	+ computedhmacvalue = b2a_hex(h.digest())
1302	+ self.failUnlessEqual(computedhmacvalue[:length],hmacvalue,"computedhmac: %s, hmac: %s" % (computedhmacvalue, hmacvalue))
1303	+
1304	+if __name__ == "__main__":
1305	+ unittest.main()
1306	addfile ./pycryptopp/testvectors/HMACMsg.txt
1307	hunk ./pycryptopp/testvectors/HMACMsg.txt 1
1308	+
1309	+COUNT=1
1310	+KEY=0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b
1311	+DATA=4869205468657265
1312	+HMAC-SHA256=b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7
1313	+
1314	+COUNT=2
1315	+KEY=4a656665
1316	+DATA=7768617420646f2079612077616e7420666f72206e6f7468696e673f
1317	+HMAC-SHA256=5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843
1318	+
1319	+COUNT=3
1320	+KEY=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
1321	+DATA=dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
1322	+HMAC-SHA256=773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe
1323	+
1324	+COUNT=4
1325	+KEY=0102030405060708090a0b0c0d0e0f10111213141516171819
1326	+DATA=cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd
1327	+HMAC-SHA256=82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b
1328	+
1329	+COUNT=5
1330	+KEY=0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c
1331	+DATA=546573742057697468205472756e636174696f6e
1332	+HMAC-SHA256=a3b6167473100ee06e0c796c2955552b
1333	+
1334	+COUNT=6
1335	+KEY=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
1336	+DATA=54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374
1337	+HMAC-SHA256=60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54
1338	+
1339	+COUNT=7
1340	+KEY=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
1341	+DATA=5468697320697320612074657374207573696e672061206c6172676572207468616e20626c6f636b2d73697a65206b657920616e642061206c6172676572207468616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565647320746f20626520686173686564206265666f7265206265696e6720757365642062792074686520484d414320616c676f726974686d2e
1342	+HMAC-SHA256=9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2
1343	+
1344	}
1345
1346	Context:
1347
1348	[setup: reorganize misc/ to match Tahoe-LAFS's misc/ so that the same buildmaster config can use pycryptopp's and Tahoe-LAFS's
1349	zooko@zooko.com**20100607062909
1350	Ignore-this: 500b1eab3ac1983dd72d4d120b48ac64
1351	]
1352	[TAG pycryptopp-0.5.19
1353	zooko@zooko.com**20100604065231
1354	Ignore-this: 923894ad4dca6c77ed31e80c3e4b64e7
1355	]
1356	Patch bundle hash:
1357	1753a9cc648b13aaf32b948f60a66f2b899b9594

Download in other formats:

Original Format