des.c File Reference

DES algorithm. More...

#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/rotate.h>
#include <ipxe/crypto.h>
#include <ipxe/ecb.h>
#include <ipxe/cbc.h>
#include <ipxe/init.h>
#include <ipxe/des.h>

Go to the source code of this file.

Data Structures
struct	des_generator
	A DES systematic permutation generator. More...

Macros
#define	DES_SCHEDULE   0x0d556aab
	DES shift schedule. More...
#define	SBYTE(x, y)   ( ( (y) << 4 ) | (x) )
	Define an element pair in a DES S-box. More...
#define	SBOX(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xa, xb, xc, xd, xe, xf, y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, ya, yb, yc, yd, ye, yf)
	Define a row pair in a DES S-box. More...
#define	DES_PC2(x)   ( (x) + ( ( (x) > 28 ) ? 4 : 0 ) )
	Define a bit index within permuted choice 2 (PC2) More...
#define	DES_PC2R(r1, c3, c2, c1, c0, r0)
	Define six bits of permuted choice 2 (PC2) More...
#define	DES_GENERATOR(PERMUTATION, OFFSET, INV5, BIT5, INV4, BIT4, INV3, BIT3, INV2, BIT2, INV1, BIT1, INV0, BIT0)
	Define a DES permutation generator. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static void	des_generate (struct des_generator *generator)
	Generate DES permutation. More...
static void	des_init (void)
	Initialise permutations. More...
struct init_fn des_init_fn	__init_fn (INIT_NORMAL)
	Initialisation function. More...
static void	des_permute (const uint8_t *permutation, const uint8_t *in, uint8_t *out)
	Perform bit permutation. More...
static uint32_t	des_sbox (uint32_t in, const union des_round_key *rkey)
	Perform DES S-box substitution. More...
static void	des_round (union des_block *block, const union des_round_key *rkey)
	Perform a single DES round. More...
static void	des_rounds (const union des_block *in, union des_block *out, const union des_round_key *rkey, ssize_t offset)
	Perform all DES rounds. More...
static uint32_t	des_rol28 (uint32_t dword)
	Rotate 28-bit word. More...
static int	des_setkey (void *ctx, const void *key, size_t keylen)
	Set key. More...
static void	des_encrypt (void *ctx, const void *src, void *dst, size_t len)
	Encrypt data. More...
static void	des_decrypt (void *ctx, const void *src, void *dst, size_t len)
	Decrypt data. More...
	ECB_CIPHER (des_ecb, des_ecb_algorithm, des_algorithm, struct des_context, DES_BLOCKSIZE)
	CBC_CIPHER (des_cbc, des_cbc_algorithm, des_algorithm, struct des_context, DES_BLOCKSIZE)

Variables
static const uint8_t	des_s [8][32]
	DES S-boxes S1..S8. More...
static uint8_t	des_pc1c [29]
	DES permuted choice 1 (PC1) "C" register. More...
static uint8_t	des_pc1d [33]
	DES permuted choice 1 (PC1) "D" register. More...
static const uint8_t	des_pc2 [65]
	DES permuted choice 2 (PC2) More...
static uint8_t	des_ip [65]
	DES initial permutation (IP) More...
static const uint8_t	des_p [33]
	DES data permutation (P) More...
static uint8_t	des_fp [65]
	DES final / inverse initial permutation (FP / IP^-1) More...
static struct des_generator	des_generators []
	DES permutation generators. More...
struct cipher_algorithm	des_algorithm
	Basic DES algorithm. More...

Detailed Description

DES algorithm.

DES was not designed to be implemented in software, and therefore contains a large number of bit permutation operations that are essentially free in hardware (requiring only wires, no gates) but expensive in software.

Since DES is no longer used as a practical block cipher for large volumes of data, we optimise for code size, and do not attempt to obtain fast throughput.

The algorithm is specified in NIST SP 800-67, downloadable from https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-67r2.pdf

Definition in file des.c.

Macro Definition Documentation

DES_SCHEDULE

#define DES_SCHEDULE   0x0d556aab

DES shift schedule.

The DES shift schedule (ordered from round 16 down to round 1) is {1,2,2,2,2,2,2,1,2,2,2,2,2,2,1,1}. In binary, this may be represented as {1,10,10,10,10,10,10,1,10,10,10,10,10,10,1,1} and concatenated (without padding) to produce a single binary integer 1101010101010110101010101011 (equal to 0x0d556aab in hexadecimal).

This integer may then be consumed LSB-first, where a 1 bit indicates a shift and the generation of a round key, and a 0 bit indicates a shift without the generation of a round key.

Definition at line 67 of file des.c.

SBYTE

#define SBYTE	(		x,
			y
	)		( ( (y) << 4 ) | (x) )

Define an element pair in a DES S-box.

Parameters

x	Upper element of element pair
y	Lower element of element pair

DES S-box elements are 4-bit values. We encode two values per byte, ordering the elements so that the six-bit input value may be used directly as a lookup index.

Specifically, if the input value is {r1,c3,c2,c1,c0,r0}, where {r1,r0} is the table row index and {c3,c2,c1,c0} is the table column index (as used in the DES specification), then:

• {r1,c3,c2,c1,c0} is the byte index into the table
• (4*r0) is the required bit shift to extract the 4-bit value

Definition at line 87 of file des.c.

SBOX

#define SBOX	(		x0,
			x1,
			x2,
			x3,
			x4,
			x5,
			x6,
			x7,
			x8,
			x9,
			xa,
			xb,
			xc,
			xd,
			xe,
			xf,
			y0,
			y1,
			y2,
			y3,
			y4,
			y5,
			y6,
			y7,
			y8,
			y9,
			ya,
			yb,
			yc,
			yd,
			ye,
			yf
	)

Value:

SBYTE ( x0, y0 ), SBYTE ( x1, y1 ), SBYTE ( x2, y2 ), SBYTE ( x3, y3 ),\
        SBYTE ( x4, y4 ), SBYTE ( x5, y5 ), SBYTE ( x6, y6 ), SBYTE ( x7, y7 ),\
        SBYTE ( x8, y8 ), SBYTE ( x9, y9 ), SBYTE ( xa, ya ), SBYTE ( xb, yb ),\
        SBYTE ( xc, yc ), SBYTE ( xd, yd ), SBYTE ( xe, ye ), SBYTE ( xf, yf )

Define a row pair in a DES S-box.

Parameters

x0..xf	Upper row of row pair
y0..yf	Lower row of row pair

Definition at line 95 of file des.c.

DES_PC2

#define DES_PC2

(

x

)

( (x) + ( ( (x) > 28 ) ? 4 : 0 ) )

Define a bit index within permuted choice 2 (PC2)

Parameters

bit

Bit index

Permuted choice 2 (PC2) is used to select bits from a concatenated pair of 28-bit registers ("C" and "D") as part of the key schedule. We store these as 32-bit registers and so must add 4 to indexes above 28.

Definition at line 163 of file des.c.

DES_PC2R

#define DES_PC2R	(		r1,
			c3,
			c2,
			c1,
			c0,
			r0
	)

Value:

DES_PC2 ( r0 ), /* LSB stored in sign bit */                    \
        DES_PC2 ( r0 ), /* Unused bit */                                \
        DES_PC2 ( r0 ), /* Unused bit */                                \
        DES_PC2 ( r1 ), /* Remaining 5 bits */                          \
        DES_PC2 ( c3 ), /* ... */                                       \
        DES_PC2 ( c2 ), /* ... */                                       \
        DES_PC2 ( c1 ), /* ... */                                       \
        DES_PC2 ( c0 )  /* ... */

Define six bits of permuted choice 2 (PC2)

Parameters

r1:r0	Bits corresponding to S-box row index
c3:c0	Bits corresponding to S-box column index

There are 8 steps within a DES round (one step per S-box). Each step requires six bits of the round key, corresponding to the S-box input value {r1,c3,c2,c1,c0,r0}, where {r1,r0} is the table row index and {c3,c2,c1,c0} is the table column index.

As an optimisation, we store the least significant of the 6 bits in the sign bit of a signed 8-bit value, and the remaining 5 bits in the least significant 5 bits of the 8-bit value. See the comments in des_sbox() for further details.

Definition at line 181 of file des.c.

DES_GENERATOR

#define DES_GENERATOR	(		PERMUTATION,
			OFFSET,
			INV5,
			BIT5,
			INV4,
			BIT4,
			INV3,
			BIT3,
			INV2,
			BIT2,
			INV1,
			BIT1,
			INV0,
			BIT0
	)

Value:

{                                                               \
                .permutation = (PERMUTATION),                           \
                .seed = ( ( (INV0) << 31 ) | ( (BIT0) << 28 ) |         \
                          ( (INV1) << 27 ) | ( (BIT1) << 24 ) |         \
                          ( (INV2) << 23 ) | ( (BIT2) << 20 ) |         \
                          ( (INV3) << 19 ) | ( (BIT3) << 16 ) |         \
                          ( (INV4) << 15 ) | ( (BIT4) << 12 ) |         \
                          ( (INV5) << 11 ) | ( (BIT5) <<  8 ) |         \
                          ( ( uint32_t ) sizeof (PERMUTATION) - 1 ) |   \
                          (OFFSET) ),                                   \
        }

Define a DES permutation generator.

Parameters

PERMUTATION	Permutation
OFFSET	Fixed input bit offset (0 or 1)
INV<n>	Input bit index bit <n> should be inverted
BIT<n>	Source bit for input bit index bit <n>

Return values

generator

Permutation generator

Definition at line 214 of file des.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

des_generate()

static void des_generate ( struct des_generator *  generator )

static

Generate DES permutation.

Parameters

generator

Generator

Definition at line 306 of file des.c.

                                                 {
        uint8_t *permutation = generator->permutation;
        uint32_t seed = generator->seed;
        unsigned int index = 0;
        uint8_t accum;
        uint8_t bit;

        /* Generate permutations
         *
         * This loop is optimised for code size on a
         * register-constrained architecture such as i386.
         */
        do {
                /* Rotate seed to access MSB's bit descriptor */
                seed = ror32 ( seed, 8 );

                /* Initialise accumulator with six flag bits */
                accum = 0xfc;

                /* Accumulate bits until all six flag bits are cleared */
                do {
                        /* Extract specified bit from index.  Use a
                         * rotation instead of a shift, since this
                         * will allow the mask to be elided.
                         */
                        bit = ror8 ( index, ( seed & 0x07 ) );
                        seed = ror32 ( seed, 3 );

                        /* Toggle bit if applicable */
                        bit ^= seed;
                        seed = ror32 ( seed, 1 );

                        /* Add bit to accumulator and clear one flag bit */
                        accum <<= 1;
                        accum |= ( bit & 0x01 );

                } while ( accum & 0x80 );

                /* Add constant offset if applicable */
                accum += ( seed & 0x01 );

                /* Store permutation */
                permutation[index] = accum;

                /* Loop until reaching length (which is always even) */
        } while ( ++index < ( seed & 0xfe ) );
        DBGC2 ( permutation, "DES generated permutation %p:\n", permutation );
        DBGC2_HDA ( permutation, 0, permutation,
                    ( ( seed & 0xfe ) + 1 /* zero terminator */ ) );
}

References bit, DBGC2, DBGC2_HDA, index, des_generator::permutation, ror32(), and des_generator::seed.

Referenced by des_init().

des_init()

static void des_init ( void  )

static

Initialise permutations.

Definition at line 360 of file des.c.

                              {
        unsigned int i;

        /* Generate all generated permutations */
        for ( i = 0 ; i < ( sizeof ( des_generators ) /
                            sizeof ( des_generators[0] ) ) ; i++ ) {
                des_generate ( &des_generators[i] );
        }
}

References des_generate(), and des_generators.

__init_fn()

struct init_fn des_init_fn __init_fn

(

INIT_NORMAL

)

Initialisation function.

des_permute()

static void des_permute ( const uint8_t *  permutation, const uint8_t *  in, uint8_t *  out  )

static

Perform bit permutation.

Parameters

permutation	Bit permutation (zero-terminated)
in	Input value
out	Output value

Definition at line 383 of file des.c.

                                         {
        uint8_t mask = 0x80;
        uint8_t accum = 0;
        unsigned int bit;

        /* Extract individual input bits to construct output value */
        while ( ( bit = *(permutation++) ) ) {
                bit--;
                if ( in[ bit / 8 ] & ( 0x80 >> ( bit % 8 ) ) )
                        accum |= mask;
                *out = accum;
                mask = ror8 ( mask, 1 );
                if ( mask == 0x80 ) {
                        out++;
                        accum = 0;
                }
        }
}

References bit, in, and out.

Referenced by des_round(), des_rounds(), and des_setkey().

des_sbox()

static uint32_t des_sbox ( uint32_t  in, const union des_round_key *  rkey  )

static

Perform DES S-box substitution.

Parameters

in	32-bit input value (native endian)
rkey	48-bit round key

Return values

out	32-bit output value (native endian)

Definition at line 410 of file des.c.

                                                                          {
        uint32_t out = 0;
        uint32_t lookup;
        int32_t key;
        uint8_t sub;
        unsigned int i;

        /* Perform input expansion, key addition, and S-box substitution */
        for ( i = 0 ; i < 8 ; i++ ) {

                /* Rotate input and output */
                out = rol32 ( out, 4 );
                in = rol32 ( in, 4 );

                /* Extract step key from relevant 6 bits of round key
                 *
                 * The least significant of the 6 bits (corresponding
                 * to bit r0 in the S-box lookup index) is stored in
                 * the sign bit of the step key byte.  It will
                 * therefore be propagated via sign extension to the
                 * MSB of the 32-bit step key.
                 *
                 * The remaining 5 of the 6 bits (corresponding to
                 * bits {r1,c3,c2,c1,c0} in the S-box lookup index)
                 * are stored in the least significant 5 bits of the
                 * step key byte and will end up in the least
                 * significant 5 bits of the 32-bit step key.
                 */
                key = rkey->step[i];

                /* Add step key to input to produce S-box lookup index
                 *
                 * We do not ever perform an explicit expansion of the
                 * input value from 32 to 48 bits.  Instead, we rotate
                 * the 32-bit input value by 4 bits on each step, and
                 * extract the relevant 6 bits.
                 *
                 * The least significant of the 6 bits (corresponding
                 * to bit r0 in the S-box lookup index) is currently
                 * in the MSB of the 32-bit (rotated) input value.
                 *
                 * The remaining 5 of the 6 bits (corresponding to
                 * bits {r1,c3,c2,c1,c0} in the S-box lookup index)
                 * are currently in the least significant 5 bits of
                 * the 32-bit (rotated) input value.
                 *
                 * This aligns with the placement of the bits in the
                 * step key (see above), and we can therefore perform
                 * a single XOR to add the 6-bit step key to the
                 * relevant 6 bits of the input value.
                 */
                lookup = ( in ^ key );

                /* Look up S[i][in ^ key] from S-box
                 *
                 * We have bits {r1,c3,c2,c1,c0} in the least
                 * significant 5 bits of the lookup index, and so can
                 * use the masked lookup index directly as a byte
                 * index into the relevant S-box to extract the byte
                 * containing both {r1,c3,c2,c1,c0,'0'} and
                 * {r1,c3,c2,c1,c0,'1'}.
                 *
                 * We then use the MSB of the 32-bit lookup index to
                 * extract the relevant nibble for the full lookup
                 * index {r1,c3,c2,c1,c0,r0}.
                 */
                sub = des_s[i][ lookup & 0x1f ];
                sub >>= ( ( lookup >> 29 ) & 4 );
                sub &= 0x0f;

                /* Substitute S[i][input ^ key] into output */
                out |= sub;
        }

        return out;
}

References des_s, in, key, out, rol32(), and des_round_key::step.

Referenced by des_round().

des_round()

static void des_round ( union des_block *  block, const union des_round_key *  rkey  )

static

Perform a single DES round.

Parameters

block	DES block
rkey	48-bit round key

Definition at line 493 of file des.c.

                                                          {
        union des_dword sbox;
        uint32_t left;
        uint32_t right;

        /* Extract left and right halves L[n-1] and R[n-1] */
        left = block->left.dword;
        right = block->right.dword;
        DBGC2 ( block, "DES L=%08x R=%08x K=%08x%08x", be32_to_cpu ( left ),
                be32_to_cpu ( right ), be32_to_cpu ( rkey->dword[0] ),
                be32_to_cpu ( rkey->dword[1] ) );

        /* L[n] = R[n-1] */
        block->left.dword = right;

        /* Calculate Feistel function f(R[n-1], K[n]) */
        sbox.dword = cpu_to_be32 ( des_sbox ( be32_to_cpu ( right ), rkey ) );
        des_permute ( des_p, sbox.byte, block->right.byte );

        /* R[n] = L[n-1] + f(R[n-1], K[n]) */
        block->right.dword ^= left;
        DBGC2 ( block, " => L=%08x R=%08x\n",
                be32_to_cpu ( block->left.dword ),
                be32_to_cpu ( block->right.dword ) );
}

References be32_to_cpu, block, des_dword::byte, cpu_to_be32, DBGC2, des_p, des_permute(), des_sbox(), des_dword::dword, and des_round_key::dword.

Referenced by des_rounds().

des_rounds()

static void des_rounds ( const union des_block *  in, union des_block *  out, const union des_round_key *  rkey, ssize_t  offset  )

static

Perform all DES rounds.

Parameters

in	Input DES block
out	Output DES block
rkey	Starting 48-bit round key
offset	Byte offset between round keys

Definition at line 528 of file des.c.

                                          {
        union des_block tmp;
        unsigned int i;

        /* Apply initial permutation */
        des_permute ( des_ip, in->byte, tmp.byte );

        /* Perform all DES rounds, consuming keys in the specified order */
        for ( i = 0 ; i < DES_ROUNDS ; i++ ) {
                des_round ( &tmp, rkey );
                rkey = ( ( ( void * ) rkey ) + offset );
        }

        /* Apply final permutation */
        DBGC ( &tmp, "DES %scrypted %08x%08x => ",
               ( ( offset > 0 ) ? "en" : "de" ), be32_to_cpu ( in->dword[0] ),
               be32_to_cpu ( in->dword[1] ) );
        des_permute ( des_fp, tmp.byte, out->byte );
        DBGC ( &tmp, "%08x%08x\n", be32_to_cpu ( out->dword[0] ),
               be32_to_cpu ( out->dword[1] ) );
}

References be32_to_cpu, DBGC, des_fp, des_ip, des_permute(), des_round(), DES_ROUNDS, in, offset, out, and tmp.

Referenced by des_decrypt(), and des_encrypt().

des_rol28()

static uint32_t des_rol28 ( uint32_t  dword )

static

Rotate 28-bit word.

Parameters

dword

28-bit dword value

Return values

dword

Rotated 28-bit dword value

Definition at line 558 of file des.c.

                                             {
        int32_t sdword;

        /* Convert to native-endian */
        sdword = be32_to_cpu ( dword );

        /* Signed shift right by 4 places to copy bit 31 to bits 27:31 */
        sdword >>= 4;

        /* Rotate left */
        sdword = rol32 ( sdword, 1 );

        /* Shift left by 4 places to restore bit positions */
        sdword <<= 4;

        /* Convert back to big-endian */
        dword = cpu_to_be32 ( sdword );

        return dword;
}

References be32_to_cpu, cpu_to_be32, and rol32().

Referenced by des_setkey().

des_setkey()

static int des_setkey ( void *  ctx, const void *  key, size_t  keylen  )

static

Set key.

Parameters

ctx	Context
key	Key
keylen	Key length

Return values

rc	Return status code

Definition at line 587 of file des.c.

                                                                    {
        struct des_context *des = ctx;
        union des_round_key *rkey = des->rkey;
        union des_block reg;
        uint32_t schedule;

        /* Validate key length */
        if ( keylen != DES_BLOCKSIZE )
                return -EINVAL;
        DBGC ( des, "DES %p new key:\n", des );
        DBGC_HDA ( des, 0, key, keylen );

        /* Apply permuted choice 1 */
        des_permute ( des_pc1c, key, reg.c.byte );
        des_permute ( des_pc1d, key, reg.d.byte );
        reg.d.byte[3] <<= 4; /* see comment for @c des_pc1d */
        DBGC2 ( des, "DES %p C[ 0]=%07x D[ 0]=%07x\n",
                des, ( be32_to_cpu ( reg.c.dword ) >> 4 ),
                ( be32_to_cpu ( reg.d.dword ) >> 4 ) );

        /* Generate round keys */
        for ( schedule = DES_SCHEDULE ; schedule ; schedule >>= 1 ) {

                /* Shift 28-bit words */
                reg.c.dword = des_rol28 ( reg.c.dword );
                reg.d.dword = des_rol28 ( reg.d.dword );

                /* Skip rounds according to shift schedule */
                if ( ! ( schedule & 1 ) )
                        continue;

                /* Apply permuted choice 2 */
                des_permute ( des_pc2, reg.byte, rkey->byte );
                DBGC2 ( des, "DES %p C[%2zd]=%07x D[%2zd]=%07x K[%2zd]="
                        "%08x%08x\n", des, ( ( rkey - des->rkey ) + 1 ),
                        ( be32_to_cpu ( reg.c.dword ) >> 4 ),
                        ( ( rkey - des->rkey ) + 1 ),
                        ( be32_to_cpu ( reg.d.dword ) >> 4 ),
                        ( ( rkey - des->rkey ) + 1 ),
                        be32_to_cpu ( rkey->dword[0] ),
                        be32_to_cpu ( rkey->dword[1] ) );

                /* Move to next key */
                rkey++;
        }

        /* Sanity check */
        assert ( rkey == &des->rkey[DES_ROUNDS] );

        return 0;
}

References assert(), be32_to_cpu, des_round_key::byte, ctx, DBGC, DBGC2, DBGC_HDA, DES_BLOCKSIZE, des_pc1c, des_pc1d, des_pc2, des_permute(), des_rol28(), DES_ROUNDS, DES_SCHEDULE, des_round_key::dword, EINVAL, key, reg, and des_context::rkey.

des_encrypt()

static void des_encrypt ( void *  ctx, const void *  src, void *  dst, size_t  len  )

static

Encrypt data.

Parameters

ctx	Context
src	Data to encrypt
dst	Buffer for encrypted data
len	Length of data

Definition at line 647 of file des.c.

                                                                              {
        struct des_context *des = ctx;

        /* Sanity check */
        assert ( len == DES_BLOCKSIZE );

        /* Cipher using keys in forward direction */
        des_rounds ( src, dst, &des->rkey[0], sizeof ( des->rkey[0] ) );
}

References assert(), ctx, DES_BLOCKSIZE, des_rounds(), len, des_context::rkey, and src.

des_decrypt()

static void des_decrypt ( void *  ctx, const void *  src, void *  dst, size_t  len  )

static

Decrypt data.

Parameters

ctx	Context
src	Data to decrypt
dst	Buffer for decrypted data
len	Length of data

Definition at line 665 of file des.c.

                                                                              {
        struct des_context *des = ctx;

        /* Sanity check */
        assert ( len == DES_BLOCKSIZE );

        /* Cipher using keys in reverse direction */
        des_rounds ( src, dst, &des->rkey[ DES_ROUNDS - 1 ],
                     -sizeof ( des->rkey[0] ) );
}

References assert(), ctx, DES_BLOCKSIZE, DES_ROUNDS, des_rounds(), len, des_context::rkey, and src.

ECB_CIPHER()

ECB_CIPHER	(	des_ecb	,
		des_ecb_algorithm	,
		des_algorithm	,
		struct des_context	,
		DES_BLOCKSIZE
	)

CBC_CIPHER()

CBC_CIPHER	(	des_cbc	,
		des_cbc_algorithm	,
		des_algorithm	,
		struct des_context	,
		DES_BLOCKSIZE
	)

Variable Documentation

des_s

const uint8_t des_s[8][32]

static

DES S-boxes S1..S8.

Definition at line 103 of file des.c.

Referenced by des_sbox().

des_pc1c

uint8_t des_pc1c[29]

static

DES permuted choice 1 (PC1) "C" register.

Definition at line 229 of file des.c.

Referenced by des_setkey().

des_pc1d

uint8_t des_pc1d[33]

static

DES permuted choice 1 (PC1) "D" register.

Definition at line 232 of file des.c.

Referenced by des_setkey().

des_pc2

const uint8_t des_pc2[65]

static

Initial value:

= {
        DES_PC2R ( 14, 17, 11, 24,  1,  5 ),
        DES_PC2R (  3, 28, 15,  6, 21, 10 ),
        DES_PC2R ( 23, 19, 12,  4, 26,  8 ),
        DES_PC2R ( 16,  7, 27, 20, 13,  2 ),
        DES_PC2R ( 41, 52, 31, 37, 47, 55 ),
        DES_PC2R ( 30, 40, 51, 45, 33, 48 ),
        DES_PC2R ( 44, 49, 39, 56, 34, 53 ),
        DES_PC2R ( 46, 42, 50, 36, 29, 32 ),
        0 
}

DES permuted choice 2 (PC2)

Definition at line 235 of file des.c.

Referenced by des_setkey().

des_ip

uint8_t des_ip[65]

static

DES initial permutation (IP)

Definition at line 248 of file des.c.

Referenced by des_rounds().

des_p

const uint8_t des_p[33]

static

Initial value:

= {
        16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,  5, 18, 31, 10,
         2,  8, 24, 14, 32, 27,  3,  9, 19, 13, 30,  6, 22, 11,  4, 25,
         0 
}

DES data permutation (P)

Definition at line 251 of file des.c.

Referenced by des_round().

des_fp

uint8_t des_fp[65]

static

DES final / inverse initial permutation (FP / IP^-1)

Definition at line 258 of file des.c.

Referenced by des_rounds().

des_generators

struct des_generator des_generators[]

static

Initial value:

= {

        
        DES_GENERATOR ( des_ip, 1, 1, 2, 1, 1, 1, 0, 0, 4, 0, 3, 1, 5 ),

        
        DES_GENERATOR ( des_fp, 1, 0, 0, 0, 2, 0, 1, 1, 5, 1, 4, 1, 3 ),

        
        DES_GENERATOR ( des_pc1c, 1, 1, 2, 1, 1, 1, 0, 0, 5, 0, 4, 0, 3 ),

        
        DES_GENERATOR ( des_pc1d, 0, 1, 2, 1, 1, 1, 0, 1, 5, 1, 4, 1, 3 ),
}

DES permutation generators.

Definition at line 261 of file des.c.

Referenced by des_init().

des_algorithm

struct cipher_algorithm des_algorithm

Initial value:

= {
        .name = "des",
        .ctxsize = sizeof ( struct des_context ),
        .blocksize = DES_BLOCKSIZE,
        .alignsize = 0,
        .authsize = 0,
        .setkey = des_setkey,
        .setiv = cipher_null_setiv,
        .encrypt = des_encrypt,
        .decrypt = des_decrypt,
        .auth = cipher_null_auth,
}

Basic DES algorithm.

Definition at line 677 of file des.c.

Referenced by mschapv2_challenge_response().