UltraGrid
UltraGrid Low-Latency High-Resolution Transmission System
Loading...
Searching...
No Matches
Macros | Typedefs | Functions | Variables
crypt_des.c File Reference
#include "config.h"
#include "config_unix.h"
#include "config_win32.h"
#include "crypto/crypt_des.h"
#include "crypto/random.h"
Include dependency graph for crypt_des.c:

Go to the source code of this file.

Macros

#define B00   0x80000000
 
#define B01   0x40000000
 
#define B02   0x20000000
 
#define B03   0x10000000
 
#define B04   0x08000000
 
#define B05   0x04000000
 
#define B06   0x02000000
 
#define B07   0x01000000
 
#define B08   0x00800000
 
#define B09   0x00400000
 
#define B10   0x00200000
 
#define B11   0x00100000
 
#define B12   0x00080000
 
#define B13   0x00040000
 
#define B14   0x00020000
 
#define B15   0x00010000
 
#define B16   0x00008000
 
#define B17   0x00004000
 
#define B18   0x00002000
 
#define B19   0x00001000
 
#define B20   0x00000800
 
#define B21   0x00000400
 
#define B22   0x00000200
 
#define B23   0x00000100
 
#define B24   0x00000080
 
#define B25   0x00000040
 
#define B26   0x00000020
 
#define B27   0x00000010
 
#define B28   0x00000008
 
#define B29   0x00000004
 
#define B30   0x00000002
 
#define B31   0x00000001
 
#define DES(t, ik)
 
#define FINAL_PERMUTATION(regR, regL, t)
 
#define FINAL_PERMUTATION_AUX(_i0, _i1, _o0, _o1)
 
#define INITIAL_PERMUTATION(t, regL, regR)
 
#define INITIAL_PERMUTATION_AUX(_i0, _i1, _o0, _o1)
 
#define MAKE_LITTLE_ENDIAN(t, s)
 
#define PC1(k, regC, regD)
 
#define PC1_AUX(_i0, _i1, _o0, _o1)
 
#define PC2(regC, regD, k)
 
#define PC2_AUX(_i0, _i1, _o0, _o1)
 

Typedefs

typedef unsigned int Word
 

Functions

int qfDES (unsigned char *key, unsigned char *data, unsigned int size, const QFDES_what what, const QFDES_mode mode, unsigned char *initVec)
 
unsigned int qfDES_checkParity (unsigned char *ptr, unsigned int size, const QFDES_parity parity)
 
int qfDES_checkWeakKeys (unsigned char *key)
 
unsigned char * qfDES_generate (const QFDES_generate what)
 
unsigned char qfDES_setPad (unsigned char pad)
 
void qfDES_setParity (unsigned char *ptr, unsigned int size, const QFDES_parity parity)
 
static Word ROTATE_LEFT (Word x)
 
static Word ROTATE_RIGHT (Word x)
 

Variables

unsigned char G_padChar = (char)0
 
static Word s_p0 [64]
 
static Word s_p1 [64]
 
static Word s_p2 [64]
 
static Word s_p3 [64]
 
static Word s_p4 [64]
 
static Word s_p5 [64]
 
static Word s_p6 [64]
 
static Word s_p7 [64]
 
static unsigned char weakKeys [18][8]
 

Macro Definition Documentation

◆ B00

#define B00   0x80000000

Definition at line 18 of file crypt_des.c.

◆ B01

#define B01   0x40000000

Definition at line 19 of file crypt_des.c.

◆ B02

#define B02   0x20000000

Definition at line 20 of file crypt_des.c.

◆ B03

#define B03   0x10000000

Definition at line 21 of file crypt_des.c.

◆ B04

#define B04   0x08000000

Definition at line 22 of file crypt_des.c.

◆ B05

#define B05   0x04000000

Definition at line 23 of file crypt_des.c.

◆ B06

#define B06   0x02000000

Definition at line 24 of file crypt_des.c.

◆ B07

#define B07   0x01000000

Definition at line 25 of file crypt_des.c.

◆ B08

#define B08   0x00800000

Definition at line 26 of file crypt_des.c.

◆ B09

#define B09   0x00400000

Definition at line 27 of file crypt_des.c.

◆ B10

#define B10   0x00200000

Definition at line 28 of file crypt_des.c.

◆ B11

#define B11   0x00100000

Definition at line 29 of file crypt_des.c.

◆ B12

#define B12   0x00080000

Definition at line 30 of file crypt_des.c.

◆ B13

#define B13   0x00040000

Definition at line 31 of file crypt_des.c.

◆ B14

#define B14   0x00020000

Definition at line 32 of file crypt_des.c.

◆ B15

#define B15   0x00010000

Definition at line 33 of file crypt_des.c.

◆ B16

#define B16   0x00008000

Definition at line 34 of file crypt_des.c.

◆ B17

#define B17   0x00004000

Definition at line 35 of file crypt_des.c.

◆ B18

#define B18   0x00002000

Definition at line 36 of file crypt_des.c.

◆ B19

#define B19   0x00001000

Definition at line 37 of file crypt_des.c.

◆ B20

#define B20   0x00000800

Definition at line 38 of file crypt_des.c.

◆ B21

#define B21   0x00000400

Definition at line 39 of file crypt_des.c.

◆ B22

#define B22   0x00000200

Definition at line 40 of file crypt_des.c.

◆ B23

#define B23   0x00000100

Definition at line 41 of file crypt_des.c.

◆ B24

#define B24   0x00000080

Definition at line 42 of file crypt_des.c.

◆ B25

#define B25   0x00000040

Definition at line 43 of file crypt_des.c.

◆ B26

#define B26   0x00000020

Definition at line 44 of file crypt_des.c.

◆ B27

#define B27   0x00000010

Definition at line 45 of file crypt_des.c.

◆ B28

#define B28   0x00000008

Definition at line 46 of file crypt_des.c.

◆ B29

#define B29   0x00000004

Definition at line 47 of file crypt_des.c.

◆ B30

#define B30   0x00000002

Definition at line 48 of file crypt_des.c.

◆ B31

#define B31   0x00000001

Definition at line 49 of file crypt_des.c.

◆ DES

#define DES ( t,
ik )
Value:
{ \
register Word l, r, reg32, round; \
register unsigned char *bb; \
INITIAL_PERMUTATION(t, l, r); \
for(bb = (unsigned char *) ik, round = 0x8000; round; bb += 8, round >>= 1) { \
register Word w = (r << 1) | (r >> 31); \
reg32 = s_p7[( w & 0x3f) ^ bb[4]]; \
reg32 |= s_p6[((w >>= 4) & 0x3f) ^ bb[5]]; \
reg32 |= s_p5[((w >>= 4) & 0x3f) ^ bb[6]]; \
reg32 |= s_p4[((w >>= 4) & 0x3f) ^ bb[7]]; \
reg32 |= s_p3[((w >>= 4) & 0x3f) ^ bb[0]]; \
reg32 |= s_p2[((w >>= 4) & 0x3f) ^ bb[1]]; \
reg32 |= s_p1[((w >> 4) & 0x3f) ^ bb[2]]; \
reg32 |= s_p0[(((r & 0x1) << 5) | ((r & 0xf8000000) >> 27)) ^ bb[3]]; \
reg32 ^= l; \
l = r; \
r = reg32; \
} \
FINAL_PERMUTATION(r, l, t); \
}
s_p3
static Word s_p3[64]
Definition crypt_des.c:366
s_p5
static Word s_p5[64]
Definition crypt_des.c:406
s_p2
static Word s_p2[64]
Definition crypt_des.c:346
s_p4
static Word s_p4[64]
Definition crypt_des.c:386
s_p1
static Word s_p1[64]
Definition crypt_des.c:326
s_p6
static Word s_p6[64]
Definition crypt_des.c:426
s_p0
static Word s_p0[64]
Definition crypt_des.c:306
Word
unsigned int Word
Definition crypt_des.c:16
s_p7
static Word s_p7[64]
Definition crypt_des.c:446
round
static __device__ vec3 round(const vec3 &v)
Definition cuda_dxt.cu:122

Definition at line 502 of file crypt_des.c.

