#include "c.h"
#include <limits.h>
#include <unistd.h>

Include dependency graph for crypt.c:

Data Structures
union	C_block
Defines
#define	B64 __int64
#define	STATIC static void
#define	_PASSWORD_EFMT1 '_'
#define	TO_SIX_BIT(rslt, src)
#define	ZERO(d, d0, d1) d0 = 0, d1 = 0
#define	LOAD(d, d0, d1, bl) d0 = (bl).b32.i0, d1 = (bl).b32.i1
#define	LOADREG(d, d0, d1, s, s0, s1) d0 = s0, d1 = s1
#define	OR(d, d0, d1, bl) d0 \|= (bl).b32.i0, d1 \|= (bl).b32.i1
#define	STORE(s, s0, s1, bl) (bl).b32.i0 = s0, (bl).b32.i1 = s1
#define	DCL_BLOCK(d, d0, d1) int32_t d0, d1
#define	LGCHUNKBITS 2
#define	CHUNKBITS (1<<LGCHUNKBITS)
#define	PERM6464(d, d0, d1, cpp, p) { C_block tblk; permute(cpp,&tblk,p,8); LOAD (d,d0,d1,tblk); }
#define	PERM3264(d, d0, d1, cpp, p) { C_block tblk; permute(cpp,&tblk,p,4); LOAD (d,d0,d1,tblk); }
#define	KS_SIZE 16
#define	SALT salt
#define	SPTAB(t, i) ((int32_t )((unsigned char )(t) + (i)(sizeof(int32_t)/4)))
#define	DOXOR(x, y, i) k=B.b[i]; x^=SPTAB(SPE[0][i],k); y^=SPTAB(SPE[1][i],k);
#define	CRUNCH(p0, p1, q0, q1)
Typedefs
typedef int	int32_t
Functions
static int	des_setkey (const char *key)
static int	des_cipher (const char in, char out, long salt, int num_iter)
STATIC	init_des (void)
STATIC	init_perm (C_block[64/CHUNKBITS][1<< CHUNKBITS], unsigned char[64], int, int)
STATIC	permute (unsigned char , C_block , C_block *, int)
char *	__md5crypt (const char , const char )
char *	__bcrypt (const char , const char )
char *	crypt (char key, const char setting) const
static int	des_setkey (char *key) const
static int	des_cipher (char in, char out, long salt, int num_iter) const
STATIC	init_perm (perm, p, int chars_in, int chars_out)
Variables
static const unsigned char	IP []
static const unsigned char	ExpandTr []
static const unsigned char	PC1 []
static const unsigned char	Rotates []
static const unsigned char	PC2 []
static const unsigned char	S [8][64]
static const unsigned char	P32Tr []
static const unsigned char	CIFP []
static const unsigned char	itoa64 [] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
static unsigned char	a64toi [128]
static C_block	PC1ROT [64/CHUNKBITS][1<< CHUNKBITS]
static C_block	PC2ROT [2][64/CHUNKBITS][1<< CHUNKBITS]
static C_block	IE3264 [32/CHUNKBITS][1<< CHUNKBITS]
static int32_t	SPE [2][8][64]
static C_block	CF6464 [64/CHUNKBITS][1<< CHUNKBITS]
static C_block	constdatablock
static char	cryptresult [1+4+4+11+1]
static C_block	KS [KS_SIZE]
static volatile int	des_ready = 0

Define Documentation

#define _PASSWORD_EFMT1 '_'

Definition at line 112 of file crypt.c.

Referenced by crypt().

#define B64 __int64

Definition at line 90 of file crypt.c.

#define CHUNKBITS (1<<LGCHUNKBITS)

Definition at line 285 of file crypt.c.

#define CRUNCH	(	p0,
		p1,
		q0,
		q1
	)

Value:

k = ((q0) ^ (q1)) & SALT;               \
            B.b32.i0 = k ^ (q0) ^ kp->b32.i0;       \
            B.b32.i1 = k ^ (q1) ^ kp->b32.i1;       \
            kp = (C_block *)((char *)kp+ks_inc);    \
                            \
            DOXOR(p0, p1, 0);       \
            DOXOR(p0, p1, 1);       \
            DOXOR(p0, p1, 2);       \
            DOXOR(p0, p1, 3);       \
            DOXOR(p0, p1, 4);       \
            DOXOR(p0, p1, 5);       \
            DOXOR(p0, p1, 6);       \
            DOXOR(p0, p1, 7);

Referenced by des_cipher().

#define DCL_BLOCK	(	d,
		d0,
		d1
	)		int32_t d0, d1

Definition at line 262 of file crypt.c.

Referenced by des_setkey(), and permute().

#define DOXOR	(	x,
		y,
		i
	)		k=B.b[i]; x^=SPTAB(SPE[0][i],k); y^=SPTAB(SPE[1][i],k);

#define KS_SIZE 16

Definition at line 624 of file crypt.c.

Referenced by des_cipher().

#define LGCHUNKBITS 2

Definition at line 284 of file crypt.c.

#define LOAD	(	d,
		d0,
		d1,
		bl
	)		d0 = (bl).b32.i0, d1 = (bl).b32.i1

Definition at line 258 of file crypt.c.

Referenced by des_cipher().

#define LOADREG	(	d,
		d0,
		d1,
		s,
		s0,
		s1
	)		d0 = s0, d1 = s1

Definition at line 259 of file crypt.c.

Referenced by des_cipher().

#define OR	(	d,
		d0,
		d1,
		bl
	)		d0 \|= (bl).b32.i0, d1 \|= (bl).b32.i1

Definition at line 260 of file crypt.c.

Referenced by permute().

#define PERM3264	(	d,
		d0,
		d1,
		cpp,
		p
	)		{ C_block tblk; permute(cpp,&tblk,p,4); LOAD (d,d0,d1,tblk); }

Definition at line 288 of file crypt.c.

Referenced by des_cipher().

#define PERM6464	(	d,
		d0,
		d1,
		cpp,
		p
	)		{ C_block tblk; permute(cpp,&tblk,p,8); LOAD (d,d0,d1,tblk); }

Definition at line 286 of file crypt.c.

Referenced by des_cipher(), and des_setkey().

#define SALT salt

#define SPTAB	(	t,
		i
	)		((int32_t )((unsigned char )(t) + (i)(sizeof(int32_t)/4)))

#define STATIC static void

Definition at line 101 of file crypt.c.

#define STORE	(	s,
		s0,
		s1,
		bl
	)		(bl).b32.i0 = s0, (bl).b32.i1 = s1

Definition at line 261 of file crypt.c.

Referenced by des_cipher(), des_setkey(), and permute().

#define TO_SIX_BIT	(	rslt,
		src
	)

Value:

{               \
        C_block cvt;                \
        cvt.b[0] = src; src >>= 6;      \
        cvt.b[1] = src; src >>= 6;      \
        cvt.b[2] = src; src >>= 6;      \
        cvt.b[3] = src;             \
        rslt = (cvt.b32.i0 & 0x3f3f3f3fL) << 2; \
    }

Definition at line 245 of file crypt.c.

Referenced by des_cipher(), and init_des().

#define ZERO	(	d,
		d0,
		d1
	)		d0 = 0, d1 = 0

Definition at line 257 of file crypt.c.

Referenced by permute().

Typedef Documentation

typedef int int32_t

Definition at line 108 of file crypt.c.

Function Documentation

char* __bcrypt	(	const char *	,
		const char *
	)

Referenced by crypt().

char* __md5crypt	(	const char *	,
		const char *
	)

Referenced by crypt().

char* crypt	(	char *	key,
		const char *	setting
	)			const

Definition at line 492 of file crypt.c.

References __bcrypt(), __md5crypt(), _PASSWORD_EFMT1, a64toi, C_block::b, cryptresult, des_cipher(), des_setkey(), i, itoa64, and NULL.

