crypto_des.c File Reference

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

Go to the source code of this file.

Classes
struct	des_state

Functions
static ut32	be32 (const ut8 *buf4)
static void	wbe32 (ut8 *buf4, ut32 val)
static int	des_encrypt (struct des_state *st, const ut8 *input, ut8 *output)
static int	des_decrypt (struct des_state *st, const ut8 *input, ut8 *output)
static bool	des_set_key (RzCrypto *cry, const ut8 *key, int keylen, int mode, int direction)
static int	des_get_key_size (RzCrypto *cry)
static bool	des_use (const char *algo)
static bool	update (RzCrypto *cry, const ut8 *buf, int len)
static bool	final (RzCrypto *cry, const ut8 *buf, int len)
static bool	des_init (RzCrypto *cry)
static bool	des_fini (RzCrypto *cry)

Variables
RzCryptoPlugin	rz_crypto_plugin_des
RZ_API RzLibStruct	rizin_plugin

Function Documentation

be32()

static ut32 be32 ( const ut8 *  buf4 )

static

Definition at line 18 of file crypto_des.c.

                                  {
    ut32 val = buf4[0] << 8;
    val |= buf4[1];
    val <<= 8;
    val |= buf4[2];
    val <<= 8;
    val |= buf4[3];
    return val;
}

References val.

Referenced by des_decrypt(), des_encrypt(), and des_set_key().

des_decrypt()

static int des_decrypt ( struct des_state *  st, const ut8 *  input, ut8 *  output  )

static

Definition at line 58 of file crypto_des.c.

                                                                            {
    if (!st || !input || !output) {
        return false;
    }
    st->buflo = be32(input + 0);
    st->bufhi = be32(input + 4);
    // first permutation
    rz_des_permute_block0(&st->buflo, &st->bufhi);
 
    for (st->i = 0; st->i < 16; st->i++) {
        rz_des_round(&st->buflo, &st->bufhi, &st->keylo[15 - st->i], &st->keyhi[15 - st->i]);
    }
 
    // last permutation
    rz_des_permute_block1(&st->bufhi, &st->buflo);
    // result
    wbe32(output + 0, st->bufhi);
    wbe32(output + 4, st->buflo);
    return true;
}

References be32(), des_state::bufhi, des_state::buflo, des_state::i, input(), des_state::keyhi, des_state::keylo, output, rz_des_permute_block0(), rz_des_permute_block1(), rz_des_round(), and wbe32().

Referenced by update().

des_encrypt()

static int des_encrypt ( struct des_state *  st, const ut8 *  input, ut8 *  output  )

static

Definition at line 35 of file crypto_des.c.

                                                                            {
    if (!st || !input || !output) {
        return false;
    }
    st->buflo = be32(input + 0);
    st->bufhi = be32(input + 4);
 
    // first permutation
    rz_des_permute_block0(&st->buflo, &st->bufhi);
 
    for (st->i = 0; st->i < 16; st->i++) {
        rz_des_round(&st->buflo, &st->bufhi, &st->keylo[st->i], &st->keyhi[st->i]);
    }
    // last permutation
    rz_des_permute_block1(&st->bufhi, &st->buflo);
 
    // result
    wbe32(output + 0, st->bufhi);
    wbe32(output + 4, st->buflo);
 
    return true;
}

References be32(), des_state::bufhi, des_state::buflo, des_state::i, input(), des_state::keyhi, des_state::keylo, output, rz_des_permute_block0(), rz_des_permute_block1(), rz_des_round(), and wbe32().

Referenced by update().

des_fini()

static bool des_fini ( RzCrypto *  cry )

static

Definition at line 176 of file crypto_des.c.

                                    {
    rz_return_val_if_fail(cry, false);
 
    free(cry->user);
    return true;
}

References free(), rz_return_val_if_fail, and rz_crypto_t::user.

des_get_key_size()

static int des_get_key_size ( RzCrypto *  cry )

static

Definition at line 105 of file crypto_des.c.

                                           {
    rz_return_val_if_fail(cry->user, 0);
    struct des_state *st = (struct des_state *)cry->user;
    return st->key_size;
}

References des_state::key_size, rz_return_val_if_fail, and rz_crypto_t::user.

des_init()

static bool des_init ( RzCrypto *  cry )

static

Definition at line 170 of file crypto_des.c.

                                    {
    rz_return_val_if_fail(cry, false);
    cry->user = RZ_NEW0(struct des_state);
    return cry->user != NULL;
}

References NULL, RZ_NEW0, rz_return_val_if_fail, and rz_crypto_t::user.

des_set_key()