502#define DES(t, ik) \
503{ \
504 register Word l, r, reg32, round; \
505 register unsigned char *bb; \
506 INITIAL_PERMUTATION(t, l, r); \
507 for(bb = (unsigned char *) ik, round = 0x8000; round; bb += 8, round >>= 1) { \
508 register Word w = (r << 1) | (r >> 31); \
509 reg32 = s_p7[( w & 0x3f) ^ bb[4]]; \
510 reg32 |= s_p6[((w >>= 4) & 0x3f) ^ bb[5]]; \
511 reg32 |= s_p5[((w >>= 4) & 0x3f) ^ bb[6]]; \
512 reg32 |= s_p4[((w >>= 4) & 0x3f) ^ bb[7]]; \
513 reg32 |= s_p3[((w >>= 4) & 0x3f) ^ bb[0]]; \
514 reg32 |= s_p2[((w >>= 4) & 0x3f) ^ bb[1]]; \
515 reg32 |= s_p1[((w >> 4) & 0x3f) ^ bb[2]]; \
516 reg32 |= s_p0[(((r & 0x1) << 5) | ((r & 0xf8000000) >> 27)) ^ bb[3]]; \
517 reg32 ^= l; \
518 l = r; \
519 r = reg32; \
520 } \
521 FINAL_PERMUTATION(r, l, t); \
522}

Referenced by qfDES().

◆ FINAL_PERMUTATION

#define FINAL_PERMUTATION ( regR,
regL,
t )
Value:
FINAL_PERMUTATION_AUX(regR, regL, t[0], t[1])
FINAL_PERMUTATION_AUX
#define FINAL_PERMUTATION_AUX(_i0, _i1, _o0, _o1)
Definition crypt_des.c:120

Definition at line 468 of file crypt_des.c.

468#define FINAL_PERMUTATION(regR, regL, t) \
469 FINAL_PERMUTATION_AUX(regR, regL, t[0], t[1])

◆ FINAL_PERMUTATION_AUX

#define FINAL_PERMUTATION_AUX ( _i0,
_i1,
_o0,
_o1 )

Definition at line 120 of file crypt_des.c.

120#define FINAL_PERMUTATION_AUX(_i0, _i1, _o0, _o1) \
121{ \
122_o0 = _o1 = 0; \
123_o0 |= (_i1 & B07) << 7; /* 40 */ \
124_o0 |= (_i0 & B07) << 6; /* 8 */ \
125_o0 |= (_i1 & B15) << 13; /* 48 */ \
126_o0 |= (_i0 & B15) << 12; /* 16 */ \
127_o0 |= (_i1 & B23) << 19; /* 56 */ \
128_o0 |= (_i0 & B23) << 18; /* 24 */ \
129_o0 |= (_i1 & B31) << 25; /* 64 */ \
130_o0 |= (_i0 & B31) << 24; /* 32 */ \
131_o0 |= (_i1 & B06) >> 2; /* 39 */ \
132_o0 |= (_i0 & B06) >> 3; /* 7 */ \
133_o0 |= (_i1 & B14) << 4; /* 47 */ \
134_o0 |= (_i0 & B14) << 3; /* 15 */ \
135_o0 |= (_i1 & B22) << 10; /* 55 */ \
136_o0 |= (_i0 & B22) << 9; /* 23 */ \
137_o0 |= (_i1 & B30) << 16; /* 63 */ \
138_o0 |= (_i0 & B30) << 15; /* 31 */ \
139_o0 |= (_i1 & B05) >> 11; /* 38 */ \
140_o0 |= (_i0 & B05) >> 12; /* 6 */ \
141_o0 |= (_i1 & B13) >> 5; /* 46 */ \
142_o0 |= (_i0 & B13) >> 6; /* 14 */ \
143_o0 |= (_i1 & B21) << 1; /* 54 */ \
144_o0 |= (_i0 & B21) ; /* 22 */ \
145_o0 |= (_i1 & B29) << 7; /* 62 */ \
146_o0 |= (_i0 & B29) << 6; /* 30 */ \
147_o0 |= (_i1 & B04) >> 20; /* 37 */ \
148_o0 |= (_i0 & B04) >> 21; /* 5 */ \
149_o0 |= (_i1 & B12) >> 14; /* 45 */ \
150_o0 |= (_i0 & B12) >> 15; /* 13 */ \
151_o0 |= (_i1 & B20) >> 8; /* 53 */ \
152_o0 |= (_i0 & B20) >> 9; /* 21 */ \
153_o0 |= (_i1 & B28) >> 2; /* 61 */ \
154_o0 |= (_i0 & B28) >> 3; /* 29 */ \
155_o1 |= (_i1 & B03) << 3; /* 36 */ \
156_o1 |= (_i0 & B03) << 2; /* 4 */ \
157_o1 |= (_i1 & B11) << 9; /* 44 */ \
158_o1 |= (_i0 & B11) << 8; /* 12 */ \
159_o1 |= (_i1 & B19) << 15; /* 52 */ \
160_o1 |= (_i0 & B19) << 14; /* 20 */ \
161_o1 |= (_i1 & B27) << 21; /* 60 */ \
162_o1 |= (_i0 & B27) << 20; /* 28 */ \
163_o1 |= (_i1 & B02) >> 6; /* 35 */ \
164_o1 |= (_i0 & B02) >> 7; /* 3 */ \
165_o1 |= (_i1 & B10) ; /* 43 */ \
166_o1 |= (_i0 & B10) >> 1; /* 11 */ \
167_o1 |= (_i1 & B18) << 6; /* 51 */ \
168_o1 |= (_i0 & B18) << 5; /* 19 */ \
169_o1 |= (_i1 & B26) << 12; /* 59 */ \
170_o1 |= (_i0 & B26) << 11; /* 27 */ \
171_o1 |= (_i1 & B01) >> 15; /* 34 */ \
172_o1 |= (_i0 & B01) >> 16; /* 2 */ \
173_o1 |= (_i1 & B09) >> 9; /* 42 */ \
174_o1 |= (_i0 & B09) >> 10; /* 10 */ \
175_o1 |= (_i1 & B17) >> 3; /* 50 */ \
176_o1 |= (_i0 & B17) >> 4; /* 18 */ \
177_o1 |= (_i1 & B25) << 3; /* 58 */ \
178_o1 |= (_i0 & B25) << 2; /* 26 */ \
179_o1 |= (_i1 & B00) >> 24; /* 33 */ \
180_o1 |= (_i0 & B00) >> 25; /* 1 */ \
181_o1 |= (_i1 & B08) >> 18; /* 41 */ \
182_o1 |= (_i0 & B08) >> 19; /* 9 */ \
183_o1 |= (_i1 & B16) >> 12; /* 49 */ \
184_o1 |= (_i0 & B16) >> 13; /* 17 */ \
185_o1 |= (_i1 & B24) >> 6; /* 57 */ \
186_o1 |= (_i0 & B24) >> 7; /* 25 */ \
187}

◆ INITIAL_PERMUTATION

#define INITIAL_PERMUTATION ( t,
regL,
regR )
Value:
INITIAL_PERMUTATION_AUX(t[0], t[1], regL, regR)
INITIAL_PERMUTATION_AUX
#define INITIAL_PERMUTATION_AUX(_i0, _i1, _o0, _o1)
Definition crypt_des.c:51

Definition at line 465 of file crypt_des.c.

465#define INITIAL_PERMUTATION(t, regL, regR) \
466 INITIAL_PERMUTATION_AUX(t[0], t[1], regL, regR)

◆ INITIAL_PERMUTATION_AUX

#define INITIAL_PERMUTATION_AUX ( _i0,
_i1,
_o0,
_o1 )

Definition at line 51 of file crypt_des.c.

51#define INITIAL_PERMUTATION_AUX(_i0, _i1, _o0, _o1) \
52{ \
53_o0 = _o1 = 0; \
54_o0 |= (_i1 & B25) << 25; /* 58 */ \
55_o0 |= (_i1 & B17) << 16; /* 50 */ \
56_o0 |= (_i1 & B09) << 7; /* 42 */ \
57_o0 |= (_i1 & B01) >> 2; /* 34 */ \
58_o0 |= (_i0 & B25) << 21; /* 26 */ \
59_o0 |= (_i0 & B17) << 12; /* 18 */ \
60_o0 |= (_i0 & B09) << 3; /* 10 */ \
61_o0 |= (_i0 & B01) >> 6; /* 2 */ \
62_o0 |= (_i1 & B27) << 19; /* 60 */ \
63_o0 |= (_i1 & B19) << 10; /* 52 */ \
64_o0 |= (_i1 & B11) << 1; /* 44 */ \
65_o0 |= (_i1 & B03) >> 8; /* 36 */ \
66_o0 |= (_i0 & B27) << 15; /* 28 */ \
67_o0 |= (_i0 & B19) << 6; /* 20 */ \
68_o0 |= (_i0 & B11) >> 3; /* 12 */ \
69_o0 |= (_i0 & B03) >> 12; /* 4 */ \
70_o0 |= (_i1 & B29) << 13; /* 62 */ \
71_o0 |= (_i1 & B21) << 4; /* 54 */ \
72_o0 |= (_i1 & B13) >> 5; /* 46 */ \
73_o0 |= (_i1 & B05) >> 14; /* 38 */ \
74_o0 |= (_i0 & B29) << 9; /* 30 */ \
75_o0 |= (_i0 & B21) ; /* 22 */ \
76_o0 |= (_i0 & B13) >> 9; /* 14 */ \
77_o0 |= (_i0 & B05) >> 18; /* 6 */ \
78_o0 |= (_i1 & B31) << 7; /* 64 */ \
79_o0 |= (_i1 & B23) >> 2; /* 56 */ \
80_o0 |= (_i1 & B15) >> 11; /* 48 */ \
81_o0 |= (_i1 & B07) >> 20; /* 40 */ \
82_o0 |= (_i0 & B31) << 3; /* 32 */ \
83_o0 |= (_i0 & B23) >> 6; /* 24 */ \
84_o0 |= (_i0 & B15) >> 15; /* 16 */ \
85_o0 |= (_i0 & B07) >> 24; /* 8 */ \
86_o1 |= (_i1 & B24) << 24; /* 57 */ \
87_o1 |= (_i1 & B16) << 15; /* 49 */ \
88_o1 |= (_i1 & B08) << 6; /* 41 */ \
89_o1 |= (_i1 & B00) >> 3; /* 33 */ \
90_o1 |= (_i0 & B24) << 20; /* 25 */ \
91_o1 |= (_i0 & B16) << 11; /* 17 */ \
92_o1 |= (_i0 & B08) << 2; /* 9 */ \
93_o1 |= (_i0 & B00) >> 7; /* 1 */ \
94_o1 |= (_i1 & B26) << 18; /* 59 */ \
95_o1 |= (_i1 & B18) << 9; /* 51 */ \
96_o1 |= (_i1 & B10) ; /* 43 */ \
97_o1 |= (_i1 & B02) >> 9; /* 35 */ \
98_o1 |= (_i0 & B26) << 14; /* 27 */ \
99_o1 |= (_i0 & B18) << 5; /* 19 */ \
100_o1 |= (_i0 & B10) >> 4; /* 11 */ \
101_o1 |= (_i0 & B02) >> 13; /* 3 */ \
102_o1 |= (_i1 & B28) << 12; /* 61 */ \
103_o1 |= (_i1 & B20) << 3; /* 53 */ \
104_o1 |= (_i1 & B12) >> 6; /* 45 */ \
105_o1 |= (_i1 & B04) >> 15; /* 37 */ \
106_o1 |= (_i0 & B28) << 8; /* 29 */ \
107_o1 |= (_i0 & B20) >> 1; /* 21 */ \
108_o1 |= (_i0 & B12) >> 10; /* 13 */ \
109_o1 |= (_i0 & B04) >> 19; /* 5 */ \
110_o1 |= (_i1 & B30) << 6; /* 63 */ \
111_o1 |= (_i1 & B22) >> 3; /* 55 */ \
112_o1 |= (_i1 & B14) >> 12; /* 47 */ \
113_o1 |= (_i1 & B06) >> 21; /* 39 */ \
114_o1 |= (_i0 & B30) << 2; /* 31 */ \
115_o1 |= (_i0 & B22) >> 7; /* 23 */ \
116_o1 |= (_i0 & B14) >> 16; /* 15 */ \
117_o1 |= (_i0 & B06) >> 25; /* 7 */ \
118}

◆ MAKE_LITTLE_ENDIAN

#define MAKE_LITTLE_ENDIAN ( t,
s )
Value:
{ \
register unsigned int z, l = s/4; \
register Word *tp = (Word *)(void *) t; \
for(z = 0; z < l; ++z) tp[z] = htonl(tp[z]); \
}

Definition at line 524 of file crypt_des.c.

524#define MAKE_LITTLE_ENDIAN(t, s) \
525{ \
526 register unsigned int z, l = s/4; \
527 register Word *tp = (Word *)(void *) t; \
528 for(z = 0; z < l; ++z) tp[z] = htonl(tp[z]); \
529}

Referenced by qfDES().

◆ PC1

#define PC1 ( k,
regC,
regD )
Value:
PC1_AUX(k[0], k[1], regC, regD)
PC1_AUX
#define PC1_AUX(_i0, _i1, _o0, _o1)
Definition crypt_des.c:190

Definition at line 471 of file crypt_des.c.

471#define PC1(k, regC, regD) \
472 PC1_AUX(k[0], k[1], regC, regD)

Referenced by qfDES().

◆ PC1_AUX

#define PC1_AUX ( _i0,
_i1,
_o0,
_o1 )

Definition at line 190 of file crypt_des.c.

190#define PC1_AUX(_i0, _i1, _o0, _o1) \
191{ \
192_o0 = _o1 = 0; \
193_o0 |= (_i1 & B24) << 24; /* 57 */ \
194_o0 |= (_i1 & B16) << 15; /* 49 */ \
195_o0 |= (_i1 & B08) << 6; /* 41 */ \
196_o0 |= (_i1 & B00) >> 3; /* 33 */ \
197_o0 |= (_i0 & B24) << 20; /* 25 */ \
198_o0 |= (_i0 & B16) << 11; /* 17 */ \
199_o0 |= (_i0 & B08) << 2; /* 9 */ \
200_o0 |= (_i0 & B00) >> 7; /* 1 */ \
201_o0 |= (_i1 & B25) << 17; /* 58 */ \
202_o0 |= (_i1 & B17) << 8; /* 50 */ \
203_o0 |= (_i1 & B09) >> 1; /* 42 */ \
204_o0 |= (_i1 & B01) >> 10; /* 34 */ \
205_o0 |= (_i0 & B25) << 13; /* 26 */ \
206_o0 |= (_i0 & B17) << 4; /* 18 */ \
207_o0 |= (_i0 & B09) >> 5; /* 10 */ \
208_o0 |= (_i0 & B01) >> 14; /* 2 */ \
209_o0 |= (_i1 & B26) << 10; /* 59 */ \
210_o0 |= (_i1 & B18) << 1; /* 51 */ \
211_o0 |= (_i1 & B10) >> 8; /* 43 */ \
212_o0 |= (_i1 & B02) >> 17; /* 35 */ \
213_o0 |= (_i0 & B26) << 6; /* 27 */ \
214_o0 |= (_i0 & B18) >> 3; /* 19 */ \
215_o0 |= (_i0 & B10) >> 12; /* 11 */ \
216_o0 |= (_i0 & B02) >> 21; /* 3 */ \
217_o0 |= (_i1 & B27) << 3; /* 60 */ \
218_o0 |= (_i1 & B19) >> 6; /* 52 */ \
219_o0 |= (_i1 & B11) >> 15; /* 44 */ \
220_o0 |= (_i1 & B03) >> 24; /* 36 */ \
221_o1 |= (_i1 & B30) << 30; /* 63 */ \
222_o1 |= (_i1 & B22) << 21; /* 55 */ \
223_o1 |= (_i1 & B14) << 12; /* 47 */ \
224_o1 |= (_i1 & B06) << 3; /* 39 */ \
225_o1 |= (_i0 & B30) << 26; /* 31 */ \
226_o1 |= (_i0 & B22) << 17; /* 23 */ \
227_o1 |= (_i0 & B14) << 8; /* 15 */ \
228_o1 |= (_i0 & B06) >> 1; /* 7 */ \
229_o1 |= (_i1 & B29) << 21; /* 62 */ \
230_o1 |= (_i1 & B21) << 12; /* 54 */ \
231_o1 |= (_i1 & B13) << 3; /* 46 */ \
232_o1 |= (_i1 & B05) >> 6; /* 38 */ \
233_o1 |= (_i0 & B29) << 17; /* 30 */ \
234_o1 |= (_i0 & B21) << 8; /* 22 */ \
235_o1 |= (_i0 & B13) >> 1; /* 14 */ \
236_o1 |= (_i0 & B05) >> 10; /* 6 */ \
237_o1 |= (_i1 & B28) << 12; /* 61 */ \
238_o1 |= (_i1 & B20) << 3; /* 53 */ \
239_o1 |= (_i1 & B12) >> 6; /* 45 */ \
240_o1 |= (_i1 & B04) >> 15; /* 37 */ \
241_o1 |= (_i0 & B28) << 8; /* 29 */ \
242_o1 |= (_i0 & B20) >> 1; /* 21 */ \
243_o1 |= (_i0 & B12) >> 10; /* 13 */ \
244_o1 |= (_i0 & B04) >> 19; /* 5 */ \
245_o1 |= (_i0 & B27) << 3; /* 28 */ \
246_o1 |= (_i0 & B19) >> 6; /* 20 */ \
247_o1 |= (_i0 & B11) >> 15; /* 12 */ \
248_o1 |= (_i0 & B03) >> 24; /* 4 */ \
249}

