Context Navigation

des.c

Last change on this file was 20366, checked in by Itms, 7 years ago

Alpha 12 version of Premake 5, including prebuilt binary for Windows.
Directly taken from https://premake.github.io/.

File size: 31.1 KB

Line
1	/*
2	* FIPS-46-3 compliant Triple-DES implementation
3	*
4	* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
5	* SPDX-License-Identifier: Apache-2.0
6	*
7	* Licensed under the Apache License, Version 2.0 (the "License"); you may
8	* not use this file except in compliance with the License.
9	* You may obtain a copy of the License at
10	*
11	* http://www.apache.org/licenses/LICENSE-2.0
12	*
13	* Unless required by applicable law or agreed to in writing, software
14	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	* See the License for the specific language governing permissions and
17	* limitations under the License.
18	*
19	* This file is part of mbed TLS (https://tls.mbed.org)
20	*/
21	/*
22	* DES, on which TDES is based, was originally designed by Horst Feistel
23	* at IBM in 1974, and was adopted as a standard by NIST (formerly NBS).
24	*
25	* http://csrc.nist.gov/publications/fips/fips46-3/fips46-3.pdf
26	*/
27
28	#if !defined(MBEDTLS_CONFIG_FILE)
29	#include "mbedtls/config.h"
30	#else
31	#include MBEDTLS_CONFIG_FILE
32	#endif
33
34	#if defined(MBEDTLS_DES_C)
35
36	#include "mbedtls/des.h"
37
38	#include <string.h>
39
40	#if defined(MBEDTLS_SELF_TEST)
41	#if defined(MBEDTLS_PLATFORM_C)
42	#include "mbedtls/platform.h"
43	#else
44	#include <stdio.h>
45	#define mbedtls_printf printf
46	#endif /* MBEDTLS_PLATFORM_C */
47	#endif /* MBEDTLS_SELF_TEST */
48
49	#if !defined(MBEDTLS_DES_ALT)
50
51	/* Implementation that should never be optimized out by the compiler */
52	static void mbedtls_zeroize( void *v, size_t n ) {
53	volatile unsigned char p = v; while( n-- ) p++ = 0;
54	}
55
56	/*
57	* 32-bit integer manipulation macros (big endian)
58	*/
59	#ifndef GET_UINT32_BE
60	#define GET_UINT32_BE(n,b,i) \
61	{ \
62	(n) = ( (uint32_t) (b)[(i) ] << 24 ) \
63	\| ( (uint32_t) (b)[(i) + 1] << 16 ) \
64	\| ( (uint32_t) (b)[(i) + 2] << 8 ) \
65	\| ( (uint32_t) (b)[(i) + 3] ); \
66	}
67	#endif
68
69	#ifndef PUT_UINT32_BE
70	#define PUT_UINT32_BE(n,b,i) \
71	{ \
72	(b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
73	(b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
74	(b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
75	(b)[(i) + 3] = (unsigned char) ( (n) ); \
76	}
77	#endif
78
79	/*
80	* Expanded DES S-boxes
81	*/
82	static const uint32_t SB1[64] =
83	{
84	0x01010400, 0x00000000, 0x00010000, 0x01010404,
85	0x01010004, 0x00010404, 0x00000004, 0x00010000,
86	0x00000400, 0x01010400, 0x01010404, 0x00000400,
87	0x01000404, 0x01010004, 0x01000000, 0x00000004,
88	0x00000404, 0x01000400, 0x01000400, 0x00010400,
89	0x00010400, 0x01010000, 0x01010000, 0x01000404,
90	0x00010004, 0x01000004, 0x01000004, 0x00010004,
91	0x00000000, 0x00000404, 0x00010404, 0x01000000,
92	0x00010000, 0x01010404, 0x00000004, 0x01010000,
93	0x01010400, 0x01000000, 0x01000000, 0x00000400,
94	0x01010004, 0x00010000, 0x00010400, 0x01000004,
95	0x00000400, 0x00000004, 0x01000404, 0x00010404,
96	0x01010404, 0x00010004, 0x01010000, 0x01000404,
97	0x01000004, 0x00000404, 0x00010404, 0x01010400,
98	0x00000404, 0x01000400, 0x01000400, 0x00000000,
99	0x00010004, 0x00010400, 0x00000000, 0x01010004
100	};
101
102	static const uint32_t SB2[64] =
103	{
104	0x80108020, 0x80008000, 0x00008000, 0x00108020,
105	0x00100000, 0x00000020, 0x80100020, 0x80008020,
106	0x80000020, 0x80108020, 0x80108000, 0x80000000,
107	0x80008000, 0x00100000, 0x00000020, 0x80100020,
108	0x00108000, 0x00100020, 0x80008020, 0x00000000,
109	0x80000000, 0x00008000, 0x00108020, 0x80100000,
110	0x00100020, 0x80000020, 0x00000000, 0x00108000,
111	0x00008020, 0x80108000, 0x80100000, 0x00008020,
112	0x00000000, 0x00108020, 0x80100020, 0x00100000,
113	0x80008020, 0x80100000, 0x80108000, 0x00008000,
114	0x80100000, 0x80008000, 0x00000020, 0x80108020,
115	0x00108020, 0x00000020, 0x00008000, 0x80000000,
116	0x00008020, 0x80108000, 0x00100000, 0x80000020,
117	0x00100020, 0x80008020, 0x80000020, 0x00100020,
118	0x00108000, 0x00000000, 0x80008000, 0x00008020,
119	0x80000000, 0x80100020, 0x80108020, 0x00108000
120	};
121
122	static const uint32_t SB3[64] =
123	{
124	0x00000208, 0x08020200, 0x00000000, 0x08020008,
125	0x08000200, 0x00000000, 0x00020208, 0x08000200,
126	0x00020008, 0x08000008, 0x08000008, 0x00020000,
127	0x08020208, 0x00020008, 0x08020000, 0x00000208,
128	0x08000000, 0x00000008, 0x08020200, 0x00000200,
129	0x00020200, 0x08020000, 0x08020008, 0x00020208,
130	0x08000208, 0x00020200, 0x00020000, 0x08000208,
131	0x00000008, 0x08020208, 0x00000200, 0x08000000,
132	0x08020200, 0x08000000, 0x00020008, 0x00000208,
133	0x00020000, 0x08020200, 0x08000200, 0x00000000,
134	0x00000200, 0x00020008, 0x08020208, 0x08000200,
135	0x08000008, 0x00000200, 0x00000000, 0x08020008,
136	0x08000208, 0x00020000, 0x08000000, 0x08020208,
137	0x00000008, 0x00020208, 0x00020200, 0x08000008,
138	0x08020000, 0x08000208, 0x00000208, 0x08020000,
139	0x00020208, 0x00000008, 0x08020008, 0x00020200
140	};
141
142	static const uint32_t SB4[64] =
143	{
144	0x00802001, 0x00002081, 0x00002081, 0x00000080,
145	0x00802080, 0x00800081, 0x00800001, 0x00002001,
146	0x00000000, 0x00802000, 0x00802000, 0x00802081,
147	0x00000081, 0x00000000, 0x00800080, 0x00800001,
148	0x00000001, 0x00002000, 0x00800000, 0x00802001,
149	0x00000080, 0x00800000, 0x00002001, 0x00002080,
150	0x00800081, 0x00000001, 0x00002080, 0x00800080,
151	0x00002000, 0x00802080, 0x00802081, 0x00000081,
152	0x00800080, 0x00800001, 0x00802000, 0x00802081,
153	0x00000081, 0x00000000, 0x00000000, 0x00802000,
154	0x00002080, 0x00800080, 0x00800081, 0x00000001,
155	0x00802001, 0x00002081, 0x00002081, 0x00000080,
156	0x00802081, 0x00000081, 0x00000001, 0x00002000,
157	0x00800001, 0x00002001, 0x00802080, 0x00800081,
158	0x00002001, 0x00002080, 0x00800000, 0x00802001,
159	0x00000080, 0x00800000, 0x00002000, 0x00802080
160	};
161
162	static const uint32_t SB5[64] =
163	{
164	0x00000100, 0x02080100, 0x02080000, 0x42000100,
165	0x00080000, 0x00000100, 0x40000000, 0x02080000,
166	0x40080100, 0x00080000, 0x02000100, 0x40080100,
167	0x42000100, 0x42080000, 0x00080100, 0x40000000,
168	0x02000000, 0x40080000, 0x40080000, 0x00000000,
169	0x40000100, 0x42080100, 0x42080100, 0x02000100,
170	0x42080000, 0x40000100, 0x00000000, 0x42000000,
171	0x02080100, 0x02000000, 0x42000000, 0x00080100,
172	0x00080000, 0x42000100, 0x00000100, 0x02000000,
173	0x40000000, 0x02080000, 0x42000100, 0x40080100,
174	0x02000100, 0x40000000, 0x42080000, 0x02080100,
175	0x40080100, 0x00000100, 0x02000000, 0x42080000,
176	0x42080100, 0x00080100, 0x42000000, 0x42080100,
177	0x02080000, 0x00000000, 0x40080000, 0x42000000,
178	0x00080100, 0x02000100, 0x40000100, 0x00080000,
179	0x00000000, 0x40080000, 0x02080100, 0x40000100
180	};
181
182	static const uint32_t SB6[64] =
183	{
184	0x20000010, 0x20400000, 0x00004000, 0x20404010,
185	0x20400000, 0x00000010, 0x20404010, 0x00400000,
186	0x20004000, 0x00404010, 0x00400000, 0x20000010,
187	0x00400010, 0x20004000, 0x20000000, 0x00004010,
188	0x00000000, 0x00400010, 0x20004010, 0x00004000,
189	0x00404000, 0x20004010, 0x00000010, 0x20400010,
190	0x20400010, 0x00000000, 0x00404010, 0x20404000,
191	0x00004010, 0x00404000, 0x20404000, 0x20000000,
192	0x20004000, 0x00000010, 0x20400010, 0x00404000,
193	0x20404010, 0x00400000, 0x00004010, 0x20000010,
194	0x00400000, 0x20004000, 0x20000000, 0x00004010,
195	0x20000010, 0x20404010, 0x00404000, 0x20400000,
196	0x00404010, 0x20404000, 0x00000000, 0x20400010,
197	0x00000010, 0x00004000, 0x20400000, 0x00404010,
198	0x00004000, 0x00400010, 0x20004010, 0x00000000,
199	0x20404000, 0x20000000, 0x00400010, 0x20004010
200	};
201
202	static const uint32_t SB7[64] =
203	{
204	0x00200000, 0x04200002, 0x04000802, 0x00000000,
205	0x00000800, 0x04000802, 0x00200802, 0x04200800,
206	0x04200802, 0x00200000, 0x00000000, 0x04000002,
207	0x00000002, 0x04000000, 0x04200002, 0x00000802,
208	0x04000800, 0x00200802, 0x00200002, 0x04000800,
209	0x04000002, 0x04200000, 0x04200800, 0x00200002,
210	0x04200000, 0x00000800, 0x00000802, 0x04200802,
211	0x00200800, 0x00000002, 0x04000000, 0x00200800,
212	0x04000000, 0x00200800, 0x00200000, 0x04000802,
213	0x04000802, 0x04200002, 0x04200002, 0x00000002,
214	0x00200002, 0x04000000, 0x04000800, 0x00200000,
215	0x04200800, 0x00000802, 0x00200802, 0x04200800,
216	0x00000802, 0x04000002, 0x04200802, 0x04200000,
217	0x00200800, 0x00000000, 0x00000002, 0x04200802,
218	0x00000000, 0x00200802, 0x04200000, 0x00000800,
219	0x04000002, 0x04000800, 0x00000800, 0x00200002
220	};
221
222	static const uint32_t SB8[64] =
223	{
224	0x10001040, 0x00001000, 0x00040000, 0x10041040,
225	0x10000000, 0x10001040, 0x00000040, 0x10000000,
226	0x00040040, 0x10040000, 0x10041040, 0x00041000,
227	0x10041000, 0x00041040, 0x00001000, 0x00000040,
228	0x10040000, 0x10000040, 0x10001000, 0x00001040,
229	0x00041000, 0x00040040, 0x10040040, 0x10041000,
230	0x00001040, 0x00000000, 0x00000000, 0x10040040,
231	0x10000040, 0x10001000, 0x00041040, 0x00040000,
232	0x00041040, 0x00040000, 0x10041000, 0x00001000,
233	0x00000040, 0x10040040, 0x00001000, 0x00041040,
234	0x10001000, 0x00000040, 0x10000040, 0x10040000,
235	0x10040040, 0x10000000, 0x00040000, 0x10001040,
236	0x00000000, 0x10041040, 0x00040040, 0x10000040,
237	0x10040000, 0x10001000, 0x10001040, 0x00000000,
238	0x10041040, 0x00041000, 0x00041000, 0x00001040,
239	0x00001040, 0x00040040, 0x10000000, 0x10041000
240	};
241
242	/*
243	* PC1: left and right halves bit-swap
244	*/
245	static const uint32_t LHs[16] =
246	{
247	0x00000000, 0x00000001, 0x00000100, 0x00000101,
248	0x00010000, 0x00010001, 0x00010100, 0x00010101,
249	0x01000000, 0x01000001, 0x01000100, 0x01000101,
250	0x01010000, 0x01010001, 0x01010100, 0x01010101
251	};
252
253	static const uint32_t RHs[16] =
254	{
255	0x00000000, 0x01000000, 0x00010000, 0x01010000,
256	0x00000100, 0x01000100, 0x00010100, 0x01010100,
257	0x00000001, 0x01000001, 0x00010001, 0x01010001,
258	0x00000101, 0x01000101, 0x00010101, 0x01010101,
259	};
260
261	/*
262	* Initial Permutation macro
263	*/
264	#define DES_IP(X,Y) \
265	{ \
266	T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
267	T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
268	T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
269	T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
270	Y = ((Y << 1) \| (Y >> 31)) & 0xFFFFFFFF; \
271	T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T; \
272	X = ((X << 1) \| (X >> 31)) & 0xFFFFFFFF; \
273	}
274
275	/*
276	* Final Permutation macro
277	*/
278	#define DES_FP(X,Y) \
279	{ \
280	X = ((X << 31) \| (X >> 1)) & 0xFFFFFFFF; \
281	T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T; \
282	Y = ((Y << 31) \| (Y >> 1)) & 0xFFFFFFFF; \
283	T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \
284	T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \
285	T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \
286	T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \
287	}
288
289	/*
290	* DES round macro
291	*/
292	#define DES_ROUND(X,Y) \
293	{ \
294	T = *SK++ ^ X; \
295	Y ^= SB8[ (T ) & 0x3F ] ^ \
296	SB6[ (T >> 8) & 0x3F ] ^ \
297	SB4[ (T >> 16) & 0x3F ] ^ \
298	SB2[ (T >> 24) & 0x3F ]; \
299	\
300	T = *SK++ ^ ((X << 28) \| (X >> 4)); \
301	Y ^= SB7[ (T ) & 0x3F ] ^ \
302	SB5[ (T >> 8) & 0x3F ] ^ \
303	SB3[ (T >> 16) & 0x3F ] ^ \
304	SB1[ (T >> 24) & 0x3F ]; \
305	}
306
307	#define SWAP(a,b) { uint32_t t = a; a = b; b = t; t = 0; }
308
309	void mbedtls_des_init( mbedtls_des_context *ctx )
310	{
311	memset( ctx, 0, sizeof( mbedtls_des_context ) );
312	}
313
314	void mbedtls_des_free( mbedtls_des_context *ctx )
315	{
316	if( ctx == NULL )
317	return;
318
319	mbedtls_zeroize( ctx, sizeof( mbedtls_des_context ) );
320	}
321
322	void mbedtls_des3_init( mbedtls_des3_context *ctx )
323	{
324	memset( ctx, 0, sizeof( mbedtls_des3_context ) );
325	}
326
327	void mbedtls_des3_free( mbedtls_des3_context *ctx )
328	{
329	if( ctx == NULL )
330	return;
331
332	mbedtls_zeroize( ctx, sizeof( mbedtls_des3_context ) );
333	}
334
335	static const unsigned char odd_parity_table[128] = { 1, 2, 4, 7, 8,
336	11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31, 32, 35, 37, 38, 41, 42, 44,
337	47, 49, 50, 52, 55, 56, 59, 61, 62, 64, 67, 69, 70, 73, 74, 76, 79, 81,
338	82, 84, 87, 88, 91, 93, 94, 97, 98, 100, 103, 104, 107, 109, 110, 112,
339	115, 117, 118, 121, 122, 124, 127, 128, 131, 133, 134, 137, 138, 140,
340	143, 145, 146, 148, 151, 152, 155, 157, 158, 161, 162, 164, 167, 168,
341	171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191, 193, 194, 196,
342	199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223, 224,
343	227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253,
344	254 };
345
346	void mbedtls_des_key_set_parity( unsigned char key[MBEDTLS_DES_KEY_SIZE] )
347	{
348	int i;
349
350	for( i = 0; i < MBEDTLS_DES_KEY_SIZE; i++ )
351	key[i] = odd_parity_table[key[i] / 2];
352	}
353
354	/*
355	* Check the given key's parity, returns 1 on failure, 0 on SUCCESS
356	*/
357	int mbedtls_des_key_check_key_parity( const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
358	{
359	int i;
360
361	for( i = 0; i < MBEDTLS_DES_KEY_SIZE; i++ )
362	if( key[i] != odd_parity_table[key[i] / 2] )
363	return( 1 );
364
365	return( 0 );
366	}
367
368	/*
369	* Table of weak and semi-weak keys
370	*
371	* Source: http://en.wikipedia.org/wiki/Weak_key
372	*
373	* Weak:
374	* Alternating ones + zeros (0x0101010101010101)
375	* Alternating 'F' + 'E' (0xFEFEFEFEFEFEFEFE)
376	* '0xE0E0E0E0F1F1F1F1'
377	* '0x1F1F1F1F0E0E0E0E'
378	*
379	* Semi-weak:
380	* 0x011F011F010E010E and 0x1F011F010E010E01
381	* 0x01E001E001F101F1 and 0xE001E001F101F101
382	* 0x01FE01FE01FE01FE and 0xFE01FE01FE01FE01
383	* 0x1FE01FE00EF10EF1 and 0xE01FE01FF10EF10E
384	* 0x1FFE1FFE0EFE0EFE and 0xFE1FFE1FFE0EFE0E
385	* 0xE0FEE0FEF1FEF1FE and 0xFEE0FEE0FEF1FEF1
386	*
387	*/
388
389	#define WEAK_KEY_COUNT 16
390
391	static const unsigned char weak_key_table[WEAK_KEY_COUNT][MBEDTLS_DES_KEY_SIZE] =
392	{
393	{ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
394	{ 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE },
395	{ 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
396	{ 0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1 },
397
398	{ 0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E },
399	{ 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01 },
400	{ 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1 },
401	{ 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01 },
402	{ 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE },
403	{ 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01 },
404	{ 0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1 },
405	{ 0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E },
406	{ 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE },
407	{ 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E },
408	{ 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
409	{ 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 }
410	};
411
412	int mbedtls_des_key_check_weak( const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
413	{
414	int i;
415
416	for( i = 0; i < WEAK_KEY_COUNT; i++ )
417	if( memcmp( weak_key_table[i], key, MBEDTLS_DES_KEY_SIZE) == 0 )
418	return( 1 );
419
420	return( 0 );
421	}
422
423	#if !defined(MBEDTLS_DES_SETKEY_ALT)
424	void mbedtls_des_setkey( uint32_t SK[32], const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
425	{
426	int i;
427	uint32_t X, Y, T;
428
429	GET_UINT32_BE( X, key, 0 );
430	GET_UINT32_BE( Y, key, 4 );
431
432	/*
433	* Permuted Choice 1
434	*/
435	T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
436	T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T );
437
438	X = (LHs[ (X ) & 0xF] << 3) \| (LHs[ (X >> 8) & 0xF ] << 2)
439	\| (LHs[ (X >> 16) & 0xF] << 1) \| (LHs[ (X >> 24) & 0xF ] )
440	\| (LHs[ (X >> 5) & 0xF] << 7) \| (LHs[ (X >> 13) & 0xF ] << 6)
441	\| (LHs[ (X >> 21) & 0xF] << 5) \| (LHs[ (X >> 29) & 0xF ] << 4);
442
443	Y = (RHs[ (Y >> 1) & 0xF] << 3) \| (RHs[ (Y >> 9) & 0xF ] << 2)
444	\| (RHs[ (Y >> 17) & 0xF] << 1) \| (RHs[ (Y >> 25) & 0xF ] )
445	\| (RHs[ (Y >> 4) & 0xF] << 7) \| (RHs[ (Y >> 12) & 0xF ] << 6)
446	\| (RHs[ (Y >> 20) & 0xF] << 5) \| (RHs[ (Y >> 28) & 0xF ] << 4);
447
448	X &= 0x0FFFFFFF;
449	Y &= 0x0FFFFFFF;
450
451	/*
452	* calculate subkeys
453	*/
454	for( i = 0; i < 16; i++ )
455	{
456	if( i < 2 \|\| i == 8 \|\| i == 15 )
457	{
458	X = ((X << 1) \| (X >> 27)) & 0x0FFFFFFF;
459	Y = ((Y << 1) \| (Y >> 27)) & 0x0FFFFFFF;
460	}
461	else
462	{
463	X = ((X << 2) \| (X >> 26)) & 0x0FFFFFFF;
464	Y = ((Y << 2) \| (Y >> 26)) & 0x0FFFFFFF;
465	}
466
467	*SK++ = ((X << 4) & 0x24000000) \| ((X << 28) & 0x10000000)
468	\| ((X << 14) & 0x08000000) \| ((X << 18) & 0x02080000)
469	\| ((X << 6) & 0x01000000) \| ((X << 9) & 0x00200000)
470	\| ((X >> 1) & 0x00100000) \| ((X << 10) & 0x00040000)
471	\| ((X << 2) & 0x00020000) \| ((X >> 10) & 0x00010000)
472	\| ((Y >> 13) & 0x00002000) \| ((Y >> 4) & 0x00001000)
473	\| ((Y << 6) & 0x00000800) \| ((Y >> 1) & 0x00000400)
474	\| ((Y >> 14) & 0x00000200) \| ((Y ) & 0x00000100)
475	\| ((Y >> 5) & 0x00000020) \| ((Y >> 10) & 0x00000010)
476	\| ((Y >> 3) & 0x00000008) \| ((Y >> 18) & 0x00000004)
477	\| ((Y >> 26) & 0x00000002) \| ((Y >> 24) & 0x00000001);
478
479	*SK++ = ((X << 15) & 0x20000000) \| ((X << 17) & 0x10000000)
480	\| ((X << 10) & 0x08000000) \| ((X << 22) & 0x04000000)
481	\| ((X >> 2) & 0x02000000) \| ((X << 1) & 0x01000000)
482	\| ((X << 16) & 0x00200000) \| ((X << 11) & 0x00100000)
483	\| ((X << 3) & 0x00080000) \| ((X >> 6) & 0x00040000)
484	\| ((X << 15) & 0x00020000) \| ((X >> 4) & 0x00010000)
485	\| ((Y >> 2) & 0x00002000) \| ((Y << 8) & 0x00001000)
486	\| ((Y >> 14) & 0x00000808) \| ((Y >> 9) & 0x00000400)
487	\| ((Y ) & 0x00000200) \| ((Y << 7) & 0x00000100)
488	\| ((Y >> 7) & 0x00000020) \| ((Y >> 3) & 0x00000011)
489	\| ((Y << 2) & 0x00000004) \| ((Y >> 21) & 0x00000002);
490	}
491	}
492	#endif /* !MBEDTLS_DES_SETKEY_ALT */
493
494	/*
495	* DES key schedule (56-bit, encryption)
496	*/
497	int mbedtls_des_setkey_enc( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
498	{
499	mbedtls_des_setkey( ctx->sk, key );
500
501	return( 0 );
502	}
503
504	/*
505	* DES key schedule (56-bit, decryption)
506	*/
507	int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
508	{
509	int i;
510
511	mbedtls_des_setkey( ctx->sk, key );
512
513	for( i = 0; i < 16; i += 2 )
514	{
515	SWAP( ctx->sk[i ], ctx->sk[30 - i] );
516	SWAP( ctx->sk[i + 1], ctx->sk[31 - i] );
517	}
518
519	return( 0 );
520	}
521
522	static void des3_set2key( uint32_t esk[96],
523	uint32_t dsk[96],
524	const unsigned char key[MBEDTLS_DES_KEY_SIZE*2] )
525	{
526	int i;
527
528	mbedtls_des_setkey( esk, key );
529	mbedtls_des_setkey( dsk + 32, key + 8 );
530
531	for( i = 0; i < 32; i += 2 )
532	{
533	dsk[i ] = esk[30 - i];
534	dsk[i + 1] = esk[31 - i];
535
536	esk[i + 32] = dsk[62 - i];
537	esk[i + 33] = dsk[63 - i];
538
539	esk[i + 64] = esk[i ];
540	esk[i + 65] = esk[i + 1];
541
542	dsk[i + 64] = dsk[i ];
543	dsk[i + 65] = dsk[i + 1];
544	}
545	}
546
547	/*
548	* Triple-DES key schedule (112-bit, encryption)
549	*/
550	int mbedtls_des3_set2key_enc( mbedtls_des3_context *ctx,
551	const unsigned char key[MBEDTLS_DES_KEY_SIZE * 2] )
552	{
553	uint32_t sk[96];
554
555	des3_set2key( ctx->sk, sk, key );
556	mbedtls_zeroize( sk, sizeof( sk ) );
557
558	return( 0 );
559	}
560
561	/*
562	* Triple-DES key schedule (112-bit, decryption)
563	*/
564	int mbedtls_des3_set2key_dec( mbedtls_des3_context *ctx,
565	const unsigned char key[MBEDTLS_DES_KEY_SIZE * 2] )
566	{
567	uint32_t sk[96];
568
569	des3_set2key( sk, ctx->sk, key );
570	mbedtls_zeroize( sk, sizeof( sk ) );
571
572	return( 0 );
573	}
574
575	static void des3_set3key( uint32_t esk[96],
576	uint32_t dsk[96],
577	const unsigned char key[24] )
578	{
579	int i;
580
581	mbedtls_des_setkey( esk, key );
582	mbedtls_des_setkey( dsk + 32, key + 8 );
583	mbedtls_des_setkey( esk + 64, key + 16 );
584
585	for( i = 0; i < 32; i += 2 )
586	{
587	dsk[i ] = esk[94 - i];
588	dsk[i + 1] = esk[95 - i];
589
590	esk[i + 32] = dsk[62 - i];
591	esk[i + 33] = dsk[63 - i];
592
593	dsk[i + 64] = esk[30 - i];
594	dsk[i + 65] = esk[31 - i];
595	}
596	}
597
598	/*
599	* Triple-DES key schedule (168-bit, encryption)
600	*/
601	int mbedtls_des3_set3key_enc( mbedtls_des3_context *ctx,
602	const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] )
603	{
604	uint32_t sk[96];
605
606	des3_set3key( ctx->sk, sk, key );
607	mbedtls_zeroize( sk, sizeof( sk ) );
608
609	return( 0 );
610	}
611
612	/*
613	* Triple-DES key schedule (168-bit, decryption)
614	*/
615	int mbedtls_des3_set3key_dec( mbedtls_des3_context *ctx,
616	const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] )
617	{
618	uint32_t sk[96];
619
620	des3_set3key( sk, ctx->sk, key );
621	mbedtls_zeroize( sk, sizeof( sk ) );
622
623	return( 0 );
624	}
625
626	/*
627	* DES-ECB block encryption/decryption
628	*/
629	#if !defined(MBEDTLS_DES_CRYPT_ECB_ALT)
630	int mbedtls_des_crypt_ecb( mbedtls_des_context *ctx,
631	const unsigned char input[8],
632	unsigned char output[8] )
633	{
634	int i;
635	uint32_t X, Y, T, *SK;
636
637	SK = ctx->sk;
638
639	GET_UINT32_BE( X, input, 0 );
640	GET_UINT32_BE( Y, input, 4 );
641
642	DES_IP( X, Y );
643
644	for( i = 0; i < 8; i++ )
645	{
646	DES_ROUND( Y, X );
647	DES_ROUND( X, Y );
648	}
649
650	DES_FP( Y, X );
651
652	PUT_UINT32_BE( Y, output, 0 );
653	PUT_UINT32_BE( X, output, 4 );
654
655	return( 0 );
656	}
657	#endif /* !MBEDTLS_DES_CRYPT_ECB_ALT */
658
659	#if defined(MBEDTLS_CIPHER_MODE_CBC)
660	/*
661	* DES-CBC buffer encryption/decryption
662	*/
663	int mbedtls_des_crypt_cbc( mbedtls_des_context *ctx,
664	int mode,
665	size_t length,
666	unsigned char iv[8],
667	const unsigned char *input,
668	unsigned char *output )
669	{
670	int i;
671	unsigned char temp[8];
672
673	if( length % 8 )
674	return( MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH );
675
676	if( mode == MBEDTLS_DES_ENCRYPT )
677	{
678	while( length > 0 )
679	{
680	for( i = 0; i < 8; i++ )
681	output[i] = (unsigned char)( input[i] ^ iv[i] );
682
683	mbedtls_des_crypt_ecb( ctx, output, output );
684	memcpy( iv, output, 8 );
685
686	input += 8;
687	output += 8;
688	length -= 8;
689	}
690	}
691	else /* MBEDTLS_DES_DECRYPT */
692	{
693	while( length > 0 )
694	{
695	memcpy( temp, input, 8 );
696	mbedtls_des_crypt_ecb( ctx, input, output );
697
698	for( i = 0; i < 8; i++ )
699	output[i] = (unsigned char)( output[i] ^ iv[i] );
700
701	memcpy( iv, temp, 8 );
702
703	input += 8;
704	output += 8;
705	length -= 8;
706	}
707	}
708
709	return( 0 );
710	}
711	#endif /* MBEDTLS_CIPHER_MODE_CBC */
712
713	/*
714	* 3DES-ECB block encryption/decryption
715	*/
716	#if !defined(MBEDTLS_DES3_CRYPT_ECB_ALT)
717	int mbedtls_des3_crypt_ecb( mbedtls_des3_context *ctx,
718	const unsigned char input[8],
719	unsigned char output[8] )
720	{
721	int i;
722	uint32_t X, Y, T, *SK;
723
724	SK = ctx->sk;
725
726	GET_UINT32_BE( X, input, 0 );
727	GET_UINT32_BE( Y, input, 4 );
728
729	DES_IP( X, Y );
730
731	for( i = 0; i < 8; i++ )
732	{
733	DES_ROUND( Y, X );
734	DES_ROUND( X, Y );
735	}
736
737	for( i = 0; i < 8; i++ )
738	{
739	DES_ROUND( X, Y );
740	DES_ROUND( Y, X );
741	}
742
743	for( i = 0; i < 8; i++ )
744	{
745	DES_ROUND( Y, X );
746	DES_ROUND( X, Y );
747	}
748
749	DES_FP( Y, X );
750
751	PUT_UINT32_BE( Y, output, 0 );
752	PUT_UINT32_BE( X, output, 4 );
753
754	return( 0 );
755	}
756	#endif /* !MBEDTLS_DES3_CRYPT_ECB_ALT */
757
758	#if defined(MBEDTLS_CIPHER_MODE_CBC)
759	/*
760	* 3DES-CBC buffer encryption/decryption
761	*/
762	int mbedtls_des3_crypt_cbc( mbedtls_des3_context *ctx,
763	int mode,
764	size_t length,
765	unsigned char iv[8],
766	const unsigned char *input,
767	unsigned char *output )
768	{
769	int i;
770	unsigned char temp[8];
771
772	if( length % 8 )
773	return( MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH );
774
775	if( mode == MBEDTLS_DES_ENCRYPT )
776	{
777	while( length > 0 )
778	{
779	for( i = 0; i < 8; i++ )
780	output[i] = (unsigned char)( input[i] ^ iv[i] );
781
782	mbedtls_des3_crypt_ecb( ctx, output, output );
783	memcpy( iv, output, 8 );
784
785	input += 8;
786	output += 8;
787	length -= 8;
788	}
789	}
790	else /* MBEDTLS_DES_DECRYPT */
791	{
792	while( length > 0 )
793	{
794	memcpy( temp, input, 8 );
795	mbedtls_des3_crypt_ecb( ctx, input, output );
796
797	for( i = 0; i < 8; i++ )
798	output[i] = (unsigned char)( output[i] ^ iv[i] );
799
800	memcpy( iv, temp, 8 );
801
802	input += 8;
803	output += 8;
804	length -= 8;
805	}
806	}
807
808	return( 0 );
809	}
810	#endif /* MBEDTLS_CIPHER_MODE_CBC */
811
812	#endif /* !MBEDTLS_DES_ALT */
813
814	#if defined(MBEDTLS_SELF_TEST)
815	/*
816	* DES and 3DES test vectors from:
817	*
818	* http://csrc.nist.gov/groups/STM/cavp/documents/des/tripledes-vectors.zip
819	*/
820	static const unsigned char des3_test_keys[24] =
821	{
822	0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
823	0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
824	0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23
825	};
826
827	static const unsigned char des3_test_buf[8] =
828	{
829	0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74
830	};
831
832	static const unsigned char des3_test_ecb_dec[3][8] =
833	{
834	{ 0xCD, 0xD6, 0x4F, 0x2F, 0x94, 0x27, 0xC1, 0x5D },
835	{ 0x69, 0x96, 0xC8, 0xFA, 0x47, 0xA2, 0xAB, 0xEB },
836	{ 0x83, 0x25, 0x39, 0x76, 0x44, 0x09, 0x1A, 0x0A }
837	};
838
839	static const unsigned char des3_test_ecb_enc[3][8] =
840	{
841	{ 0x6A, 0x2A, 0x19, 0xF4, 0x1E, 0xCA, 0x85, 0x4B },
842	{ 0x03, 0xE6, 0x9F, 0x5B, 0xFA, 0x58, 0xEB, 0x42 },
843	{ 0xDD, 0x17, 0xE8, 0xB8, 0xB4, 0x37, 0xD2, 0x32 }
844	};
845
846	#if defined(MBEDTLS_CIPHER_MODE_CBC)
847	static const unsigned char des3_test_iv[8] =
848	{
849	0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF,
850	};
851
852	static const unsigned char des3_test_cbc_dec[3][8] =
853	{
854	{ 0x12, 0x9F, 0x40, 0xB9, 0xD2, 0x00, 0x56, 0xB3 },
855	{ 0x47, 0x0E, 0xFC, 0x9A, 0x6B, 0x8E, 0xE3, 0x93 },
856	{ 0xC5, 0xCE, 0xCF, 0x63, 0xEC, 0xEC, 0x51, 0x4C }
857	};
858
859	static const unsigned char des3_test_cbc_enc[3][8] =
860	{
861	{ 0x54, 0xF1, 0x5A, 0xF6, 0xEB, 0xE3, 0xA4, 0xB4 },
862	{ 0x35, 0x76, 0x11, 0x56, 0x5F, 0xA1, 0x8E, 0x4D },
863	{ 0xCB, 0x19, 0x1F, 0x85, 0xD1, 0xED, 0x84, 0x39 }
864	};
865	#endif /* MBEDTLS_CIPHER_MODE_CBC */
866
867	/*
868	* Checkup routine
869	*/
870	int mbedtls_des_self_test( int verbose )
871	{
872	int i, j, u, v, ret = 0;
873	mbedtls_des_context ctx;
874	mbedtls_des3_context ctx3;
875	unsigned char buf[8];
876	#if defined(MBEDTLS_CIPHER_MODE_CBC)
877	unsigned char prv[8];
878	unsigned char iv[8];
879	#endif
880
881	mbedtls_des_init( &ctx );
882	mbedtls_des3_init( &ctx3 );
883	/*
884	* ECB mode
885	*/
886	for( i = 0; i < 6; i++ )
887	{
888	u = i >> 1;
889	v = i & 1;
890
891	if( verbose != 0 )
892	mbedtls_printf( " DES%c-ECB-%3d (%s): ",
893	( u == 0 ) ? ' ' : '3', 56 + u * 56,
894	( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" );
895
896	memcpy( buf, des3_test_buf, 8 );
897
898	switch( i )
899	{
900	case 0:
901	mbedtls_des_setkey_dec( &ctx, des3_test_keys );
902	break;
903
904	case 1:
905	mbedtls_des_setkey_enc( &ctx, des3_test_keys );
906	break;
907
908	case 2:
909	mbedtls_des3_set2key_dec( &ctx3, des3_test_keys );
910	break;
911
912	case 3:
913	mbedtls_des3_set2key_enc( &ctx3, des3_test_keys );
914	break;
915
916	case 4:
917	mbedtls_des3_set3key_dec( &ctx3, des3_test_keys );
918	break;
919
920	case 5:
921	mbedtls_des3_set3key_enc( &ctx3, des3_test_keys );
922	break;
923
924	default:
925	return( 1 );
926	}
927
928	for( j = 0; j < 10000; j++ )
929	{
930	if( u == 0 )
931	mbedtls_des_crypt_ecb( &ctx, buf, buf );
932	else
933	mbedtls_des3_crypt_ecb( &ctx3, buf, buf );
934	}
935
936	if( ( v == MBEDTLS_DES_DECRYPT &&
937	memcmp( buf, des3_test_ecb_dec[u], 8 ) != 0 ) \|\|
938	( v != MBEDTLS_DES_DECRYPT &&
939	memcmp( buf, des3_test_ecb_enc[u], 8 ) != 0 ) )
940	{
941	if( verbose != 0 )
942	mbedtls_printf( "failed\n" );
943
944	ret = 1;
945	goto exit;
946	}
947
948	if( verbose != 0 )
949	mbedtls_printf( "passed\n" );
950	}
951
952	if( verbose != 0 )
953	mbedtls_printf( "\n" );
954
955	#if defined(MBEDTLS_CIPHER_MODE_CBC)
956	/*
957	* CBC mode
958	*/
959	for( i = 0; i < 6; i++ )
960	{
961	u = i >> 1;
962	v = i & 1;
963
964	if( verbose != 0 )
965	mbedtls_printf( " DES%c-CBC-%3d (%s): ",
966	( u == 0 ) ? ' ' : '3', 56 + u * 56,
967	( v == MBEDTLS_DES_DECRYPT ) ? "dec" : "enc" );
968
969	memcpy( iv, des3_test_iv, 8 );
970	memcpy( prv, des3_test_iv, 8 );
971	memcpy( buf, des3_test_buf, 8 );
972
973	switch( i )
974	{
975	case 0:
976	mbedtls_des_setkey_dec( &ctx, des3_test_keys );
977	break;
978
979	case 1:
980	mbedtls_des_setkey_enc( &ctx, des3_test_keys );
981	break;
982
983	case 2:
984	mbedtls_des3_set2key_dec( &ctx3, des3_test_keys );
985	break;
986
987	case 3:
988	mbedtls_des3_set2key_enc( &ctx3, des3_test_keys );
989	break;
990
991	case 4:
992	mbedtls_des3_set3key_dec( &ctx3, des3_test_keys );
993	break;
994
995	case 5:
996	mbedtls_des3_set3key_enc( &ctx3, des3_test_keys );
997	break;
998
999	default:
1000	return( 1 );
1001	}
1002
1003	if( v == MBEDTLS_DES_DECRYPT )
1004	{
1005	for( j = 0; j < 10000; j++ )
1006	{
1007	if( u == 0 )
1008	mbedtls_des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
1009	else
1010	mbedtls_des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
1011	}
1012	}
1013	else
1014	{
1015	for( j = 0; j < 10000; j++ )
1016	{
1017	unsigned char tmp[8];
1018
1019	if( u == 0 )
1020	mbedtls_des_crypt_cbc( &ctx, v, 8, iv, buf, buf );
1021	else
1022	mbedtls_des3_crypt_cbc( &ctx3, v, 8, iv, buf, buf );
1023
1024	memcpy( tmp, prv, 8 );
1025	memcpy( prv, buf, 8 );
1026	memcpy( buf, tmp, 8 );
1027	}
1028
1029	memcpy( buf, prv, 8 );
1030	}
1031
1032	if( ( v == MBEDTLS_DES_DECRYPT &&
1033	memcmp( buf, des3_test_cbc_dec[u], 8 ) != 0 ) \|\|
1034	( v != MBEDTLS_DES_DECRYPT &&
1035	memcmp( buf, des3_test_cbc_enc[u], 8 ) != 0 ) )
1036	{
1037	if( verbose != 0 )
1038	mbedtls_printf( "failed\n" );
1039
1040	ret = 1;
1041	goto exit;
1042	}
1043
1044	if( verbose != 0 )
1045	mbedtls_printf( "passed\n" );
1046	}
1047	#endif /* MBEDTLS_CIPHER_MODE_CBC */
1048
1049	if( verbose != 0 )
1050	mbedtls_printf( "\n" );
1051
1052	exit:
1053	mbedtls_des_free( &ctx );
1054	mbedtls_des3_free( &ctx3 );
1055
1056	return( ret );
1057	}
1058
1059	#endif /* MBEDTLS_SELF_TEST */
1060
1061	#endif /* MBEDTLS_DES_C */

Note: See TracBrowser for help on using the repository browser.

This Trac instance is not used for development anymore!

Context Navigation

source: ps/trunk/build/premake/premake5/contrib/mbedtls/library/des.c

Download in other formats: