Back to index

php5  5.3.10
Defines | Functions | Variables
crypt_freesec.c File Reference
#include <sys/types.h>
#include <string.h>
#include "crypt_freesec.h"

Go to the source code of this file.

Defines

#define _PASSWORD_EFMT1   '_'

Functions

static int ascii_to_bin (char ch)
static int ascii_is_unsafe (char ch)
void _crypt_extended_init (void)
static void des_init_local (struct php_crypt_extended_data *data)
static void setup_salt (uint32_t salt, struct php_crypt_extended_data *data)
static int des_setkey (const char *key, struct php_crypt_extended_data *data)
static int do_des (uint32_t l_in, uint32_t r_in, uint32_t *l_out, uint32_t *r_out, int count, struct php_crypt_extended_data *data)
static int des_cipher (const char *in, char *out, uint32_t salt, int count, struct php_crypt_extended_data *data)
char * _crypt_extended_r (const char *key, const char *setting, struct php_crypt_extended_data *data)

Variables

static u_char IP [64]
static u_char key_perm [56]
static u_char key_shifts [16]
static u_char comp_perm [48]
static u_char sbox [8][64]
static u_char pbox [32]
static uint32_t bits32 [32]
static u_char bits8 [8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }
static unsigned char ascii64 [] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
static u_char m_sbox [4][4096]
static uint32_t psbox [4][256]
static uint32_t ip_maskl [8][256]
static uint32_t ip_maskr [8][256]
static uint32_t fp_maskl [8][256]
static uint32_t fp_maskr [8][256]
static uint32_t key_perm_maskl [8][128]
static uint32_t key_perm_maskr [8][128]
static uint32_t comp_maskl [8][128]
static uint32_t comp_maskr [8][128]

Define Documentation

#define _PASSWORD_EFMT1   '_'

Definition at line 74 of file crypt_freesec.c.


Function Documentation

void _crypt_extended_init ( void  )

Definition at line 215 of file crypt_freesec.c.

{
       int i, j, b, k, inbit, obit;
       uint32_t *p, *il, *ir, *fl, *fr;
       uint32_t *bits28, *bits24;
       u_char inv_key_perm[64];
       u_char u_key_perm[56];
       u_char inv_comp_perm[56];
       u_char init_perm[64], final_perm[64];
       u_char u_sbox[8][64];
       u_char un_pbox[32];

       bits24 = (bits28 = bits32 + 4) + 4;

       /*
        * Invert the S-boxes, reordering the input bits.
        */
       for (i = 0; i < 8; i++)
              for (j = 0; j < 64; j++) {
                     b = (j & 0x20) | ((j & 1) << 4) | ((j >> 1) & 0xf);
                     u_sbox[i][j] = sbox[i][b];
              }

       /*
        * Convert the inverted S-boxes into 4 arrays of 8 bits.
        * Each will handle 12 bits of the S-box input.
        */
       for (b = 0; b < 4; b++)
              for (i = 0; i < 64; i++)
                     for (j = 0; j < 64; j++)
                            m_sbox[b][(i << 6) | j] =
                                   (u_sbox[(b << 1)][i] << 4) |
                                   u_sbox[(b << 1) + 1][j];

       /*
        * Set up the initial & final permutations into a useful form, and
        * initialise the inverted key permutation.
        */
       for (i = 0; i < 64; i++) {
              init_perm[final_perm[i] = IP[i] - 1] = i;
              inv_key_perm[i] = 255;
       }

       /*
        * Invert the key permutation and initialise the inverted key
        * compression permutation.
        */
       for (i = 0; i < 56; i++) {
              u_key_perm[i] = key_perm[i] - 1;
              inv_key_perm[key_perm[i] - 1] = i;
              inv_comp_perm[i] = 255;
       }

       /*
        * Invert the key compression permutation.
        */
       for (i = 0; i < 48; i++) {
              inv_comp_perm[comp_perm[i] - 1] = i;
       }

       /*
        * Set up the OR-mask arrays for the initial and final permutations,
        * and for the key initial and compression permutations.
        */
       for (k = 0; k < 8; k++) {
              for (i = 0; i < 256; i++) {
                     *(il = &ip_maskl[k][i]) = 0;
                     *(ir = &ip_maskr[k][i]) = 0;
                     *(fl = &fp_maskl[k][i]) = 0;
                     *(fr = &fp_maskr[k][i]) = 0;
                     for (j = 0; j < 8; j++) {
                            inbit = 8 * k + j;
                            if (i & bits8[j]) {
                                   if ((obit = init_perm[inbit]) < 32)
                                          *il |= bits32[obit];
                                   else
                                          *ir |= bits32[obit-32];
                                   if ((obit = final_perm[inbit]) < 32)
                                          *fl |= bits32[obit];
                                   else
                                          *fr |= bits32[obit - 32];
                            }
                     }
              }
              for (i = 0; i < 128; i++) {
                     *(il = &key_perm_maskl[k][i]) = 0;
                     *(ir = &key_perm_maskr[k][i]) = 0;
                     for (j = 0; j < 7; j++) {
                            inbit = 8 * k + j;
                            if (i & bits8[j + 1]) {
                                   if ((obit = inv_key_perm[inbit]) == 255)
                                          continue;
                                   if (obit < 28)
                                          *il |= bits28[obit];
                                   else
                                          *ir |= bits28[obit - 28];
                            }
                     }
                     *(il = &comp_maskl[k][i]) = 0;
                     *(ir = &comp_maskr[k][i]) = 0;
                     for (j = 0; j < 7; j++) {
                            inbit = 7 * k + j;
                            if (i & bits8[j + 1]) {
                                   if ((obit=inv_comp_perm[inbit]) == 255)
                                          continue;
                                   if (obit < 24)
                                          *il |= bits24[obit];
                                   else
                                          *ir |= bits24[obit - 24];
                            }
                     }
              }
       }

       /*
        * Invert the P-box permutation, and convert into OR-masks for
        * handling the output of the S-box arrays setup above.
        */
       for (i = 0; i < 32; i++)
              un_pbox[pbox[i] - 1] = i;

       for (b = 0; b < 4; b++)
              for (i = 0; i < 256; i++) {
                     *(p = &psbox[b][i]) = 0;
                     for (j = 0; j < 8; j++) {
                            if (i & bits8[j])
                                   *p |= bits32[un_pbox[8 * b + j]];
                     }
              }
}