◆ PC2

#define PC2 ( regC,
regD,
k )
Value:
PC2_AUX(regC, regD, k[0], k[1])
PC2_AUX
#define PC2_AUX(_i0, _i1, _o0, _o1)
Definition crypt_des.c:252

Definition at line 474 of file crypt_des.c.

474#define PC2(regC, regD, k) \
475 PC2_AUX(regC, regD, k[0], k[1])

Referenced by qfDES().

◆ PC2_AUX

#define PC2_AUX ( _i0,
_i1,
_o0,
_o1 )

Definition at line 252 of file crypt_des.c.

252#define PC2_AUX(_i0, _i1, _o0, _o1) \
253{ \
254_o0 = _o1 = 0; \
255_o0 |= (_i0 & B13) << 11; /* 14 */ \
256_o0 |= (_i0 & B16) << 13; /* 17 */ \
257_o0 |= (_i0 & B10) << 6; /* 11 */ \
258_o0 |= (_i0 & B23) << 18; /* 24 */ \
259_o0 |= (_i0 & B00) >> 6; /* 1 */ \
260_o0 |= (_i0 & B04) >> 3; /* 5 */ \
261_o0 |= (_i0 & B02) >> 8; /* 3 */ \
262_o0 |= (_i0 & B27) << 16; /* 28 */ \
263_o0 |= (_i0 & B14) << 2; /* 15 */ \
264_o0 |= (_i0 & B05) >> 8; /* 6 */ \
265_o0 |= (_i0 & B20) << 6; /* 21 */ \
266_o0 |= (_i0 & B09) >> 6; /* 10 */ \
267_o0 |= (_i0 & B22) << 4; /* 23 */ \
268_o0 |= (_i0 & B18) >> 1; /* 19 */ \
269_o0 |= (_i0 & B11) >> 9; /* 12 */ \
270_o0 |= (_i0 & B03) >> 18; /* 4 */ \
271_o0 |= (_i0 & B25) << 3; /* 26 */ \
272_o0 |= (_i0 & B07) >> 16; /* 8 */ \
273_o0 |= (_i0 & B15) >> 11; /* 16 */ \
274_o0 |= (_i0 & B06) >> 21; /* 7 */ \
275_o0 |= (_i0 & B26) >> 2; /* 27 */ \
276_o0 |= (_i0 & B19) >> 10; /* 20 */ \
277_o0 |= (_i0 & B12) >> 18; /* 13 */ \
278_o0 |= (_i0 & B01) >> 30; /* 2 */ \
279_o1 |= (_i1 & B12) << 10; /* 41 */ \
280_o1 |= (_i1 & B23) << 20; /* 52 */ \
281_o1 |= (_i1 & B02) >> 2; /* 31 */ \
282_o1 |= (_i1 & B08) << 3; /* 37 */ \
283_o1 |= (_i1 & B18) << 12; /* 47 */ \
284_o1 |= (_i1 & B26) << 19; /* 55 */ \
285_o1 |= (_i1 & B01) >> 9; /* 30 */ \
286_o1 |= (_i1 & B11) ; /* 40 */ \
287_o1 |= (_i1 & B22) << 10; /* 51 */ \
288_o1 |= (_i1 & B16) << 3; /* 45 */ \
289_o1 |= (_i1 & B04) >> 10; /* 33 */ \
290_o1 |= (_i1 & B19) << 4; /* 48 */ \
291_o1 |= (_i1 & B15) >> 3; /* 44 */ \
292_o1 |= (_i1 & B20) << 1; /* 49 */ \
293_o1 |= (_i1 & B10) >> 10; /* 39 */ \
294_o1 |= (_i1 & B27) << 6; /* 56 */ \
295_o1 |= (_i1 & B05) >> 17; /* 34 */ \
296_o1 |= (_i1 & B24) << 1; /* 53 */ \
297_o1 |= (_i1 & B17) >> 9; /* 46 */ \
298_o1 |= (_i1 & B13) >> 14; /* 42 */ \
299_o1 |= (_i1 & B21) >> 7; /* 50 */ \
300_o1 |= (_i1 & B07) >> 22; /* 36 */ \
301_o1 |= (_i1 & B00) >> 30; /* 29 */ \
302_o1 |= (_i1 & B03) >> 28; /* 32 */ \
303}

Typedef Documentation

◆ Word

typedef unsigned int Word

Definition at line 16 of file crypt_des.c.

Function Documentation

◆ qfDES()

int qfDES ( unsigned char * key,
unsigned char * data,
unsigned int size,
const QFDES_what what,
const QFDES_mode mode,
unsigned char * initVec )

Definition at line 558 of file crypt_des.c.