static bool des_set_key ( RzCrypto *  cry, const ut8 *  key, int  keylen, int  mode, int  direction  )

static

Definition at line 79 of file crypto_des.c.

                                                                                            {
    rz_return_val_if_fail(cry->user && key, 0);
    struct des_state *st = (struct des_state *)cry->user;
 
    ut32 keylo, keyhi, i;
    if (keylen != DES_KEY_SIZE) {
        return false;
    }
    // splitting the key in hi & lo
    keylo = be32(key);
    keyhi = be32(key + 4);
 
    st->key_size = DES_KEY_SIZE;
    st->rounds = 16;
    cry->dir = direction;
    // key permutation to derive round keys
    rz_des_permute_key(&keylo, &keyhi);
 
    for (i = 0; i < 16; i++) {
        // filling round keys space
        rz_des_round_key(i, &st->keylo[i], &st->keyhi[i], &keylo, &keyhi);
    }
 
    return true;
}

References be32(), DES_KEY_SIZE, rz_crypto_t::dir, i, if(), key, des_state::key_size, des_state::keyhi, des_state::keylo, des_state::rounds, rz_des_permute_key(), rz_des_round_key(), rz_return_val_if_fail, and rz_crypto_t::user.

des_use()

static bool des_use ( const char *  algo )

static

Definition at line 111 of file crypto_des.c.

                                      {
    return algo && !strcmp(algo, "des-ecb");
}

final()

static bool final ( RzCrypto *  cry, const ut8 *  buf, int  len  )

static

Definition at line 166 of file crypto_des.c.

                                                          {
    return update(cry, buf, len);
}

References len, and update().

update()

static bool update ( RzCrypto *  cry, const ut8 *  buf, int  len  )

static

Definition at line 115 of file crypto_des.c.

                                                           {
    rz_return_val_if_fail(cry->user, false);
    struct des_state *st = (struct des_state *)cry->user;
 
    if (len <= 0) {
        return false;
    }
 
    // Pad to the block size, do not append dummy block
    const int diff = (DES_BLOCK_SIZE - (len % DES_BLOCK_SIZE)) % DES_BLOCK_SIZE;
    const int size = len + diff;
    const int blocks = size / DES_BLOCK_SIZE;
 
    ut8 *const obuf = calloc(1, size);
    if (!obuf) {
        return false;
    }
 
    ut8 *const ibuf = calloc(1, size);
    if (!ibuf) {
        free(obuf);
        return false;
    }
 
    memset(ibuf + len, 0, (size - len));
    memcpy(ibuf, buf, len);
    // got it from AES, should be changed??
    // Padding should start like 100000...
    //  if (diff) {
    //      ibuf[len] = 8; //0b1000;
    //  }
 
    int i;
    if (cry->dir == RZ_CRYPTO_DIR_DECRYPT) {
        for (i = 0; i < blocks; i++) {
            ut32 next = (DES_BLOCK_SIZE * i);
            des_decrypt(st, ibuf + next, obuf + next);
        }
    } else {
        for (i = 0; i < blocks; i++) {
            ut32 next = (DES_BLOCK_SIZE * i);
            des_encrypt(st, ibuf + next, obuf + next);
        }
    }
 
    rz_crypto_append(cry, obuf, size);
    free(obuf);
    free(ibuf);
    return 0;
}

References blocks, calloc(), DES_BLOCK_SIZE, des_decrypt(), des_encrypt(), rz_crypto_t::dir, free(), i, if(), len, memcpy(), memset(), obuf, rz_crypto_append(), RZ_CRYPTO_DIR_DECRYPT, rz_return_val_if_fail, and rz_crypto_t::user.

Referenced by final().

wbe32()

static void wbe32 ( ut8 *  buf4, ut32  val  )

static

Definition at line 28 of file crypto_des.c.

                                       {
    buf4[0] = (val >> 24);
    buf4[1] = (val >> 16) & 0xFF;
    buf4[2] = (val >> 8) & 0xFF;
    buf4[3] = val & 0xFF;
}

References val.

Referenced by des_decrypt(), and des_encrypt().

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_CRYPTO,
    .data = &rz_crypto_plugin_des,
    .version = RZ_VERSION
}

Definition at line 197 of file crypto_des.c.

rz_crypto_plugin_des

RzCryptoPlugin rz_crypto_plugin_des

Initial value:

= {
    .name = "des-ecb",
    .author = "deroad",
    .license = "LGPL-3",
    .set_key = des_set_key,
    .get_key_size = des_get_key_size,
    .use = des_use,
    .update = update,
    .final = final,
    .init = des_init,
    .fini = des_fini,
}

Definition at line 183 of file crypto_des.c.