Here is the caller graph for this function:

char* _crypt_extended_r ( const char *  key,
const char *  setting,
struct php_crypt_extended_data data 
)

Definition at line 616 of file crypt_freesec.c.

{
       int           i;
       uint32_t      count, salt, l, r0, r1, keybuf[2];
       u_char        *p, *q;

       if (!data->initialized)
              des_init_local(data);

       /*
        * Copy the key, shifting each character up by one bit
        * and padding with zeros.
        */
       q = (u_char *) keybuf;
       while (q - (u_char *) keybuf < sizeof(keybuf)) {
              if ((*q++ = *key << 1))
                     key++;
       }
       if (des_setkey((u_char *) keybuf, data))
              return(NULL);

       if (*setting == _PASSWORD_EFMT1) {
              /*
               * "new"-style:
               *     setting - underscore, 4 chars of count, 4 chars of salt
               *     key - unlimited characters
               */
              for (i = 1, count = 0; i < 5; i++) {
                     int value = ascii_to_bin(setting[i]);
                     if (ascii64[value] != setting[i])
                            return(NULL);
                     count |= value << (i - 1) * 6;
              }
              if (!count)
                     return(NULL);

              for (i = 5, salt = 0; i < 9; i++) {
                     int value = ascii_to_bin(setting[i]);
                     if (ascii64[value] != setting[i])
                            return(NULL);
                     salt |= value << (i - 5) * 6;
              }

              while (*key) {
                     /*
                      * Encrypt the key with itself.
                      */
                     if (des_cipher((u_char *) keybuf, (u_char *) keybuf,
                         0, 1, data))
                            return(NULL);
                     /*
                      * And XOR with the next 8 characters of the key.
                      */
                     q = (u_char *) keybuf;
                     while (q - (u_char *) keybuf < sizeof(keybuf) && *key)
                            *q++ ^= *key++ << 1;

                     if (des_setkey((u_char *) keybuf, data))
                            return(NULL);
              }
              memcpy(data->output, setting, 9);
              data->output[9] = '\0';
              p = (u_char *) data->output + 9;
       } else {
              /*
               * "old"-style:
               *     setting - 2 chars of salt
               *     key - up to 8 characters
               */
              count = 25;

              if (ascii_is_unsafe(setting[0]) || ascii_is_unsafe(setting[1]))
                     return(NULL);

              salt = (ascii_to_bin(setting[1]) << 6)
                   |  ascii_to_bin(setting[0]);

              data->output[0] = setting[0];
              data->output[1] = setting[1];
              p = (u_char *) data->output + 2;
       }
       setup_salt(salt, data);
       /*
        * Do it.
        */
       if (do_des(0, 0, &r0, &r1, count, data))
              return(NULL);
       /*
        * Now encode the result...
        */
       l = (r0 >> 8);
       *p++ = ascii64[(l >> 18) & 0x3f];
       *p++ = ascii64[(l >> 12) & 0x3f];
       *p++ = ascii64[(l >> 6) & 0x3f];
       *p++ = ascii64[l & 0x3f];

       l = (r0 << 16) | ((r1 >> 16) & 0xffff);
       *p++ = ascii64[(l >> 18) & 0x3f];
       *p++ = ascii64[(l >> 12) & 0x3f];
       *p++ = ascii64[(l >> 6) & 0x3f];
       *p++ = ascii64[l & 0x3f];

       l = r1 << 2;
       *p++ = ascii64[(l >> 12) & 0x3f];
       *p++ = ascii64[(l >> 6) & 0x3f];
       *p++ = ascii64[l & 0x3f];
       *p = 0;

       return(data->output);
}

