crypto_blowfish.c File Reference

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

Go to the source code of this file.

Classes
struct	blowfish_state

Macros
#define	BLOCK_SIZE   8

Functions
static void	swap (ut32 *left, ut32 *right)
static ut32	F (struct blowfish_state *const state, const ut32 inbuf)
static void	blowfish_crypt (struct blowfish_state *const state, const ut8 *inbuf, ut8 *outbuf, int buflen)
static void	blowfish_decrypt (struct blowfish_state *const state, const ut8 *inbuf, ut8 *outbuf, int buflen)
static bool	blowfish_init_state (struct blowfish_state *const state, const ut8 *key, int keylen)
static bool	blowfish_set_key (RzCrypto *cry, const ut8 *key, int keylen, int mode, int direction)
static int	blowfish_get_key_size (RzCrypto *cry)
static bool	blowfish_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	blowfish_init (RzCrypto *cry)
static bool	blowfish_fini (RzCrypto *cry)

Variables
static const ut32	p [18]
static const ut32	s [4][256]
RzCryptoPlugin	rz_crypto_plugin_blowfish
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

BLOCK_SIZE

#define BLOCK_SIZE   8

Definition at line 14 of file crypto_blowfish.c.

Function Documentation

blowfish_crypt()

static void blowfish_crypt ( struct blowfish_state *const  state, const ut8 *  inbuf, ut8 *  outbuf, int  buflen  )

static

Definition at line 176 of file crypto_blowfish.c.

                                                                                                          {
    ut32 left, right;
    int index1, index2;
 
    if (!state || !inbuf || !outbuf || buflen < 0 || buflen % 8 != 0) {
        // let user deal with padding
        if (buflen % 8 != 0) {
            eprintf("Invalid input length %d. Expected length is multiple of 8 bytes.\n", buflen);
        }
        return;
    }
 
    for (index1 = 0; index1 < buflen; index1 += 8) {
        left = (inbuf[index1 + 0] << 24 | inbuf[index1 + 1] << 16 | inbuf[index1 + 2] << 8 | inbuf[index1 + 3]);
        right = (inbuf[index1 + 4] << 24 | inbuf[index1 + 5] << 16 | inbuf[index1 + 6] << 8 | inbuf[index1 + 7]);
 
        for (index2 = 0; index2 < 16; index2 += 1) {
            left ^= state->p[index2];
            right ^= F(state, left);
            swap(&left, &right);
        }
        /* Undo the last swap. */
        swap(&left, &right);
        right ^= state->p[16];
        left ^= state->p[17];
 
        outbuf[index1 + 0] = left >> 24;
        outbuf[index1 + 1] = left >> 16;
        outbuf[index1 + 2] = left >> 8;
        outbuf[index1 + 3] = left;
        outbuf[index1 + 4] = right >> 24;
        outbuf[index1 + 5] = right >> 16;
        outbuf[index1 + 6] = right >> 8;
        outbuf[index1 + 7] = right;
    }
}

References buflen, eprintf, F(), inbuf, outbuf, and swap().

Referenced by blowfish_init_state(), and update().

blowfish_decrypt()

static void blowfish_decrypt ( struct blowfish_state *const  state, const ut8 *  inbuf, ut8 *  outbuf, int  buflen  )

static

Definition at line 213 of file crypto_blowfish.c.

                                                                                                            {
    ut32 left, right;
    int index1, index2;
 
    if (!state || !inbuf || !outbuf || buflen < 0 || buflen % 8 != 0) {
        // length of encrypted output of blowfish is multiple of 8 bytes.
        if ((buflen % 8) != 0) {
            eprintf("Invalid input length %d. Expected length is multiple of 8 bytes.\n", buflen);
        }
        return;
    }
 
    for (index1 = 0; index1 < buflen; index1 += 8) {
        left = (inbuf[index1 + 0] << 24 | inbuf[index1 + 1] << 16 | inbuf[index1 + 2] << 8 | inbuf[index1 + 3]);
        right = (inbuf[index1 + 4] << 24 | inbuf[index1 + 5] << 16 | inbuf[index1 + 6] << 8 | inbuf[index1 + 7]);
 
        for (index2 = 17; index2 > 1; index2 -= 1) {
            left ^= state->p[index2];
            right ^= F(state, left);
            swap(&left, &right);
        }
        /* Undo the last swap. */
        swap(&left, &right);
        right ^= state->p[1];
        left ^= state->p[0];
 
        outbuf[index1 + 0] = left >> 24;
        outbuf[index1 + 1] = left >> 16;
        outbuf[index1 + 2] = left >> 8;
        outbuf[index1 + 3] = left;
        outbuf[index1 + 4] = right >> 24;
        outbuf[index1 + 5] = right >> 16;
        outbuf[index1 + 6] = right >> 8;
        outbuf[index1 + 7] = right;
    }
}

References buflen, eprintf, F(), inbuf, outbuf, and swap().

Referenced by update().

blowfish_fini()

static bool blowfish_fini ( RzCrypto *  cry )

static

Definition at line 341 of file crypto_blowfish.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.

blowfish_get_key_size()

static int blowfish_get_key_size ( RzCrypto *  cry )

static

Definition at line 298 of file crypto_blowfish.c.

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

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

blowfish_init()

static bool blowfish_init ( RzCrypto *  cry )

static

Definition at line 334 of file crypto_blowfish.c.

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

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

blowfish_init_state()

static bool blowfish_init_state ( struct blowfish_state *const  state, const ut8 *  key, int  keylen  )

static