{
    char       *encp;
    int32_t     i;
    int         t;
    int32_t     salt;
    int         num_iter,
                salt_size;
    C_block     keyblock,
                rsltblock;

#if 0
    /* Non-DES encryption schemes hook in here. */
    if (setting[0] == _PASSWORD_NONDES)
    {
        switch (setting[1])
        {
            case '2':
                return (__bcrypt(key, setting));
            case '1':
            default:
                return (__md5crypt(key, setting));
        }
    }
#endif

    for (i = 0; i < 8; i++)
    {
        if ((t = 2 * (unsigned char) (*key)) != 0)
            key++;
        keyblock.b[i] = t;
    }
    if (des_setkey((char *) keyblock.b))        /* also initializes "a64toi" */
        return (NULL);

    encp = &cryptresult[0];
    switch (*setting)
    {
        case _PASSWORD_EFMT1:

            /*
             * Involve the rest of the password 8 characters at a time.
             */
            while (*key)
            {
                if (des_cipher((char *) (void *) &keyblock,
                               (char *) (void *) &keyblock, 0L, 1))
                    return (NULL);
                for (i = 0; i < 8; i++)
                {
                    if ((t = 2 * (unsigned char) (*key)) != 0)
                        key++;
                    keyblock.b[i] ^= t;
                }
                if (des_setkey((char *) keyblock.b))
                    return (NULL);
            }

            *encp++ = *setting++;

            /* get iteration count */
            num_iter = 0;
            for (i = 4; --i >= 0;)
            {
                if ((t = (unsigned char) setting[i]) == '\0')
                    t = '.';
                encp[i] = t;
                num_iter = (num_iter << 6) | a64toi[t];
            }
            setting += 4;
            encp += 4;
            salt_size = 4;
            break;
        default:
            num_iter = 25;
            salt_size = 2;
    }

    salt = 0;
    for (i = salt_size; --i >= 0;)
    {
        if ((t = (unsigned char) setting[i]) == '\0')
            t = '.';
        encp[i] = t;
        salt = (salt << 6) | a64toi[t];
    }
    encp += salt_size;
    if (des_cipher((char *) (void *) &constdatablock,
                   (char *) (void *) &rsltblock, salt, num_iter))
        return (NULL);

    /*
     * Encode the 64 cipher bits as 11 ascii characters.
     */
    i = ((int32_t) ((rsltblock.b[0] << 8) | rsltblock.b[1]) << 8) |
        rsltblock.b[2];
    encp[3] = itoa64[i & 0x3f];
    i >>= 6;
    encp[2] = itoa64[i & 0x3f];
    i >>= 6;
    encp[1] = itoa64[i & 0x3f];
    i >>= 6;
    encp[0] = itoa64[i];
    encp += 4;
    i = ((int32_t) ((rsltblock.b[3] << 8) | rsltblock.b[4]) << 8) |
        rsltblock.b[5];
    encp[3] = itoa64[i & 0x3f];
    i >>= 6;
    encp[2] = itoa64[i & 0x3f];
    i >>= 6;
    encp[1] = itoa64[i & 0x3f];
    i >>= 6;
    encp[0] = itoa64[i];
    encp += 4;
    i = ((int32_t) ((rsltblock.b[6]) << 8) | rsltblock.b[7]) << 2;
    encp[2] = itoa64[i & 0x3f];
    i >>= 6;
    encp[1] = itoa64[i & 0x3f];
    i >>= 6;
    encp[0] = itoa64[i];

    encp[3] = 0;

    return (cryptresult);
}

static int des_cipher	(	char *	in,
		char *	out,
		long	salt,
		int	num_iter
	)			const `[static]`

Definition at line 666 of file crypt.c.

References C_block::b, CRUNCH, KS_SIZE, LOAD, LOADREG, PERM3264, PERM6464, R, STORE, and TO_SIX_BIT.

{
    /* variables that we want in registers, most important first */
#if defined(pdp11)
    int         j;
#endif
    int32_t     L0,
                L1,
                R0,
                R1,
                k;
    C_block    *kp;
    int         ks_inc,
                loop_count;
    C_block     B;

    L0 = salt;
    TO_SIX_BIT(salt, L0);       /* convert to 4*(6+2) format */

#if defined(__vax__) || defined(pdp11)
    salt = ~salt;               /* "x &~ y" is faster than "x & y". */
#define SALT (~salt)
#else
#define SALT salt
#endif

#if defined(MUST_ALIGN)
    B.b[0] = in[0];
    B.b[1] = in[1];
    B.b[2] = in[2];
    B.b[3] = in[3];
    B.b[4] = in[4];
    B.b[5] = in[5];
    B.b[6] = in[6];
    B.b[7] = in[7];
    LOAD(L, L0, L1, B);
#else
    LOAD(L, L0, L1, *(C_block *) in);
#endif
    LOADREG(R, R0, R1, L, L0, L1);
    L0 &= 0x55555555L;
    L1 &= 0x55555555L;
    L0 = (L0 << 1) | L1;        /* L0 is the even-numbered input bits */
    R0 &= 0xaaaaaaaaL;
    R1 = (R1 >> 1) & 0x55555555L;
    L1 = R0 | R1;               /* L1 is the odd-numbered input bits */
    STORE(L, L0, L1, B);
    PERM3264(L, L0, L1, B.b, (C_block *) IE3264);       /* even bits */
    PERM3264(R, R0, R1, B.b + 4, (C_block *) IE3264);   /* odd bits */

    if (num_iter >= 0)
    {                           /* encryption */
        kp = &KS[0];
        ks_inc = sizeof(*kp);
    }
    else
    {                           /* decryption */
        num_iter = -num_iter;
        kp = &KS[KS_SIZE - 1];
        ks_inc = -(long) sizeof(*kp);
    }

    while (--num_iter >= 0)
    {
        loop_count = 8;
        do
        {

#define SPTAB(t, i) \
        (*(int32_t *)((unsigned char *)(t) + (i)*(sizeof(int32_t)/4)))
#if defined(gould)
            /* use this if B.b[i] is evaluated just once ... */
#define DOXOR(x,y,i)    x^=SPTAB(SPE[0][i],B.b[i]); y^=SPTAB(SPE[1][i],B.b[i]);
#else
#if defined(pdp11)
            /* use this if your "long" int indexing is slow */
#define DOXOR(x,y,i)    j=B.b[i]; x^=SPTAB(SPE[0][i],j); y^=SPTAB(SPE[1][i],j);
#else
            /* use this if "k" is allocated to a register ... */
#define DOXOR(x,y,i)    k=B.b[i]; x^=SPTAB(SPE[0][i],k); y^=SPTAB(SPE[1][i],k);
#endif
#endif

#define CRUNCH(p0, p1, q0, q1)  \
            k = ((q0) ^ (q1)) & SALT;               \
            B.b32.i0 = k ^ (q0) ^ kp->b32.i0;       \
            B.b32.i1 = k ^ (q1) ^ kp->b32.i1;       \
            kp = (C_block *)((char *)kp+ks_inc);    \
                            \
            DOXOR(p0, p1, 0);       \
            DOXOR(p0, p1, 1);       \
            DOXOR(p0, p1, 2);       \
            DOXOR(p0, p1, 3);       \
            DOXOR(p0, p1, 4);       \
            DOXOR(p0, p1, 5);       \
            DOXOR(p0, p1, 6);       \
            DOXOR(p0, p1, 7);

            CRUNCH(L0, L1, R0, R1);
            CRUNCH(R0, R1, L0, L1);
        } while (--loop_count != 0);
        kp = (C_block *) ((char *) kp - (ks_inc * KS_SIZE));


        /* swap L and R */
        L0 ^= R0;
        L1 ^= R1;
        R0 ^= L0;
        R1 ^= L1;
        L0 ^= R0;
        L1 ^= R1;
    }

    /* store the encrypted (or decrypted) result */
    L0 = ((L0 >> 3) & 0x0f0f0f0fL) | ((L1 << 1) & 0xf0f0f0f0L);
    L1 = ((R0 >> 3) & 0x0f0f0f0fL) | ((R1 << 1) & 0xf0f0f0f0L);
    STORE(L, L0, L1, B);
    PERM6464(L, L0, L1, B.b, (C_block *) CF6464);
#if defined(MUST_ALIGN)
    STORE(L, L0, L1, B);
    out[0] = B.b[0];
    out[1] = B.b[1];
    out[2] = B.b[2];
    out[3] = B.b[3];
    out[4] = B.b[4];
    out[5] = B.b[5];
    out[6] = B.b[6];
    out[7] = B.b[7];
#else
    STORE(L, L0, L1, *(C_block *) out);
#endif
    return (0);
}

static int des_cipher	(	const char *	in,
		char *	out,
		long	salt,
		int	num_iter
	)			`[static]`

static int des_setkey ( char * key ) const [static]

Definition at line 633 of file crypt.c.

References DCL_BLOCK, des_ready, i, init_des(), K, PERM6464, Rotates, and STORE.

{
    DCL_BLOCK(K, K0, K1);
    C_block    *ptabp;
    int         i;

    if (!des_ready)
        init_des();

    PERM6464(K, K0, K1, (unsigned char *) key, (C_block *) PC1ROT);
    key = (char *) &KS[0];
    STORE(K & ~0x03030303L, K0 & ~0x03030303L, K1, *(C_block *) key);
    for (i = 1; i < 16; i++)
    {
        key += sizeof(C_block);
        STORE(K, K0, K1, *(C_block *) key);
        ptabp = (C_block *) PC2ROT[Rotates[i] - 1];
        PERM6464(K, K0, K1, (unsigned char *) key, ptabp);
        STORE(K & ~0x03030303L, K0 & ~0x03030303L, K1, *(C_block *) key);
    }
    return (0);
}

static int des_setkey ( const char * key ) [static]

STATIC init_des ( void )

Definition at line 810 of file crypt.c.

References a64toi, CIFP, des_ready, ExpandTr, i, init_perm, IP, itoa64, P32Tr, PC1, PC2, Rotates, S, SPE, and TO_SIX_BIT.

Referenced by des_setkey().

{
    int         i,
                j;
    int32_t     k;
    int         tableno;
    static unsigned char perm[64],
                tmp32[32];      /* "static" for speed */

/*  static volatile long init_start = 0; not used */

    /*
     * table that converts chars "./0-9A-Za-z"to integers 0-63.
     */
    for (i = 0; i < 64; i++)
        a64toi[itoa64[i]] = i;

    /*
     * PC1ROT - bit reverse, then PC1, then Rotate, then PC2.
     */
    for (i = 0; i < 64; i++)
        perm[i] = 0;
    for (i = 0; i < 64; i++)
    {
        if ((k = PC2[i]) == 0)
            continue;
        k += Rotates[0] - 1;
        if ((k % 28) < Rotates[0])
            k -= 28;
        k = PC1[k];
        if (k > 0)
        {
            k--;
            k = (k | 07) - (k & 07);
            k++;
        }
        perm[i] = k;
    }
#ifdef DEBUG
    prtab("pc1tab", perm, 8);
#endif
    init_perm(PC1ROT, perm, 8, 8);

    /*
     * PC2ROT - PC2 inverse, then Rotate (once or twice), then PC2.
     */
    for (j = 0; j < 2; j++)
    {
        unsigned char pc2inv[64];

        for (i = 0; i < 64; i++)
            perm[i] = pc2inv[i] = 0;
        for (i = 0; i < 64; i++)
        {
            if ((k = PC2[i]) == 0)
                continue;
            pc2inv[k - 1] = i + 1;
        }
        for (i = 0; i < 64; i++)
        {
            if ((k = PC2[i]) == 0)
                continue;
            k += j;
            if ((k % 28) <= j)
                k -= 28;
            perm[i] = pc2inv[k];
        }
#ifdef DEBUG
        prtab("pc2tab", perm, 8);
#endif
        init_perm(PC2ROT[j], perm, 8, 8);
    }

    /*
     * Bit reverse, then initial permutation, then expansion.
     */
    for (i = 0; i < 8; i++)
    {
        for (j = 0; j < 8; j++)
        {
            k = (j < 2) ? 0 : IP[ExpandTr[i * 6 + j - 2] - 1];
            if (k > 32)
                k -= 32;
            else if (k > 0)
                k--;
            if (k > 0)
            {
                k--;
                k = (k | 07) - (k & 07);
                k++;
            }
            perm[i * 8 + j] = k;
        }
    }
#ifdef DEBUG
    prtab("ietab", perm, 8);
#endif
    init_perm(IE3264, perm, 4, 8);

    /*
     * Compression, then final permutation, then bit reverse.
     */
    for (i = 0; i < 64; i++)
    {
        k = IP[CIFP[i] - 1];
        if (k > 0)
        {
            k--;
            k = (k | 07) - (k & 07);
            k++;
        }
        perm[k - 1] = i + 1;
    }
#ifdef DEBUG
    prtab("cftab", perm, 8);
#endif
    init_perm(CF6464, perm, 8, 8);

    /*
     * SPE table
     */
    for (i = 0; i < 48; i++)
        perm[i] = P32Tr[ExpandTr[i] - 1];
    for (tableno = 0; tableno < 8; tableno++)
    {
        for (j = 0; j < 64; j++)
        {
            k = (((j >> 0) & 01) << 5) |
                (((j >> 1) & 01) << 3) |
                (((j >> 2) & 01) << 2) |
                (((j >> 3) & 01) << 1) |
                (((j >> 4) & 01) << 0) |
                (((j >> 5) & 01) << 4);
            k = S[tableno][k];
            k = (((k >> 3) & 01) << 0) |
                (((k >> 2) & 01) << 1) |
                (((k >> 1) & 01) << 2) |
                (((k >> 0) & 01) << 3);
            for (i = 0; i < 32; i++)
                tmp32[i] = 0;
            for (i = 0; i < 4; i++)
                tmp32[4 * tableno + i] = (k >> i) & 01;
            k = 0;
            for (i = 24; --i >= 0;)
                k = (k << 1) | tmp32[perm[i] - 1];
            TO_SIX_BIT(SPE[0][tableno][j], k);
            k = 0;
            for (i = 24; --i >= 0;)
                k = (k << 1) | tmp32[perm[i + 24] - 1];
            TO_SIX_BIT(SPE[1][tableno][j], k);
        }
    }

    des_ready = 1;
}

STATIC init_perm	(	perm	,
		p	,
		int	chars_in,
		int	chars_out
	)

Definition at line 975 of file crypt.c.

References i.

{
    int         i,
                j,
                k,
                l;

    for (k = 0; k < chars_out * 8; k++)
    {                           /* each output bit position */
        l = p[k] - 1;           /* where this bit comes from */
        if (l < 0)
            continue;           /* output bit is always 0 */
        i = l >> LGCHUNKBITS;   /* which chunk this bit comes from */
        l = 1 << (l & (CHUNKBITS - 1)); /* mask for this bit */
        for (j = 0; j < (1 << CHUNKBITS); j++)
        {                       /* each chunk value */
            if ((j & l) != 0)
                perm[i][j].b[k >> 3] |= 1 << (k & 07);
        }
    }
}

STATIC init_perm	(	C_block	[64/CHUNKBITS][1<< CHUNKBITS],
		unsigned	char[64],
		int	,
		int
	)

STATIC permute	(	unsigned char *	cp,
		C_block *	out,
		C_block *	p,
		int	chars_in
	)

Definition at line 305 of file crypt.c.

References DCL_BLOCK, OR, STORE, and ZERO.

{
    DCL_BLOCK(D, D0, D1);
    C_block    *tp;
    int         t;

    ZERO(D, D0, D1);
    do
    {
        t = *cp++;
        tp = &p[t & 0xf];
        OR(D, D0, D1, *tp);
        p += (1 << CHUNKBITS);
        tp = &p[t >> 4];
        OR(D, D0, D1, *tp);
        p += (1 << CHUNKBITS);
    } while (--chars_in > 0);
    STORE(D, D0, D1, *out);
}

Variable Documentation

unsigned char a64toi[128] [static]

Definition at line 459 of file crypt.c.

Referenced by crypt(), and init_des().

C_block CF6464[64/CHUNKBITS][1<< CHUNKBITS] [static]

Definition at line 474 of file crypt.c.

const unsigned char CIFP[] [static]

Initial value:

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

    33, 34, 35, 36, 49, 50, 51, 52,
    37, 38, 39, 40, 53, 54, 55, 56,
    41, 42, 43, 44, 57, 58, 59, 60,
    45, 46, 47, 48, 61, 62, 63, 64,
}

Definition at line 440 of file crypt.c.

Referenced by init_des().

C_block constdatablock [static]

Definition at line 480 of file crypt.c.

char cryptresult[1+4+4+11+1] [static]

Definition at line 481 of file crypt.c.

Referenced by crypt().

volatile int des_ready = 0 [static]

Definition at line 627 of file crypt.c.

Referenced by des_setkey(), and init_des().

const unsigned char ExpandTr[] [static]

Initial value:

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

Definition at line 346 of file crypt.c.

Referenced by init_des().

C_block IE3264[32/CHUNKBITS][1<< CHUNKBITS] [static]

Definition at line 468 of file crypt.c.

const unsigned char IP[] [static]

Initial value:

 {      
    58, 50, 42, 34, 26, 18, 10, 2,
    60, 52, 44, 36, 28, 20, 12, 4,
    62, 54, 46, 38, 30, 22, 14, 6,
    64, 56, 48, 40, 32, 24, 16, 8,
    57, 49, 41, 33, 25, 17, 9, 1,
    59, 51, 43, 35, 27, 19, 11, 3,
    61, 53, 45, 37, 29, 21, 13, 5,
    63, 55, 47, 39, 31, 23, 15, 7,
}

Definition at line 333 of file crypt.c.

Referenced by init_des().

const unsigned char itoa64[] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" [static]

Definition at line 452 of file crypt.c.

Referenced by crypt(), and init_des().

C_block KS[KS_SIZE] [static]

Definition at line 625 of file crypt.c.

const unsigned char P32Tr[] [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,
}

Definition at line 429 of file crypt.c.

Referenced by init_des().

const unsigned char PC1[] [static]

Initial value:

 {  
    57, 49, 41, 33, 25, 17, 9,
    1, 58, 50, 42, 34, 26, 18,
    10, 2, 59, 51, 43, 35, 27,
    19, 11, 3, 60, 52, 44, 36,

    63, 55, 47, 39, 31, 23, 15,
    7, 62, 54, 46, 38, 30, 22,
    14, 6, 61, 53, 45, 37, 29,
    21, 13, 5, 28, 20, 12, 4,
}

Definition at line 357 of file crypt.c.

Referenced by init_des().

C_block PC1ROT[64/CHUNKBITS][1<< CHUNKBITS] [static]

Definition at line 462 of file crypt.c.

const unsigned char PC2[] [static]

Initial value:

 {  
    9, 18, 14, 17, 11, 24, 1, 5,
    22, 25, 3, 28, 15, 6, 21, 10,
    35, 38, 23, 19, 12, 4, 26, 8,
    43, 54, 16, 7, 27, 20, 13, 2,

    0, 0, 41, 52, 31, 37, 47, 55,
    0, 0, 30, 40, 51, 45, 33, 48,
    0, 0, 44, 49, 39, 56, 34, 53,
    0, 0, 46, 42, 50, 36, 29, 32,
}

Definition at line 374 of file crypt.c.

Referenced by init_des().

C_block PC2ROT[2][64/CHUNKBITS][1<< CHUNKBITS] [static]

Definition at line 465 of file crypt.c.

const unsigned char Rotates[] [static]

Initial value:

 {      
    1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1,
}

Definition at line 369 of file crypt.c.

Referenced by des_setkey(), and init_des().

const unsigned char S[8][64] [static]

Definition at line 386 of file crypt.c.

Referenced by init_des().

int32_t SPE[2][8][64] [static]

Definition at line 471 of file crypt.c.

Referenced by init_des().

Header And Logo

crypt.c File Reference

Data Structures

Defines

Typedefs

Functions

Variables

Define Documentation

Typedef Documentation

Function Documentation

Variable Documentation