internal.h File Reference

#include <openssl/base.h>

Go to the source code of this file.

Macros
#define	c2l(c, l)
#define	l2c(l, c)
#define	c2ln(c, l1, l2, n)
#define	l2cn(l1, l2, c, n)
#define	PERM_OP(a, b, t, n, m)
#define	IP(l, r)
#define	FP(l, r)
#define	LOAD_DATA(ks, R, S, u, t, E0, E1)
#define	D_ENCRYPT(ks, LL, R, S)
#define	ITERATIONS   16
#define	HALF_ITERATIONS   8
#define	ROTATE(a, n)   (((a) >> (n)) + ((a) << (32 - (n))))

Macro Definition Documentation

c2l

#define c2l	(		c,
			l
	)

Value:

do {                                    \
    (l) = ((uint32_t)(*((c)++)));         \
    (l) |= ((uint32_t)(*((c)++))) << 8L;  \
    (l) |= ((uint32_t)(*((c)++))) << 16L; \
    (l) |= ((uint32_t)(*((c)++))) << 24L; \
  } while (0)

c2ln

#define c2ln	(		c,
			l1,
			l2,
			n
	)

Value:

do {                                         \
    (c) += (n);                                \
    (l1) = (l2) = 0;                           \
    switch (n) {                               \
      case 8:                                  \
        (l2) = ((uint32_t)(*(--(c)))) << 24L;  \
      case 7:                                  \
        (l2) |= ((uint32_t)(*(--(c)))) << 16L; \
      case 6:                                  \
        (l2) |= ((uint32_t)(*(--(c)))) << 8L;  \
      case 5:                                  \
        (l2) |= ((uint32_t)(*(--(c))));        \
      case 4:                                  \
        (l1) = ((uint32_t)(*(--(c)))) << 24L;  \
      case 3:                                  \
        (l1) |= ((uint32_t)(*(--(c)))) << 16L; \
      case 2:                                  \
        (l1) |= ((uint32_t)(*(--(c)))) << 8L;  \
      case 1:                                  \
        (l1) |= ((uint32_t)(*(--(c))));        \
    }                                          \
  } while (0)

D_ENCRYPT

#define D_ENCRYPT	(		ks,
			LL,
			R,
			S
	)

Value:

do {                                                                         \
    LOAD_DATA(ks, R, S, u, t, E0, E1);                                         \
    t = ROTATE(t, 4);                                                          \
    (LL) ^=                                                                    \
        DES_SPtrans[0][(u >> 2L) & 0x3f] ^ DES_SPtrans[2][(u >> 10L) & 0x3f] ^ \
        DES_SPtrans[4][(u >> 18L) & 0x3f] ^                                    \
        DES_SPtrans[6][(u >> 26L) & 0x3f] ^ DES_SPtrans[1][(t >> 2L) & 0x3f] ^ \
        DES_SPtrans[3][(t >> 10L) & 0x3f] ^                                    \
        DES_SPtrans[5][(t >> 18L) & 0x3f] ^ DES_SPtrans[7][(t >> 26L) & 0x3f]; \
  } while (0)

FP

#define FP	(		l,
			r
	)

Value:

do {                                  \
    uint32_t tt;                        \
    PERM_OP(l, r, tt, 1, 0x55555555L);  \
    PERM_OP(r, l, tt, 8, 0x00ff00ffL);  \
    PERM_OP(l, r, tt, 2, 0x33333333L);  \
    PERM_OP(r, l, tt, 16, 0x0000ffffL); \
    PERM_OP(l, r, tt, 4, 0x0f0f0f0fL);  \
  } while (0)

HALF_ITERATIONS

#define HALF_ITERATIONS   8

IP

#define IP	(		l,
			r
	)

Value:

do {                                  \
    uint32_t tt;                        \
    PERM_OP(r, l, tt, 4, 0x0f0f0f0fL);  \
    PERM_OP(l, r, tt, 16, 0x0000ffffL); \
    PERM_OP(r, l, tt, 2, 0x33333333L);  \
    PERM_OP(l, r, tt, 8, 0x00ff00ffL);  \
    PERM_OP(r, l, tt, 1, 0x55555555L);  \
  } while (0)

ITERATIONS

#define ITERATIONS   16

l2c

#define l2c	(		l,
			c
	)

Value:

do {                                               \
    *((c)++) = (unsigned char)(((l)) & 0xff);        \
    *((c)++) = (unsigned char)(((l) >> 8L) & 0xff);  \
    *((c)++) = (unsigned char)(((l) >> 16L) & 0xff); \
    *((c)++) = (unsigned char)(((l) >> 24L) & 0xff); \
  } while (0)

l2cn

#define l2cn	(		l1,
			l2,
			c,
			n
	)

Value:

do {                                                    \
    (c) += (n);                                           \
    switch (n) {                                          \
      case 8:                                             \
        *(--(c)) = (unsigned char)(((l2) >> 24L) & 0xff); \
      case 7:                                             \
        *(--(c)) = (unsigned char)(((l2) >> 16L) & 0xff); \
      case 6:                                             \
        *(--(c)) = (unsigned char)(((l2) >> 8L) & 0xff);  \
      case 5:                                             \
        *(--(c)) = (unsigned char)(((l2)) & 0xff);        \
      case 4:                                             \
        *(--(c)) = (unsigned char)(((l1) >> 24L) & 0xff); \
      case 3:                                             \
        *(--(c)) = (unsigned char)(((l1) >> 16L) & 0xff); \
      case 2:                                             \
        *(--(c)) = (unsigned char)(((l1) >> 8L) & 0xff);  \
      case 1:                                             \
        *(--(c)) = (unsigned char)(((l1)) & 0xff);        \
    }                                                     \
  } while (0)

LOAD_DATA

#define LOAD_DATA	(		ks,
			R,
			S,
			u,
			t,
			E0,
			E1
	)

Value:

do {                                    \
    (u) = (R) ^ (ks)->subkeys[S][0];      \
    (t) = (R) ^ (ks)->subkeys[S][1];      \
  } while (0)

PERM_OP

#define PERM_OP	(		a,
			b,
			t,
			n,
			m
	)

Value:

do {                                  \
    (t) = ((((a) >> (n)) ^ (b)) & (m)); \
    (b) ^= (t);                         \
    (a) ^= ((t) << (n));                \
  } while (0)

ROTATE

#define ROTATE	(		a,
			n
	)		(((a) >> (n)) + ((a) << (32 - (n))))