Definition at line 250 of file crypto_blowfish.c.

                                                                                                {
    if (!state || !key || keylen > 56) {
        return false;
    }
 
    ut8 block[8];
    int index1, index2;
 
    memset(block, 0, 8);
    memcpy(state->p, p, sizeof(ut32) * 18);
    memcpy(state->s, s, sizeof(ut32) * 1024);
 
    state->key_size = keylen;
 
    /* Subkeys are calculated in terms of user key.
     * P0 is XORed with first 32 bits of key, P1 with next 32 bits, and so on.
     * Key bits are reused when length is exceeded.
     * */
    for (index1 = 0, index2 = 0; index1 < 18; index1 += 1, index2 += 4) {
        state->p[index1] ^= ((key[index2 % keylen] << 24) | (key[(index2 + 1) % keylen] << 16) | (key[(index2 + 2) % keylen] << 8) | (key[(index2 + 3) % keylen]));
    }
 
    /* Recalculating P-boxes */
    for (index1 = 0; index1 < 18; index1 += 2) {
        blowfish_crypt(state, block, block, 8);
        state->p[index1] = (block[0] << 24 | block[1] << 16 | block[2] << 8 | block[3]);
        state->p[index1 + 1] = (block[4] << 24 | block[5] << 16 | block[6] << 8 | block[7]);
    }
 
    /* Recalculating S-boxes */
    for (index1 = 0; index1 < 4; index1 += 1) {
        for (index2 = 0; index2 < 256; index2 += 2) {
            blowfish_crypt(state, block, block, 8);
            state->s[index1][index2] = (block[0] << 24 | block[1] << 16 | block[2] << 8 | block[3]);
            state->s[index1][index2 + 1] = (block[4] << 24 | block[5] << 16 | block[6] << 8 | block[7]);
        }
    }
    return true;
}

References blowfish_crypt(), key, memcpy(), memset(), p, and s.

Referenced by blowfish_set_key().

blowfish_set_key()

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

static

Definition at line 290 of file crypto_blowfish.c.

                                                                                                 {
    rz_return_val_if_fail(cry->user && key, false);
    struct blowfish_state *st = (struct blowfish_state *)cry->user;
 
    cry->dir = direction;
    return blowfish_init_state(st, key, keylen);
}

References blowfish_init_state(), rz_crypto_t::dir, key, rz_return_val_if_fail, and rz_crypto_t::user.

blowfish_use()

static bool blowfish_use ( const char *  algo )

static

Definition at line 305 of file crypto_blowfish.c.

                                           {
    return !strcmp(algo, "blowfish");
}

F()

static ut32 F ( struct blowfish_state *const  state, const ut32  inbuf  )

static

Definition at line 168 of file crypto_blowfish.c.

                                                                    {
    ut8 a = (inbuf >> 24) & 0xff;
    ut8 b = (inbuf >> 16) & 0xff;
    ut8 c = (inbuf >> 8) & 0xff;
    ut8 d = (inbuf)&0xff;
    return ((state->s[0][a] + state->s[1][b]) ^ state->s[2][c]) + state->s[3][d];
}

References a, b, c, d, and inbuf.

Referenced by blowfish_crypt(), and blowfish_decrypt().

final()

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

static

Definition at line 330 of file crypto_blowfish.c.

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

References len, and update().

swap()

static void swap ( ut32 *  left, ut32 *  right  )

static

Definition at line 160 of file crypto_blowfish.c.

                                          {
    ut32 temp;
 
    temp = *right;
    *right = *left;
    *left = temp;
}

Referenced by blowfish_crypt(), and blowfish_decrypt().

update()

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

static

Definition at line 309 of file crypto_blowfish.c.

                                                           {
    rz_return_val_if_fail(cry->user, false);
    struct blowfish_state *st = (struct blowfish_state *)cry->user;
 
    if (!buf || len < 1) {
        return false;
    }
    ut8 *obuf = calloc(1, len);
    if (!obuf) {
        return false;
    }
    if (cry->dir == RZ_CRYPTO_DIR_ENCRYPT) {
        blowfish_crypt(st, buf, obuf, len);
    } else {
        blowfish_decrypt(st, buf, obuf, len);
    }
    rz_crypto_append(cry, obuf, len);
    free(obuf);
    return true;
}

References blowfish_crypt(), blowfish_decrypt(), calloc(), rz_crypto_t::dir, free(), if(), len, obuf, rz_crypto_append(), RZ_CRYPTO_DIR_ENCRYPT, rz_return_val_if_fail, and rz_crypto_t::user.

Referenced by final().

Variable Documentation

p

const ut32 p[18]

static

Initial value:

= {
    0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0, 0x082EFA98,
    0xEC4E6C89, 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C, 0xC0AC29B7, 0xC97C50DD,
    0x3F84D5B5, 0xB5470917, 0x9216D5D9, 0x8979FB1B
}

Definition at line 16 of file crypto_blowfish.c.

Referenced by blowfish_init_state().

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

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

Definition at line 362 of file crypto_blowfish.c.

rz_crypto_plugin_blowfish

RzCryptoPlugin rz_crypto_plugin_blowfish

Initial value:

= {
    .name = "blowfish",
    .license = "LGPL3",
    .author = "kishorbhat",
    .set_key = blowfish_set_key,
    .get_key_size = blowfish_get_key_size,
    .use = blowfish_use,
    .update = update,
    .final = final,
    .init = blowfish_init,
    .fini = blowfish_fini,
}

Definition at line 348 of file crypto_blowfish.c.

s

const ut32 s[4][256]

static

Definition at line 22 of file crypto_blowfish.c.

Referenced by blowfish_init_state().