crypto_serpent_algo.h File Reference

#include <rz_crypto.h>
#include <rz_util.h>

Go to the source code of this file.

Classes
struct	serpent_state

Macros
#define	DW_BY_BLOCK   4
#define	DW_BY_USERKEY   8
#define	NB_ROUNDS   32
#define	NB_SUBKEYS   33
#define	NIBBLES_BY_SUBKEY   32

Typedefs
typedef struct serpent_state	serpent_state_t

Functions
void	serpent_encrypt (serpent_state_t *st, ut32 in[DW_BY_BLOCK], ut32 out[DW_BY_BLOCK])
void	serpent_decrypt (serpent_state_t *st, ut32 in[DW_BY_BLOCK], ut32 out[DW_BY_BLOCK])
void	serpent_keyschedule (const serpent_state_t *st, ut32 subkeys[NB_SUBKEYS *DW_BY_BLOCK])

Macro Definition Documentation

DW_BY_BLOCK

#define DW_BY_BLOCK   4

Definition at line 9 of file crypto_serpent_algo.h.

DW_BY_USERKEY

#define DW_BY_USERKEY   8

Definition at line 10 of file crypto_serpent_algo.h.

NB_ROUNDS

#define NB_ROUNDS   32

Definition at line 11 of file crypto_serpent_algo.h.

NB_SUBKEYS

#define NB_SUBKEYS   33

Definition at line 12 of file crypto_serpent_algo.h.

NIBBLES_BY_SUBKEY

#define NIBBLES_BY_SUBKEY   32

Definition at line 13 of file crypto_serpent_algo.h.

Typedef Documentation

serpent_state_t

typedef struct serpent_state serpent_state_t

Function Documentation

serpent_decrypt()

void serpent_decrypt	(	serpent_state_t *	st,
		ut32	in[DW_BY_BLOCK],
		ut32	out[DW_BY_BLOCK]
	)

Definition at line 235 of file crypto_serpent_algo.c.

                           {
    int i;
    ut32 subkeys[DW_BY_BLOCK * NB_SUBKEYS] = { 0 };
    ut32 tmp_block[DW_BY_BLOCK] = { 0 };
 
    serpent_keyschedule(st, subkeys);
 
    apply_IP(in, tmp_block);
    for (i = NB_ROUNDS - 1; i >= 0; i--) {
        apply_round_inv(i, tmp_block, subkeys);
    }
    apply_FP(tmp_block, out);
}

References apply_FP(), apply_IP(), apply_round_inv(), DW_BY_BLOCK, i, in, NB_ROUNDS, NB_SUBKEYS, out, and serpent_keyschedule().

Referenced by update().

serpent_encrypt()

void serpent_encrypt	(	serpent_state_t *	st,
		ut32	in[DW_BY_BLOCK],
		ut32	out[DW_BY_BLOCK]
	)

Definition at line 220 of file crypto_serpent_algo.c.

                           {
    int i;
    ut32 subkeys[DW_BY_BLOCK * NB_SUBKEYS] = { 0 };
    ut32 tmp_block[DW_BY_BLOCK] = { 0 };
 
    serpent_keyschedule(st, subkeys);
 
    apply_IP(in, tmp_block);
    for (i = 0; i < NB_ROUNDS; i++) {
        apply_round(i, tmp_block, subkeys);
    }
    apply_FP(tmp_block, out);
}

References apply_FP(), apply_IP(), apply_round(), DW_BY_BLOCK, i, in, NB_ROUNDS, NB_SUBKEYS, out, and serpent_keyschedule().

Referenced by update().

serpent_keyschedule()

void serpent_keyschedule	(	const serpent_state_t *	st,
		ut32	subkeys[NB_SUBKEYS *DW_BY_BLOCK]
	)

Definition at line 93 of file crypto_serpent_algo.c.

                                                                                            {
    rz_return_if_fail((st->key_size == 128) || (st->key_size == 192) || (st->key_size == 256));
 
    ut32 tmpkeys[DW_BY_BLOCK * NB_SUBKEYS + DW_BY_USERKEY] = { 0 };
    const ut32 phi = 0x9e3779b9;
    int si;
    ut8 in, out;
    int i, j, l;
 
    for (i = 0; i < st->key_size / 32; i++) {
        tmpkeys[i] = st->key[i];
    }
 
    // Padding key
    if (st->key_size != 256) {
        tmpkeys[st->key_size / 32] = 1;
    }
 
    for (i = DW_BY_USERKEY; i < NB_SUBKEYS * DW_BY_BLOCK + DW_BY_USERKEY; i++) {
        tmpkeys[i] = tmpkeys[i - 8] ^ tmpkeys[i - 5] ^ tmpkeys[i - 3] ^ tmpkeys[i - 1] ^ phi ^ (i - 8);
        rotl(tmpkeys + i, 11);
    }
 
    // Applying sbox for subkey i
    for (i = 0; i < NB_SUBKEYS; i++) {
        si = (32 + 3 - i) % 8;
 
        // Iterates over all nibbles of the subkey i
        for (j = 0; j < NIBBLES_BY_SUBKEY; j++) {
            in = get_bit(j, tmpkeys[0 + DW_BY_BLOCK * i + DW_BY_USERKEY]) | get_bit(j, tmpkeys[1 + DW_BY_BLOCK * i + DW_BY_USERKEY]) << 1 | get_bit(j, tmpkeys[2 + DW_BY_BLOCK * i + DW_BY_USERKEY]) << 2 | get_bit(j, tmpkeys[3 + DW_BY_BLOCK * i + DW_BY_USERKEY]) << 3;
            out = apply_sbox(si, in);
            for (l = 0; l < DW_BY_BLOCK; l++) {
                subkeys[l + DW_BY_BLOCK * i] |= get_bit(l, (ut32)out) << j;
            }
        }
    }
 
    // Apply IP on every subkey
    for (i = 0; i < NB_SUBKEYS; i++) {
        apply_IP(&subkeys[i * DW_BY_BLOCK], &tmpkeys[DW_BY_USERKEY + i * DW_BY_BLOCK]);
    }
 
    memcpy(subkeys, tmpkeys + DW_BY_USERKEY, 132 * sizeof(ut32));
}

References apply_IP(), apply_sbox(), DW_BY_BLOCK, DW_BY_USERKEY, get_bit(), i, in, serpent_state::key, serpent_state::key_size, memcpy(), NB_SUBKEYS, NIBBLES_BY_SUBKEY, out, rotl(), rz_return_if_fail, and si.

Referenced by serpent_decrypt(), and serpent_encrypt().