Here is the call graph for this function:

static int ascii_is_unsafe ( char  ch) [inline, static]

Definition at line 209 of file crypt_freesec.c.

{
       return !ch || ch == '\n' || ch == ':';
}

Here is the caller graph for this function:

static int ascii_to_bin ( char  ch) [inline, static]

Definition at line 188 of file crypt_freesec.c.

{
       signed char sch = ch;
       int retval;

       retval = sch - '.';
       if (sch >= 'A') {
              retval = sch - ('A' - 12);
              if (sch >= 'a')
                     retval = sch - ('a' - 38);
       }
       retval &= 0x3f;

       return(retval);
}

Here is the caller graph for this function:

static int des_cipher ( const char *  in,
char *  out,
uint32_t  salt,
int  count,
struct php_crypt_extended_data data 
) [static]

Definition at line 582 of file crypt_freesec.c.

{
       uint32_t      l_out, r_out, rawl, rawr;
       int    retval;

       setup_salt(salt, data);

       rawl =
              (uint32_t)(u_char)in[3] |
              ((uint32_t)(u_char)in[2] << 8) |
              ((uint32_t)(u_char)in[1] << 16) |
              ((uint32_t)(u_char)in[0] << 24);
       rawr =
              (uint32_t)(u_char)in[7] |
              ((uint32_t)(u_char)in[6] << 8) |
              ((uint32_t)(u_char)in[5] << 16) |
              ((uint32_t)(u_char)in[4] << 24);

       retval = do_des(rawl, rawr, &l_out, &r_out, count, data);

       out[0] = l_out >> 24;
       out[1] = l_out >> 16;
       out[2] = l_out >> 8;
       out[3] = l_out;
       out[4] = r_out >> 24;
       out[5] = r_out >> 16;
       out[6] = r_out >> 8;
       out[7] = r_out;

       return(retval);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void des_init_local ( struct php_crypt_extended_data data) [static]

Definition at line 347 of file crypt_freesec.c.

{
       data->old_rawkey0 = data->old_rawkey1 = 0;
       data->saltbits = 0;
       data->old_salt = 0;

       data->initialized = 1;
}

Here is the caller graph for this function:

static int des_setkey ( const char *  key,
struct php_crypt_extended_data data 
) [static]

Definition at line 379 of file crypt_freesec.c.

{
       uint32_t      k0, k1, rawkey0, rawkey1;
       int    shifts, round;

       rawkey0 =
              (uint32_t)(u_char)key[3] |
              ((uint32_t)(u_char)key[2] << 8) |
              ((uint32_t)(u_char)key[1] << 16) |
              ((uint32_t)(u_char)key[0] << 24);
       rawkey1 =
              (uint32_t)(u_char)key[7] |
              ((uint32_t)(u_char)key[6] << 8) |
              ((uint32_t)(u_char)key[5] << 16) |
              ((uint32_t)(u_char)key[4] << 24);

       if ((rawkey0 | rawkey1)
           && rawkey0 == data->old_rawkey0
           && rawkey1 == data->old_rawkey1) {
              /*
               * Already setup for this key.
               * This optimisation fails on a zero key (which is weak and
               * has bad parity anyway) in order to simplify the starting
               * conditions.
               */
              return(0);
       }
       data->old_rawkey0 = rawkey0;
       data->old_rawkey1 = rawkey1;

       /*
        *     Do key permutation and split into two 28-bit subkeys.
        */
       k0 = key_perm_maskl[0][rawkey0 >> 25]
          | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
          | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f]
          | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f]
          | key_perm_maskl[4][rawkey1 >> 25]
          | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f]
          | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f]
          | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f];
       k1 = key_perm_maskr[0][rawkey0 >> 25]
          | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f]
          | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f]
          | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f]
          | key_perm_maskr[4][rawkey1 >> 25]
          | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
          | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
          | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
       /*
        *     Rotate subkeys and do compression permutation.
        */
       shifts = 0;
       for (round = 0; round < 16; round++) {
              uint32_t      t0, t1;

              shifts += key_shifts[round];

              t0 = (k0 << shifts) | (k0 >> (28 - shifts));
              t1 = (k1 << shifts) | (k1 >> (28 - shifts));

              data->de_keysl[15 - round] =
              data->en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f]
                            | comp_maskl[1][(t0 >> 14) & 0x7f]
                            | comp_maskl[2][(t0 >> 7) & 0x7f]
                            | comp_maskl[3][t0 & 0x7f]
                            | comp_maskl[4][(t1 >> 21) & 0x7f]
                            | comp_maskl[5][(t1 >> 14) & 0x7f]
                            | comp_maskl[6][(t1 >> 7) & 0x7f]
                            | comp_maskl[7][t1 & 0x7f];

              data->de_keysr[15 - round] =
              data->en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f]
                            | comp_maskr[1][(t0 >> 14) & 0x7f]
                            | comp_maskr[2][(t0 >> 7) & 0x7f]
                            | comp_maskr[3][t0 & 0x7f]
                            | comp_maskr[4][(t1 >> 21) & 0x7f]
                            | comp_maskr[5][(t1 >> 14) & 0x7f]
                            | comp_maskr[6][(t1 >> 7) & 0x7f]
                            | comp_maskr[7][t1 & 0x7f];
       }
       return(0);
}