562{
563 /* Store some info to optimise for multiple calls ... */
564 static unsigned char desKey[8], desKeys[128];
565 static Word *oldKey = (Word *)(void *) desKey, *keys = (Word *) desKeys;
566 static QFDES_what oldWhat;
567 static QFDES_mode oldMode __attribute__((unused));
568 unsigned char b0[8] = "", b1[8]; /* feedback blocks */
569 Word *newKey = (Word *)(void *) key, /* key from user */
570 *text, /* text to be [en|de]crypted */
571 *cb = (Word *)(void *) b0, /* the chained block in CBC mode */
572 *cb1 = (Word *)(void *) b1; /* a copy for use when decrypting */
573
574#if !defined(WORDS_BIGENDIAN)
575 unsigned int origSize = size;
576 MAKE_LITTLE_ENDIAN(key, 8);
577 MAKE_LITTLE_ENDIAN(data, origSize);
578#endif
579
580 /*
581 ** Check new key against old key
582 ** and set up intermediate keys.
583 */
584 if (newKey[0] != oldKey[0] || newKey[1] != oldKey[1]) {
585 Word c, d; /* C and D registers */
586
587 oldKey[0] = newKey[0];
588 oldKey[1] = newKey[1];
589 oldWhat = what;
590 oldMode = mode;
591
592 PC1(newKey, c, d);
593
594 if ((what == qfDES_encrypt) || (mode == qfDES_cfb)
595 || (mode == qfDES_ofb)) {
596 int z;
597 Word r;
598 Word *k = keys;
599 Word rol[16] =
600 { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
601
602 for (z = 0; z < 16; z++, k += 2) {
603 for (r = 0; r < rol[z]; r++) {
604 c = ROTATE_LEFT(c);
605 d = ROTATE_LEFT(d);
606 }
607 PC2(c, d, k);
608 }
609 } else {
610 int z;
611 Word r;
612 Word *k = keys;
613 Word ror[16] =
614 { 0, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
615
616 for (z = 0; z < 16; z++, k += 2) {
617 r = 0;
618 while (ror[z] > r) {
619 r++;
620 c = ROTATE_RIGHT(c);
621 d = ROTATE_RIGHT(d);
622 }
623 PC2(c, d, k);
624 }
625 }
626 } else if ((what != oldWhat)
627 && ((mode == qfDES_ecb) || (mode == qfDES_cbc))) {
628 /*
629 ** Same key but different direction.
630 ** Reverse intermediate key sequence (ECB and CBC).
631 */
632 Word *ik1, *ik2, ik3[2];
633
634 for (ik1 = keys, ik2 = &(keys[30]); ik1 < ik2;
635 ik1 += 2, ik2 -= 2) {
636 ik3[0] = ik1[0];
637 ik3[1] = ik1[1];
638 ik1[0] = ik2[0];
639 ik1[1] = ik2[1];
640 ik2[0] = ik3[0];
641 ik2[1] = ik3[1];
642 }
643
644 oldWhat = what;
645 }
646
647 /* Set up initilaisation vector */
648 if (mode != qfDES_ecb) {
649 if (initVec) {
650 {
651 cb[0] = ((Word *)(void *) initVec)[0];
652 cb[1] = ((Word *)(void *) initVec)[1];
653 }
654 } else {
655 cb[0] = 0;
656 cb[1] = 0;
657 }
658#if !defined(WORDS_BIGENDIAN)
659 MAKE_LITTLE_ENDIAN(cb, 8);
660#endif
661 }
662
663 /*
664 ** Lots of gotos and code duplication follow (arrgh) but it speeds
665 ** it up a wee bit!
666 ** What would be more useful is looking more carefully at the DES
667 ** permutations to produce more efficient versions of the macros
668 ** of the "auto-generated" versions used in qfDES-aux.c.
669 */
670
671 size >>= 3; /* this is always a multpile of 8 */
672
673 if (what == qfDES_encrypt) {
674 switch ((int)mode) {
675 case ((int)qfDES_ecb):
676 goto _ECB_;
677 case ((int)qfDES_cbc):
678 goto _CBC_encrypt_;
679 case ((int)qfDES_cfb):
680 goto _CFB_encrypt_;
681 case ((int)qfDES_ofb):
682 goto _OFB_;
683 }
684 } else {
685 switch ((int)mode) {
686 case ((int)qfDES_ecb):
687 goto _ECB_;
688 case ((int)qfDES_cbc):
689 goto _CBC_decrypt_;
690 case ((int)qfDES_cfb):
691 goto _CFB_decrypt_;
692 case ((int)qfDES_ofb):
693 goto _OFB_;
694 }
695 }
696
697 _ECB_:
698
699 /* ECB */
700 for (text = (Word *)(void *) data; size; --size, text += 2) {
701 DES(text, keys);
702 }
703
704 goto _exit_qfDES_;
705
706 _CBC_encrypt_:
707
708 /* CBC Encryption */
709 for (text = (Word *)(void *) data; size; --size, text += 2) {
710
711 /* chaining block */
712 text[0] ^= cb[0];
713 text[1] ^= cb[1];
714
715 DES(text, keys);
716
717 /* set up chaining block for next round */
718 cb[0] = text[0];
719 cb[1] = text[1];
720 }
721
722 goto _initVec_;
723
724 _CBC_decrypt_:
725
726 /* CBC Decryption */
727 for (text = (Word *)(void *) data; size; --size, text += 2) {
728
729 /* set up chaining block */
730 /*
731 ** The decryption is done in place so I need
732 ** to copy this text block for the next round.
733 */
734 cb1[0] = text[0];
735 cb1[1] = text[1];
736
737 DES(text, keys);
738
739 /* chaining block for next round */
740 text[0] ^= cb[0];
741 text[1] ^= cb[1];
742
743 /*
744 ** Copy back the saved encrypted text - this makes
745 ** CBC decryption slower than CBC encryption.
746 */
747 cb[0] = cb1[0];
748 cb[1] = cb1[1];
749 }
750
751 goto _initVec_;
752
753 _CFB_encrypt_:
754
755 /* CFB Encryption */
756 for (text = (Word *)(void *) data; size; --size, text += 2) {
757
758 /* use cb as the feedback block */
759 DES(cb, keys);
760
761 text[0] ^= cb[0];
762 text[1] ^= cb[1];
763
764 /* set up feedback block for next round */
765 cb[0] = text[0];
766 cb[1] = text[1];
767 }
768
769 goto _initVec_;
770
771 _CFB_decrypt_:
772
773 /* CFB Decryption */
774 for (text = (Word *)(void *) data; size; --size, text += 2) {
775
776 /* set up feedback block */
777 /*
778 ** The decryption is done in place so I need
779 ** to copy this text block for the next round.
780 */
781 cb1[0] = text[0];
782 cb1[1] = text[1];
783
784 /* use cb as the feedback block */
785 DES(cb, keys);
786
787 text[0] ^= cb[0];
788 text[1] ^= cb[1];
789
790 /* set up feedback block for next round */
791 cb[0] = cb1[0];
792 cb[1] = cb1[1];
793 }
794
795 goto _initVec_;
796
797 _OFB_:
798
799 /* OFB */
800 for (text = (Word *)(void *) data; size; --size, text += 2) {
801
802 /* use cb as the feed back block */
803 DES(cb, keys);
804
805 text[0] ^= cb[0];
806 text[1] ^= cb[1];
807 }
808
809 _initVec_:
810
811 /*
812 ** Copy the final chained block back to initVec (CBC, CFB and OFB).
813 ** This allows the [en|de]cryption of large amounts of data in small
814 ** chunks.
815 */
816 if (initVec) {
817 ((Word *)(void *) initVec)[0] = cb[0];
818 ((Word *)(void *) initVec)[1] = cb[1];
819
820#if !defined(WORDS_BIGENDIAN)
821 MAKE_LITTLE_ENDIAN(initVec, 8);
822#endif
823 }
824
825 _exit_qfDES_:
826
827#if !defined(WORDS_BIGENDIAN)
828 MAKE_LITTLE_ENDIAN(key, 8);
829 MAKE_LITTLE_ENDIAN(data, origSize);
830#endif
831
832 return 0;
833}
PC2
#define PC2(regC, regD, k)
Definition crypt_des.c:474
MAKE_LITTLE_ENDIAN
#define MAKE_LITTLE_ENDIAN(t, s)
Definition crypt_des.c:524
DES
#define DES(t, ik)
Definition crypt_des.c:502
ROTATE_RIGHT
static Word ROTATE_RIGHT(Word x)
Definition crypt_des.c:486
PC1
#define PC1(k, regC, regD)
Definition crypt_des.c:471
ROTATE_LEFT
static Word ROTATE_LEFT(Word x)
Definition crypt_des.c:479
QFDES_mode
QFDES_mode
Definition crypt_des.h:21
qfDES_ecb
@ qfDES_ecb
Definition crypt_des.h:21
qfDES_cbc
@ qfDES_cbc
Definition crypt_des.h:21
qfDES_ofb
@ qfDES_ofb
Definition crypt_des.h:21
qfDES_cfb
@ qfDES_cfb
Definition crypt_des.h:21
QFDES_what
QFDES_what
Definition crypt_des.h:18
qfDES_encrypt
@ qfDES_encrypt
Definition crypt_des.h:18
mode
enum openssl_mode mode
Definition openssl_encrypt.c:96
__attribute__
struct __attribute__((packed))
Definition rtp.h:88
key
const char * key
Definition cineform.cpp:125

References __attribute__(), DES, key, MAKE_LITTLE_ENDIAN, mode, PC1, PC2, qfDES_cbc, qfDES_cfb, qfDES_ecb, qfDES_encrypt, qfDES_ofb, ROTATE_LEFT(), and ROTATE_RIGHT().

Here is the call graph for this function:

◆ qfDES_checkParity()

unsigned int qfDES_checkParity ( unsigned char * ptr,
unsigned int size,
const QFDES_parity parity )

Definition at line 856 of file crypt_des.c.

858{
859 unsigned int i, mask, bits, parityBit, parityErrors = 0;
860
861 for (i = 0; i < size; ++i, ++ptr) {
862 for (mask = 0x80, bits = 0; mask > 0x01; mask >>= 1)
863 if (((unsigned int)*ptr) & mask)
864 ++bits;
865
866 parityBit = bits % 2 == (unsigned int)parity ? 0 : 1;
867
868 if ((((unsigned int)*ptr) & 0x1) != parityBit)
869 ++parityErrors;
870 }
871
872 return parityErrors;
873}

◆ qfDES_checkWeakKeys()

int qfDES_checkWeakKeys ( unsigned char * key)

Definition at line 902 of file crypt_des.c.

903{
904 unsigned char *bp;
905 int i;
906
907 for (bp = weakKeys[i = 0]; i < 18; bp = weakKeys[++i])
908 if (memcmp((void *)key, (void *)bp, 8) == 0)
909 return -1;
910
911 return 0;
912}
weakKeys
static unsigned char weakKeys[18][8]
Definition crypt_des.c:876

References key, and weakKeys.

Referenced by qfDES_generate().

◆ qfDES_generate()

unsigned char * qfDES_generate ( const QFDES_generate what)

Definition at line 921 of file crypt_des.c.

922{
923 static
924 unsigned char buffer[8];
925 static
926 int flag = 0;
927
928 unsigned char *bp;
929 int mask = what == qfDES_key ? 0xfe : 0xff;
930
931 /* Set up a seed - 42 is the answer ... */
932 if (!flag) {
933 lbl_srandom((int)(getpid() * 42) ^ (int)time((time_t *) 0));
934 flag = 1;
935 }
936 do {
937
938 for (bp = buffer; bp <= &(buffer[7]);
939 *bp++ = (unsigned char)(lbl_random() & mask)) ;
940
941 if (what == qfDES_key)
942 qfDES_setParity(buffer, 8, qfDES_odd);
943
944 } while (what == qfDES_key ? qfDES_checkWeakKeys(buffer) : 0);
945
946 return buffer;
947}
qfDES_checkWeakKeys
int qfDES_checkWeakKeys(unsigned char *key)
Definition crypt_des.c:902
qfDES_setParity
void qfDES_setParity(unsigned char *ptr, unsigned int size, const QFDES_parity parity)
Definition crypt_des.c:842
qfDES_key
@ qfDES_key
Definition crypt_des.h:27
qfDES_odd
@ qfDES_odd
Definition crypt_des.h:24
lbl_random
uint32_t lbl_random(void)
Definition random.c:61
lbl_srandom
void lbl_srandom(uint32_t seed)
Definition random.c:56

References lbl_random(), lbl_srandom(), qfDES_checkWeakKeys(), qfDES_key, qfDES_odd, and qfDES_setParity().

Here is the call graph for this function:

◆ qfDES_setPad()

unsigned char qfDES_setPad ( unsigned char pad)

Definition at line 949 of file crypt_des.c.

950{
951 unsigned char b = G_padChar;
952 G_padChar = pad;
953 return b;
954}
G_padChar
unsigned char G_padChar
Definition crypt_des.c:477

References G_padChar.

◆ qfDES_setParity()

void qfDES_setParity ( unsigned char * ptr,
unsigned int size,
const QFDES_parity parity )

Definition at line 842 of file crypt_des.c.

844{
845 unsigned int i, mask, bits;
846
847 for (i = 0; i < size; ++i, ++ptr) {
848 for (mask = 0x80, bits = 0; mask > 0x01; mask >>= 1)
849 if (((unsigned int)*ptr) & mask)
850 ++bits;
851
852 *ptr |= bits % 2 == (unsigned int)parity ? 0x00 : 0x01;
853 }
854}

Referenced by qfDES_generate().

◆ ROTATE_LEFT()

static Word ROTATE_LEFT ( Word x)
static

Definition at line 479 of file crypt_des.c.

480{
481 Word a;
482 a = (x & 0x80000000) >> 27;
483 return (x << 1) | a;
484}

Referenced by qfDES().

◆ ROTATE_RIGHT()

static Word ROTATE_RIGHT ( Word x)
static

Definition at line 486 of file crypt_des.c.

487{
488 Word a;
489 a = x & 0x00000010;
490 return (x >> 1) | (a << 27);
491}

Referenced by qfDES().

Variable Documentation

◆ G_padChar

unsigned char G_padChar = (char)0

Definition at line 477 of file crypt_des.c.

Referenced by qfDES_setPad().

◆ s_p0

Word s_p0[64]
static
Initial value:
= {
0x00808200, 0x00000000, 0x00008000, 0x00808202,
0x00808002, 0x00008202, 0x00000002, 0x00008000,
0x00000200, 0x00808200, 0x00808202, 0x00000200,
0x00800202, 0x00808002, 0x00800000, 0x00000002,
0x00000202, 0x00800200, 0x00800200, 0x00008200,
0x00008200, 0x00808000, 0x00808000, 0x00800202,
0x00008002, 0x00800002, 0x00800002, 0x00008002,
0x00000000, 0x00000202, 0x00008202, 0x00800000,
0x00008000, 0x00808202, 0x00000002, 0x00808000,
0x00808200, 0x00800000, 0x00800000, 0x00000200,
0x00808002, 0x00008000, 0x00008200, 0x00800002,
0x00000200, 0x00000002, 0x00800202, 0x00008202,
0x00808202, 0x00008002, 0x00808000, 0x00800202,
0x00800002, 0x00000202, 0x00008202, 0x00808200,
0x00000202, 0x00800200, 0x00800200, 0x00000000,
0x00008002, 0x00008200, 0x00000000, 0x00808002
}

Definition at line 306 of file crypt_des.c.

306 { /* Combined S-Box1 and permutation P */
307 0x00808200, 0x00000000, 0x00008000, 0x00808202,
308 0x00808002, 0x00008202, 0x00000002, 0x00008000,
309 0x00000200, 0x00808200, 0x00808202, 0x00000200,
310 0x00800202, 0x00808002, 0x00800000, 0x00000002,
311 0x00000202, 0x00800200, 0x00800200, 0x00008200,
312 0x00008200, 0x00808000, 0x00808000, 0x00800202,
313 0x00008002, 0x00800002, 0x00800002, 0x00008002,
314 0x00000000, 0x00000202, 0x00008202, 0x00800000,
315 0x00008000, 0x00808202, 0x00000002, 0x00808000,
316 0x00808200, 0x00800000, 0x00800000, 0x00000200,
317 0x00808002, 0x00008000, 0x00008200, 0x00800002,
318 0x00000200, 0x00000002, 0x00800202, 0x00008202,
319 0x00808202, 0x00008002, 0x00808000, 0x00800202,
320 0x00800002, 0x00000202, 0x00008202, 0x00808200,
321 0x00000202, 0x00800200, 0x00800200, 0x00000000,
322 0x00008002, 0x00008200, 0x00000000, 0x00808002
323};

◆ s_p1

Word s_p1[64]
static
Initial value:
= {
0x40084010, 0x40004000, 0x00004000, 0x00084010,
0x00080000, 0x00000010, 0x40080010, 0x40004010,
0x40000010, 0x40084010, 0x40084000, 0x40000000,
0x40004000, 0x00080000, 0x00000010, 0x40080010,
0x00084000, 0x00080010, 0x40004010, 0x00000000,
0x40000000, 0x00004000, 0x00084010, 0x40080000,
0x00080010, 0x40000010, 0x00000000, 0x00084000,
0x00004010, 0x40084000, 0x40080000, 0x00004010,
0x00000000, 0x00084010, 0x40080010, 0x00080000,
0x40004010, 0x40080000, 0x40084000, 0x00004000,
0x40080000, 0x40004000, 0x00000010, 0x40084010,
0x00084010, 0x00000010, 0x00004000, 0x40000000,
0x00004010, 0x40084000, 0x00080000, 0x40000010,
0x00080010, 0x40004010, 0x40000010, 0x00080010,
0x00084000, 0x00000000, 0x40004000, 0x00004010,
0x40000000, 0x40080010, 0x40084010, 0x00084000
}

Definition at line 326 of file crypt_des.c.

326 { /* Combined S-Box2 and permutation P */
327 0x40084010, 0x40004000, 0x00004000, 0x00084010,
328 0x00080000, 0x00000010, 0x40080010, 0x40004010,
329 0x40000010, 0x40084010, 0x40084000, 0x40000000,
330 0x40004000, 0x00080000, 0x00000010, 0x40080010,
331 0x00084000, 0x00080010, 0x40004010, 0x00000000,
332 0x40000000, 0x00004000, 0x00084010, 0x40080000,
333 0x00080010, 0x40000010, 0x00000000, 0x00084000,
334 0x00004010, 0x40084000, 0x40080000, 0x00004010,
335 0x00000000, 0x00084010, 0x40080010, 0x00080000,
336 0x40004010, 0x40080000, 0x40084000, 0x00004000,
337 0x40080000, 0x40004000, 0x00000010, 0x40084010,
338 0x00084010, 0x00000010, 0x00004000, 0x40000000,
339 0x00004010, 0x40084000, 0x00080000, 0x40000010,
340 0x00080010, 0x40004010, 0x40000010, 0x00080010,
341 0x00084000, 0x00000000, 0x40004000, 0x00004010,
342 0x40000000, 0x40080010, 0x40084010, 0x00084000
343};

◆ s_p2

Word s_p2[64]
static
Initial value:
= {
0x00000104, 0x04010100, 0x00000000, 0x04010004,
0x04000100, 0x00000000, 0x00010104, 0x04000100,
0x00010004, 0x04000004, 0x04000004, 0x00010000,
0x04010104, 0x00010004, 0x04010000, 0x00000104,
0x04000000, 0x00000004, 0x04010100, 0x00000100,
0x00010100, 0x04010000, 0x04010004, 0x00010104,
0x04000104, 0x00010100, 0x00010000, 0x04000104,
0x00000004, 0x04010104, 0x00000100, 0x04000000,
0x04010100, 0x04000000, 0x00010004, 0x00000104,
0x00010000, 0x04010100, 0x04000100, 0x00000000,
0x00000100, 0x00010004, 0x04010104, 0x04000100,
0x04000004, 0x00000100, 0x00000000, 0x04010004,
0x04000104, 0x00010000, 0x04000000, 0x04010104,
0x00000004, 0x00010104, 0x00010100, 0x04000004,
0x04010000, 0x04000104, 0x00000104, 0x04010000,
0x00010104, 0x00000004, 0x04010004, 0x00010100
}

Definition at line 346 of file crypt_des.c.

346 { /* Combined S-Box3 and permutation P */
347 0x00000104, 0x04010100, 0x00000000, 0x04010004,
348 0x04000100, 0x00000000, 0x00010104, 0x04000100,
349 0x00010004, 0x04000004, 0x04000004, 0x00010000,
350 0x04010104, 0x00010004, 0x04010000, 0x00000104,
351 0x04000000, 0x00000004, 0x04010100, 0x00000100,
352 0x00010100, 0x04010000, 0x04010004, 0x00010104,
353 0x04000104, 0x00010100, 0x00010000, 0x04000104,
354 0x00000004, 0x04010104, 0x00000100, 0x04000000,
355 0x04010100, 0x04000000, 0x00010004, 0x00000104,
356 0x00010000, 0x04010100, 0x04000100, 0x00000000,
357 0x00000100, 0x00010004, 0x04010104, 0x04000100,
358 0x04000004, 0x00000100, 0x00000000, 0x04010004,
359 0x04000104, 0x00010000, 0x04000000, 0x04010104,
360 0x00000004, 0x00010104, 0x00010100, 0x04000004,
361 0x04010000, 0x04000104, 0x00000104, 0x04010000,
362 0x00010104, 0x00000004, 0x04010004, 0x00010100
363};

◆ s_p3

Word s_p3[64]
static
Initial value:
= {
0x80401000, 0x80001040, 0x80001040, 0x00000040,
0x00401040, 0x80400040, 0x80400000, 0x80001000,
0x00000000, 0x00401000, 0x00401000, 0x80401040,
0x80000040, 0x00000000, 0x00400040, 0x80400000,
0x80000000, 0x00001000, 0x00400000, 0x80401000,
0x00000040, 0x00400000, 0x80001000, 0x00001040,
0x80400040, 0x80000000, 0x00001040, 0x00400040,
0x00001000, 0x00401040, 0x80401040, 0x80000040,
0x00400040, 0x80400000, 0x00401000, 0x80401040,
0x80000040, 0x00000000, 0x00000000, 0x00401000,
0x00001040, 0x00400040, 0x80400040, 0x80000000,
0x80401000, 0x80001040, 0x80001040, 0x00000040,
0x80401040, 0x80000040, 0x80000000, 0x00001000,
0x80400000, 0x80001000, 0x00401040, 0x80400040,
0x80001000, 0x00001040, 0x00400000, 0x80401000,
0x00000040, 0x00400000, 0x00001000, 0x00401040
}

Definition at line 366 of file crypt_des.c.

366 { /* Combined S-Box4 and permutation P */
367 0x80401000, 0x80001040, 0x80001040, 0x00000040,
368 0x00401040, 0x80400040, 0x80400000, 0x80001000,
369 0x00000000, 0x00401000, 0x00401000, 0x80401040,
370 0x80000040, 0x00000000, 0x00400040, 0x80400000,
371 0x80000000, 0x00001000, 0x00400000, 0x80401000,
372 0x00000040, 0x00400000, 0x80001000, 0x00001040,
373 0x80400040, 0x80000000, 0x00001040, 0x00400040,
374 0x00001000, 0x00401040, 0x80401040, 0x80000040,
375 0x00400040, 0x80400000, 0x00401000, 0x80401040,
376 0x80000040, 0x00000000, 0x00000000, 0x00401000,
377 0x00001040, 0x00400040, 0x80400040, 0x80000000,
378 0x80401000, 0x80001040, 0x80001040, 0x00000040,
379 0x80401040, 0x80000040, 0x80000000, 0x00001000,
380 0x80400000, 0x80001000, 0x00401040, 0x80400040,
381 0x80001000, 0x00001040, 0x00400000, 0x80401000,
382 0x00000040, 0x00400000, 0x00001000, 0x00401040
383};

◆ s_p4

Word s_p4[64]
static
Initial value:
= {
0x00000080, 0x01040080, 0x01040000, 0x21000080,
0x00040000, 0x00000080, 0x20000000, 0x01040000,
0x20040080, 0x00040000, 0x01000080, 0x20040080,
0x21000080, 0x21040000, 0x00040080, 0x20000000,
0x01000000, 0x20040000, 0x20040000, 0x00000000,
0x20000080, 0x21040080, 0x21040080, 0x01000080,
0x21040000, 0x20000080, 0x00000000, 0x21000000,
0x01040080, 0x01000000, 0x21000000, 0x00040080,
0x00040000, 0x21000080, 0x00000080, 0x01000000,
0x20000000, 0x01040000, 0x21000080, 0x20040080,
0x01000080, 0x20000000, 0x21040000, 0x01040080,
0x20040080, 0x00000080, 0x01000000, 0x21040000,
0x21040080, 0x00040080, 0x21000000, 0x21040080,
0x01040000, 0x00000000, 0x20040000, 0x21000000,
0x00040080, 0x01000080, 0x20000080, 0x00040000,
0x00000000, 0x20040000, 0x01040080, 0x20000080
}

Definition at line 386 of file crypt_des.c.

386 { /* Combined S-Box5 and permutation P */
387 0x00000080, 0x01040080, 0x01040000, 0x21000080,
388 0x00040000, 0x00000080, 0x20000000, 0x01040000,
389 0x20040080, 0x00040000, 0x01000080, 0x20040080,
390 0x21000080, 0x21040000, 0x00040080, 0x20000000,
391 0x01000000, 0x20040000, 0x20040000, 0x00000000,
392 0x20000080, 0x21040080, 0x21040080, 0x01000080,
393 0x21040000, 0x20000080, 0x00000000, 0x21000000,
394 0x01040080, 0x01000000, 0x21000000, 0x00040080,
395 0x00040000, 0x21000080, 0x00000080, 0x01000000,
396 0x20000000, 0x01040000, 0x21000080, 0x20040080,
397 0x01000080, 0x20000000, 0x21040000, 0x01040080,
398 0x20040080, 0x00000080, 0x01000000, 0x21040000,
399 0x21040080, 0x00040080, 0x21000000, 0x21040080,
400 0x01040000, 0x00000000, 0x20040000, 0x21000000,
401 0x00040080, 0x01000080, 0x20000080, 0x00040000,
402 0x00000000, 0x20040000, 0x01040080, 0x20000080
403};

◆ s_p5

Word s_p5[64]
static
Initial value:
= {
0x10000008, 0x10200000, 0x00002000, 0x10202008,
0x10200000, 0x00000008, 0x10202008, 0x00200000,
0x10002000, 0x00202008, 0x00200000, 0x10000008,
0x00200008, 0x10002000, 0x10000000, 0x00002008,
0x00000000, 0x00200008, 0x10002008, 0x00002000,
0x00202000, 0x10002008, 0x00000008, 0x10200008,
0x10200008, 0x00000000, 0x00202008, 0x10202000,
0x00002008, 0x00202000, 0x10202000, 0x10000000,
0x10002000, 0x00000008, 0x10200008, 0x00202000,
0x10202008, 0x00200000, 0x00002008, 0x10000008,
0x00200000, 0x10002000, 0x10000000, 0x00002008,
0x10000008, 0x10202008, 0x00202000, 0x10200000,
0x00202008, 0x10202000, 0x00000000, 0x10200008,
0x00000008, 0x00002000, 0x10200000, 0x00202008,
0x00002000, 0x00200008, 0x10002008, 0x00000000,
0x10202000, 0x10000000, 0x00200008, 0x10002008
}

Definition at line 406 of file crypt_des.c.

406 { /* Combined S-Box6 and permutation P */
407 0x10000008, 0x10200000, 0x00002000, 0x10202008,
408 0x10200000, 0x00000008, 0x10202008, 0x00200000,
409 0x10002000, 0x00202008, 0x00200000, 0x10000008,
410 0x00200008, 0x10002000, 0x10000000, 0x00002008,
411 0x00000000, 0x00200008, 0x10002008, 0x00002000,
412 0x00202000, 0x10002008, 0x00000008, 0x10200008,
413 0x10200008, 0x00000000, 0x00202008, 0x10202000,
414 0x00002008, 0x00202000, 0x10202000, 0x10000000,
415 0x10002000, 0x00000008, 0x10200008, 0x00202000,
416 0x10202008, 0x00200000, 0x00002008, 0x10000008,
417 0x00200000, 0x10002000, 0x10000000, 0x00002008,
418 0x10000008, 0x10202008, 0x00202000, 0x10200000,
419 0x00202008, 0x10202000, 0x00000000, 0x10200008,
420 0x00000008, 0x00002000, 0x10200000, 0x00202008,
421 0x00002000, 0x00200008, 0x10002008, 0x00000000,
422 0x10202000, 0x10000000, 0x00200008, 0x10002008
423};

◆ s_p6

Word s_p6[64]
static
Initial value:
= {
0x00100000, 0x02100001, 0x02000401, 0x00000000,
0x00000400, 0x02000401, 0x00100401, 0x02100400,
0x02100401, 0x00100000, 0x00000000, 0x02000001,
0x00000001, 0x02000000, 0x02100001, 0x00000401,
0x02000400, 0x00100401, 0x00100001, 0x02000400,
0x02000001, 0x02100000, 0x02100400, 0x00100001,
0x02100000, 0x00000400, 0x00000401, 0x02100401,
0x00100400, 0x00000001, 0x02000000, 0x00100400,
0x02000000, 0x00100400, 0x00100000, 0x02000401,
0x02000401, 0x02100001, 0x02100001, 0x00000001,
0x00100001, 0x02000000, 0x02000400, 0x00100000,
0x02100400, 0x00000401, 0x00100401, 0x02100400,
0x00000401, 0x02000001, 0x02100401, 0x02100000,
0x00100400, 0x00000000, 0x00000001, 0x02100401,
0x00000000, 0x00100401, 0x02100000, 0x00000400,
0x02000001, 0x02000400, 0x00000400, 0x00100001
}

Definition at line 426 of file crypt_des.c.

426 { /* Combined S-Box7 and permutation P */
427 0x00100000, 0x02100001, 0x02000401, 0x00000000,
428 0x00000400, 0x02000401, 0x00100401, 0x02100400,
429 0x02100401, 0x00100000, 0x00000000, 0x02000001,
430 0x00000001, 0x02000000, 0x02100001, 0x00000401,
431 0x02000400, 0x00100401, 0x00100001, 0x02000400,
432 0x02000001, 0x02100000, 0x02100400, 0x00100001,
433 0x02100000, 0x00000400, 0x00000401, 0x02100401,
434 0x00100400, 0x00000001, 0x02000000, 0x00100400,
435 0x02000000, 0x00100400, 0x00100000, 0x02000401,
436 0x02000401, 0x02100001, 0x02100001, 0x00000001,
437 0x00100001, 0x02000000, 0x02000400, 0x00100000,
438 0x02100400, 0x00000401, 0x00100401, 0x02100400,
439 0x00000401, 0x02000001, 0x02100401, 0x02100000,
440 0x00100400, 0x00000000, 0x00000001, 0x02100401,
441 0x00000000, 0x00100401, 0x02100000, 0x00000400,
442 0x02000001, 0x02000400, 0x00000400, 0x00100001
443};

◆ s_p7

Word s_p7[64]
static
Initial value:
= {
0x08000820, 0x00000800, 0x00020000, 0x08020820,
0x08000000, 0x08000820, 0x00000020, 0x08000000,
0x00020020, 0x08020000, 0x08020820, 0x00020800,
0x08020800, 0x00020820, 0x00000800, 0x00000020,
0x08020000, 0x08000020, 0x08000800, 0x00000820,
0x00020800, 0x00020020, 0x08020020, 0x08020800,
0x00000820, 0x00000000, 0x00000000, 0x08020020,
0x08000020, 0x08000800, 0x00020820, 0x00020000,
0x00020820, 0x00020000, 0x08020800, 0x00000800,
0x00000020, 0x08020020, 0x00000800, 0x00020820,
0x08000800, 0x00000020, 0x08000020, 0x08020000,
0x08020020, 0x08000000, 0x00020000, 0x08000820,
0x00000000, 0x08020820, 0x00020020, 0x08000020,
0x08020000, 0x08000800, 0x08000820, 0x00000000,
0x08020820, 0x00020800, 0x00020800, 0x00000820,
0x00000820, 0x00020020, 0x08000000, 0x08020800
}

Definition at line 446 of file crypt_des.c.

446 { /* Combined S-Box8 and permutation P */
447 0x08000820, 0x00000800, 0x00020000, 0x08020820,
448 0x08000000, 0x08000820, 0x00000020, 0x08000000,
449 0x00020020, 0x08020000, 0x08020820, 0x00020800,
450 0x08020800, 0x00020820, 0x00000800, 0x00000020,
451 0x08020000, 0x08000020, 0x08000800, 0x00000820,
452 0x00020800, 0x00020020, 0x08020020, 0x08020800,
453 0x00000820, 0x00000000, 0x00000000, 0x08020020,
454 0x08000020, 0x08000800, 0x00020820, 0x00020000,
455 0x00020820, 0x00020000, 0x08020800, 0x00000800,
456 0x00000020, 0x08020020, 0x00000800, 0x00020820,
457 0x08000800, 0x00000020, 0x08000020, 0x08020000,
458 0x08020020, 0x08000000, 0x00020000, 0x08000820,
459 0x00000000, 0x08020820, 0x00020020, 0x08000020,
460 0x08020000, 0x08000800, 0x08000820, 0x00000000,
461 0x08020820, 0x00020800, 0x00020800, 0x00000820,
462 0x00000820, 0x00020020, 0x08000000, 0x08020800
463};

◆ weakKeys

unsigned char weakKeys[18][8]
static
Initial value:
=
{ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
{0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe},
{0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e},
{0xe0, 0xe0, 0xe0, 0xe0, 0xf1, 0xf1, 0xf1, 0xf1},
{0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe},
{0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01},
{0x1f, 0xe0, 0x1f, 0xe0, 0x0e, 0xf1, 0x0e, 0xf1},
{0xe0, 0x1f, 0xe0, 0x1f, 0xf1, 0x0e, 0xf1, 0x0e},
{0x01, 0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1},
{0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1, 0x01},
{0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe},
{0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e},
{0x01, 0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e},
{0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e, 0x01},
{0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1, 0xfe},
{0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1}
}

Definition at line 876 of file crypt_des.c.

877 { {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
878{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
879{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
880{0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe},
881{0x1f, 0x1f, 0x1f, 0x1f, 0x0e, 0x0e, 0x0e, 0x0e},
882{0xe0, 0xe0, 0xe0, 0xe0, 0xf1, 0xf1, 0xf1, 0xf1},
883{0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe},
884{0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01},
885{0x1f, 0xe0, 0x1f, 0xe0, 0x0e, 0xf1, 0x0e, 0xf1},
886{0xe0, 0x1f, 0xe0, 0x1f, 0xf1, 0x0e, 0xf1, 0x0e},
887{0x01, 0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1},
888{0xe0, 0x01, 0xe0, 0x01, 0xf1, 0x01, 0xf1, 0x01},
889{0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe},
890{0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x0e, 0xfe, 0x0e},
891{0x01, 0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e},
892{0x1f, 0x01, 0x1f, 0x01, 0x0e, 0x01, 0x0e, 0x01},
893{0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1, 0xfe},
894{0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf1, 0xfe, 0xf1}
895};

Referenced by qfDES_checkWeakKeys().

Generated on Wed Sep 25 2024 14:27:30 for UltraGrid by doxygen 1.12.0