Here is the caller graph for this function:

static int do_des ( uint32_t  l_in,
uint32_t  r_in,
uint32_t l_out,
uint32_t r_out,
int  count,
struct php_crypt_extended_data data 
) [static]

Definition at line 464 of file crypt_freesec.c.

{
       /*
        *     l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
        */
       uint32_t      l, r, *kl, *kr, *kl1, *kr1;
       uint32_t      f, r48l, r48r, saltbits;
       int    round;

       if (count == 0) {
              return(1);
       } else if (count > 0) {
              /*
               * Encrypting
               */
              kl1 = data->en_keysl;
              kr1 = data->en_keysr;
       } else {
              /*
               * Decrypting
               */
              count = -count;
              kl1 = data->de_keysl;
              kr1 = data->de_keysr;
       }

       /*
        *     Do initial permutation (IP).
        */
       l = ip_maskl[0][l_in >> 24]
         | ip_maskl[1][(l_in >> 16) & 0xff]
         | ip_maskl[2][(l_in >> 8) & 0xff]
         | ip_maskl[3][l_in & 0xff]
         | ip_maskl[4][r_in >> 24]
         | ip_maskl[5][(r_in >> 16) & 0xff]
         | ip_maskl[6][(r_in >> 8) & 0xff]
         | ip_maskl[7][r_in & 0xff];
       r = ip_maskr[0][l_in >> 24]
         | ip_maskr[1][(l_in >> 16) & 0xff]
         | ip_maskr[2][(l_in >> 8) & 0xff]
         | ip_maskr[3][l_in & 0xff]
         | ip_maskr[4][r_in >> 24]
         | ip_maskr[5][(r_in >> 16) & 0xff]
         | ip_maskr[6][(r_in >> 8) & 0xff]
         | ip_maskr[7][r_in & 0xff];

       saltbits = data->saltbits;
       while (count--) {
              /*
               * Do each round.
               */
              kl = kl1;
              kr = kr1;
              round = 16;
              while (round--) {
                     /*
                      * Expand R to 48 bits (simulate the E-box).
                      */
                     r48l   = ((r & 0x00000001) << 23)
                            | ((r & 0xf8000000) >> 9)
                            | ((r & 0x1f800000) >> 11)
                            | ((r & 0x01f80000) >> 13)
                            | ((r & 0x001f8000) >> 15);

                     r48r   = ((r & 0x0001f800) << 7)
                            | ((r & 0x00001f80) << 5)
                            | ((r & 0x000001f8) << 3)
                            | ((r & 0x0000001f) << 1)
                            | ((r & 0x80000000) >> 31);
                     /*
                      * Do salting for crypt() and friends, and
                      * XOR with the permuted key.
                      */
                     f = (r48l ^ r48r) & saltbits;
                     r48l ^= f ^ *kl++;
                     r48r ^= f ^ *kr++;
                     /*
                      * Do sbox lookups (which shrink it back to 32 bits)
                      * and do the pbox permutation at the same time.
                      */
                     f = psbox[0][m_sbox[0][r48l >> 12]]
                       | psbox[1][m_sbox[1][r48l & 0xfff]]
                       | psbox[2][m_sbox[2][r48r >> 12]]
                       | psbox[3][m_sbox[3][r48r & 0xfff]];
                     /*
                      * Now that we've permuted things, complete f().
                      */
                     f ^= l;
                     l = r;
                     r = f;
              }
              r = l;
              l = f;
       }
       /*
        * Do final permutation (inverse of IP).
        */
       *l_out = fp_maskl[0][l >> 24]
              | fp_maskl[1][(l >> 16) & 0xff]
              | fp_maskl[2][(l >> 8) & 0xff]
              | fp_maskl[3][l & 0xff]
              | fp_maskl[4][r >> 24]
              | fp_maskl[5][(r >> 16) & 0xff]
              | fp_maskl[6][(r >> 8) & 0xff]
              | fp_maskl[7][r & 0xff];
       *r_out = fp_maskr[0][l >> 24]
              | fp_maskr[1][(l >> 16) & 0xff]
              | fp_maskr[2][(l >> 8) & 0xff]
              | fp_maskr[3][l & 0xff]
              | fp_maskr[4][r >> 24]
              | fp_maskr[5][(r >> 16) & 0xff]
              | fp_maskr[6][(r >> 8) & 0xff]
              | fp_maskr[7][r & 0xff];
       return(0);
}

Here is the caller graph for this function:

static void setup_salt ( uint32_t  salt,
struct php_crypt_extended_data data 
) [static]

Definition at line 357 of file crypt_freesec.c.

{
       uint32_t      obit, saltbit, saltbits;
       int    i;

       if (salt == data->old_salt)
              return;
       data->old_salt = salt;

       saltbits = 0;
       saltbit = 1;
       obit = 0x800000;
       for (i = 0; i < 24; i++) {
              if (salt & saltbit)
                     saltbits |= obit;
              saltbit <<= 1;
              obit >>= 1;
       }
       data->saltbits = saltbits;
}

Here is the caller graph for this function:


Variable Documentation

unsigned char ascii64[] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" [static]

Definition at line 175 of file crypt_freesec.c.

uint32_t bits32[32] [static]
Initial value:
{
       0x80000000, 0x40000000, 0x20000000, 0x10000000,
       0x08000000, 0x04000000, 0x02000000, 0x01000000,
       0x00800000, 0x00400000, 0x00200000, 0x00100000,
       0x00080000, 0x00040000, 0x00020000, 0x00010000,
       0x00008000, 0x00004000, 0x00002000, 0x00001000,
       0x00000800, 0x00000400, 0x00000200, 0x00000100,
       0x00000080, 0x00000040, 0x00000020, 0x00000010,
       0x00000008, 0x00000004, 0x00000002, 0x00000001
}

Definition at line 161 of file crypt_freesec.c.

u_char bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 } [static]

Definition at line 173 of file crypt_freesec.c.

uint32_t comp_maskl[8][128] [static]

Definition at line 185 of file crypt_freesec.c.

uint32_t comp_maskr[8][128] [static]

Definition at line 185 of file crypt_freesec.c.

u_char comp_perm[48] [static]
Initial value:
 {
       14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
       23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
       41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
       44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
}

Definition at line 94 of file crypt_freesec.c.

uint32_t fp_maskl[8][256] [static]

Definition at line 183 of file crypt_freesec.c.

uint32_t fp_maskr[8][256] [static]

Definition at line 183 of file crypt_freesec.c.

u_char IP[64] [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 76 of file crypt_freesec.c.

uint32_t ip_maskl[8][256] [static]

Definition at line 182 of file crypt_freesec.c.

uint32_t ip_maskr[8][256] [static]

Definition at line 182 of file crypt_freesec.c.

u_char key_perm[56] [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 83 of file crypt_freesec.c.

uint32_t key_perm_maskl[8][128] [static]

Definition at line 184 of file crypt_freesec.c.

uint32_t key_perm_maskr[8][128] [static]

Definition at line 184 of file crypt_freesec.c.

u_char key_shifts[16] [static]
Initial value:
 {
       1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
}

Definition at line 90 of file crypt_freesec.c.

u_char m_sbox[4][4096] [static]

Definition at line 180 of file crypt_freesec.c.

u_char pbox[32] [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 156 of file crypt_freesec.c.

uint32_t psbox[4][256] [static]

Definition at line 181 of file crypt_freesec.c.

u_char sbox[8][64] [static]

Definition at line 105 of file crypt_freesec.c.