crypto_cps2.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	sbox
struct	optimised_sbox

Macros
#define	UPPER_LIMIT   0x400000
#define	BIT(x, n)   (((x) >> (n)) & 1)
#define	BITSWAP8(val, B7, B6, B5, B4, B3, B2, B1, B0)

Functions
static ut8	fn (ut8 in, const struct optimised_sbox *sboxes, ut32 key)
static void	expand_1st_key (ut32 *dstkey, const ut32 *srckey)
static void	expand_2nd_key (ut32 *dstkey, const ut32 *srckey)
static void	expand_subkey (ut32 *subkey, ut16 seed)
static ut16	feistel (ut16 val, const int *bitsA, const int *bitsB, const struct optimised_sbox *boxes1, const struct optimised_sbox *boxes2, const struct optimised_sbox *boxes3, const struct optimised_sbox *boxes4, ut32 key1, ut32 key2, ut32 key3, ut32 key4)
static int	extract_inputs (ut32 val, const int *inputs)
static void	optimise_sboxes (struct optimised_sbox *out, const struct sbox *in)
static void	cps2_crypt (int dir, const ut16 *rom, ut16 *dec, int length, const ut32 *master_key, ut32 upper_limit)
static bool	set_key (RzCrypto *cry, const ut8 *key, int keylen, int mode, int direction)
static int	get_key_size (RzCrypto *cry)
static bool	cps2_use (const char *algo)
static bool	update (RzCrypto *cry, const ut8 *buf, int len)
static bool	cps2_init (RzCrypto *cry)
static bool	cps2_fini (RzCrypto *cry)

Variables
static const int	fn1_groupA [8] = { 10, 4, 6, 7, 2, 13, 15, 14 }
static const int	fn1_groupB [8] = { 0, 1, 3, 5, 8, 9, 11, 12 }
static const int	fn2_groupA [8] = { 6, 0, 2, 13, 1, 4, 14, 7 }
static const int	fn2_groupB [8] = { 3, 5, 9, 10, 8, 15, 12, 11 }
static const struct sbox	fn1_r1_boxes [4]
static const struct sbox	fn1_rz_boxes [4]
static const struct sbox	fn1_r3_boxes [4]
static const struct sbox	fn1_r4_boxes [4]
static const struct sbox	fn2_r1_boxes [4]
static const struct sbox	fn2_rz_boxes [4]
static const struct sbox	fn2_r3_boxes [4]
static const struct sbox	fn2_r4_boxes [4]
RzCryptoPlugin	rz_crypto_plugin_cps2
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

BIT

#define BIT	(		x,
			n
	)		(((x) >> (n)) & 1)

Definition at line 9 of file crypto_cps2.c.

BITSWAP8

#define BITSWAP8	(		val,
			B7,
			B6,
			B5,
			B4,
			B3,
			B2,
			B1,
			B0
	)

Value:

    ((BIT(val, B7) << 7) | (BIT(val, B6) << 6) | (BIT(val, B5) << 5) | (BIT(val, B4) << 4) | \
        (BIT(val, B3) << 3) | (BIT(val, B2) << 2) | (BIT(val, B1) << 1) | (BIT(val, B0) << 0))

Definition at line 11 of file crypto_cps2.c.

UPPER_LIMIT

#define UPPER_LIMIT   0x400000

Definition at line 7 of file crypto_cps2.c.

Function Documentation

cps2_crypt()

static void cps2_crypt ( int  dir, const ut16 *  rom, ut16 *  dec, int  length, const ut32 *  master_key, ut32  upper_limit  )

static

Definition at line 2777 of file crypto_cps2.c.

                                                                                                                  {
    int i;
    ut32 key1[4];
    struct optimised_sbox sboxes1[4 * 4];
    struct optimised_sbox sboxes2[4 * 4];
 
    optimise_sboxes(&sboxes1[0 * 4], fn1_r1_boxes);
    optimise_sboxes(&sboxes1[1 * 4], fn1_rz_boxes);
    optimise_sboxes(&sboxes1[2 * 4], fn1_r3_boxes);
    optimise_sboxes(&sboxes1[3 * 4], fn1_r4_boxes);
    optimise_sboxes(&sboxes2[0 * 4], fn2_r1_boxes);
    optimise_sboxes(&sboxes2[1 * 4], fn2_rz_boxes);
    optimise_sboxes(&sboxes2[2 * 4], fn2_r3_boxes);
    optimise_sboxes(&sboxes2[3 * 4], fn2_r4_boxes);
 
    // expand master key to 1st FN 96-bit key
    expand_1st_key(key1, master_key);
 
    // add extra bits for s-boxes with less than 6 inputs
    key1[0] ^= BIT(key1[0], 1) << 4;
    key1[0] ^= BIT(key1[0], 2) << 5;
    key1[0] ^= BIT(key1[0], 8) << 11;
    key1[1] ^= BIT(key1[1], 0) << 5;
    key1[1] ^= BIT(key1[1], 8) << 11;
    key1[2] ^= BIT(key1[2], 1) << 5;
    key1[2] ^= BIT(key1[2], 8) << 11;
 
    for (i = 0; i < 0x10000; i++) {
        int a;
        ut16 seed;
        ut32 subkey[2];
        ut32 key2[4];
 
        if ((i & 0xff) == 0) {
            eprintf("Crypting %d%%\r", i * 100 / 0x10000);
        }
 
        // pass the address through FN1
        seed = feistel(i, fn1_groupA, fn1_groupB,
            &sboxes1[0 * 4], &sboxes1[1 * 4], &sboxes1[2 * 4], &sboxes1[3 * 4],
            key1[0], key1[1], key1[2], key1[3]);
 
        // expand the result to 64-bit
        expand_subkey(subkey, seed);
 
        // XOR with the master key
        subkey[0] ^= master_key[0];
        subkey[1] ^= master_key[1];
 
        // expand key to 2nd FN 96-bit key
        expand_2nd_key(key2, subkey);
 
        // add extra bits for s-boxes with less than 6 inputs
        key2[0] ^= BIT(key2[0], 0) << 5;
        key2[0] ^= BIT(key2[0], 6) << 11;
        key2[1] ^= BIT(key2[1], 0) << 5;
        key2[1] ^= BIT(key2[1], 1) << 4;
        key2[2] ^= BIT(key2[2], 2) << 5;
        key2[2] ^= BIT(key2[2], 3) << 4;
        key2[2] ^= BIT(key2[2], 7) << 11;
        key2[3] ^= BIT(key2[3], 1) << 5;
 
        // de/en-crypt the opcodes
        for (a = i; a < length && a < upper_limit / 2; a += 0x10000) {
            if (dir) {
                /* decrypt */
                dec[a] = feistel(rom[a], fn2_groupA, fn2_groupB,
                    &sboxes2[0 * 4], &sboxes2[1 * 4], &sboxes2[2 * 4], &sboxes2[3 * 4],
                    key2[0], key2[1], key2[2], key2[3]);
                dec[a] = (dec[a] << 8) | (dec[a] >> 8);
            } else {
                /* encrypt */
                dec[a] = (rom[a] << 8) | (rom[a] >> 8);
                dec[a] = feistel(dec[a], fn2_groupA, fn2_groupB,
                    &sboxes2[3 * 4], &sboxes2[2 * 4], &sboxes2[1 * 4], &sboxes2[0 * 4],
                    key2[3], key2[2], key2[1], key2[0]);
            }
        }
        // copy the unencrypted part
        while (a < length) {
            dec[a] = (rom[a] << 8) | (rom[a] >> 8);
            a += 0x10000;
        }
    }
}

References a, BIT, eprintf, expand_1st_key(), expand_2nd_key(), expand_subkey(), feistel(), fn1_groupA, fn1_groupB, fn1_r1_boxes, fn1_r3_boxes, fn1_r4_boxes, fn1_rz_boxes, fn2_groupA, fn2_groupB, fn2_r1_boxes, fn2_r3_boxes, fn2_r4_boxes, fn2_rz_boxes, i, length, and optimise_sboxes().

Referenced by update().

cps2_fini()

static bool cps2_fini ( RzCrypto *  cry )

static

Definition at line 2947 of file crypto_cps2.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.

cps2_init()

static bool cps2_init ( RzCrypto *  cry )

static

Definition at line 2940 of file crypto_cps2.c.

                                     {
    rz_return_val_if_fail(cry, false);
 
    cry->user = RZ_NEWS0(ut32, 2);
    return cry->user != NULL;
}

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

cps2_use()

static bool cps2_use ( const char *  algo )

static

Definition at line 2908 of file crypto_cps2.c.

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

expand_1st_key()

static void expand_1st_key ( ut32 *  dstkey, const ut32 *  srckey  )

static

Definition at line 2410 of file crypto_cps2.c.

                                                             {
    static const int bits[96] = {
        33,
        58,
        49,
        36,
        0,
        31,
        22,
        30,
        3,
        16,
        5,
        53,
        10,
        41,
        23,
        19,
        27,
        39,
        43,
        6,
        34,
        12,
        61,
        21,
        48,
        13,
        32,
        35,
        6,
        42,
        43,
        14,
        21,
        41,
        52,
        25,
        18,
        47,
        46,
        37,
        57,
        53,
        20,
        8,
        55,
        54,
        59,
        60,
        27,
        33,
        35,
        18,
        8,
        15,
        63,
        1,
        50,
        44,
        16,
        46,
        5,
        4,
        45,
        51,
        38,
        25,
        13,
        11,
        62,
        29,
        48,
        2,
        59,
        61,
        62,
        56,
        51,
        57,
        54,
        9,
        24,
        63,
        22,
        7,
        26,
        42,
        45,
        40,
        23,
        14,
        2,
        31,
        52,
        28,
        44,
        17,
    };
    int i;
 
    dstkey[0] = 0;
    dstkey[1] = 0;
    dstkey[2] = 0;
    dstkey[3] = 0;
 
    for (i = 0; i < 96; i++) {
        dstkey[i / 24] |= BIT(srckey[bits[i] / 32], bits[i] % 32) << (i % 24);
    }
}

References BIT, bits(), and i.

Referenced by cps2_crypt().

expand_2nd_key()

static void expand_2nd_key ( ut32 *  dstkey, const ut32 *  srckey  )

static

Definition at line 2523 of file crypto_cps2.c.

                                                             {
    static const int bits[96] = {
        34,
        9,
        32,
        24,
        44,
        54,
        38,
        61,
        47,
        13,
        28,
        7,
        29,
        58,
        18,
        1,
        20,
        60,
        15,
        6,
        11,
        43,
        39,
        19,
        63,
        23,
        16,
        62,
        54,
        40,
        31,
        3,
        56,
        61,
        17,
        25,
        47,
        38,
        55,
        57,
        5,
        4,
        15,
        42,
        22,
        7,
        2,
        19,
        46,
        37,
        29,
        39,
        12,
        30,
        49,
        57,
        31,
        41,
        26,
        27,
        24,
        36,
        11,
        63,
        33,
        16,
        56,
        62,
        48,
        60,
        59,
        32,
        12,
        30,
        53,
        48,
        10,
        0,
        50,
        35,
        3,
        59,
        14,
        49,
        51,
        45,
        44,
        2,
        21,
        33,
        55,
        52,
        23,
        28,
        8,
        26,
    };
    int i;
 
    dstkey[0] = 0;
    dstkey[1] = 0;
    dstkey[2] = 0;
    dstkey[3] = 0;
 
    for (i = 0; i < 96; i++) {
        dstkey[i / 24] |= BIT(srckey[bits[i] / 32], bits[i] % 32) << (i % 24);
    }
}

References BIT, bits(), and i.

Referenced by cps2_crypt().

expand_subkey()

static void expand_subkey ( ut32 *  subkey, ut16  seed  )

static

Definition at line 2637 of file crypto_cps2.c.

                                                   {
    // Note that each row of the table is a permutation of the seed bits.
    static const int bits[64] = {
        5,
        10,
        14,
        9,
        4,
        0,
        15,
        6,
        1,
        8,
        3,
        2,
        12,
        7,
        13,
        11,
        5,
        12,
        7,
        2,
        13,
        11,
        9,
        14,
        4,
        1,
        6,
        10,
        8,
        0,
        15,
        3,
        4,
        10,
        2,
        0,
        6,
        9,
        12,
        1,
        11,
        7,
        15,
        8,
        13,
        5,
        14,
        3,
        14,
        11,
        12,
        7,
        4,
        5,
        2,
        10,
        1,
        15,
        0,
        9,
        8,
        6,
        13,
        3,
    };
    int i;
 
    subkey[0] = 0;
    subkey[1] = 0;
 
    for (i = 0; i < 64; i++) {
        subkey[i / 32] |= BIT(seed, bits[i]) << (i % 32);
    }
}

References BIT, bits(), and i.

Referenced by cps2_crypt().

extract_inputs()

static int extract_inputs ( ut32  val, const int *  inputs  )

static

Definition at line 2745 of file crypto_cps2.c.

                                                       {
    int i, res = 0;
    for (i = 0; i < 6; i++) {
        if (inputs[i] != -1) {
            res |= BIT(val, inputs[i]) << i;
        }
    }
    return res;
}

References BIT, i, and val.

Referenced by optimise_sboxes().

feistel()

static ut16 feistel ( ut16  val, const int *  bitsA, const int *  bitsB, const struct optimised_sbox *  boxes1, const struct optimised_sbox *  boxes2, const struct optimised_sbox *  boxes3, const struct optimised_sbox *  boxes4, ut32  key1, ut32  key2, ut32  key3, ut32  key4  )

inlinestatic

Definition at line 2715 of file crypto_cps2.c.

                                                {
    ut8 l = BITSWAP8(val, bitsB[7], bitsB[6], bitsB[5], bitsB[4], bitsB[3], bitsB[2], bitsB[1], bitsB[0]);
    ut8 r = BITSWAP8(val, bitsA[7], bitsA[6], bitsA[5], bitsA[4], bitsA[3], bitsA[2], bitsA[1], bitsA[0]);
 
    l ^= fn(r, boxes1, key1);
    r ^= fn(l, boxes2, key2);
    l ^= fn(r, boxes3, key3);
    r ^= fn(l, boxes4, key4);
 
    return (BIT(l, 0) << bitsA[0]) |
        (BIT(l, 1) << bitsA[1]) |
        (BIT(l, 2) << bitsA[2]) |
        (BIT(l, 3) << bitsA[3]) |
        (BIT(l, 4) << bitsA[4]) |
        (BIT(l, 5) << bitsA[5]) |
        (BIT(l, 6) << bitsA[6]) |
        (BIT(l, 7) << bitsA[7]) |
        (BIT(r, 0) << bitsB[0]) |
        (BIT(r, 1) << bitsB[1]) |
        (BIT(r, 2) << bitsB[2]) |
        (BIT(r, 3) << bitsB[3]) |
        (BIT(r, 4) << bitsB[4]) |
        (BIT(r, 5) << bitsB[5]) |
        (BIT(r, 6) << bitsB[6]) |
        (BIT(r, 7) << bitsB[7]);
}

References BIT, BITSWAP8, fn(), r, and val.

Referenced by cps2_crypt().

fn()

static ut8 fn ( ut8  in, const struct optimised_sbox *  sboxes, ut32  key  )

static

Definition at line 2396 of file crypto_cps2.c.

                                                                     {
    const struct optimised_sbox *sbox1 = &sboxes[0];
    const struct optimised_sbox *sbox2 = &sboxes[1];
    const struct optimised_sbox *sbox3 = &sboxes[2];
    const struct optimised_sbox *sbox4 = &sboxes[3];
 
    return sbox1->output[sbox1->input_lookup[in] ^ ((key >> 0) & 0x3f)] |
        sbox2->output[sbox2->input_lookup[in] ^ ((key >> 6) & 0x3f)] |
        sbox3->output[sbox3->input_lookup[in] ^ ((key >> 12) & 0x3f)] |
        sbox4->output[sbox4->input_lookup[in] ^ ((key >> 18) & 0x3f)];
}

References in, key, sbox1, sbox2, sbox3, and sbox4.

Referenced by feistel().

get_key_size()

static int get_key_size ( RzCrypto *  cry )

static

Definition at line 2903 of file crypto_cps2.c.

                                       {
    /* 64bit key */
    return 8;
}

optimise_sboxes()

static void optimise_sboxes ( struct optimised_sbox *  out, const struct sbox *  in  )

static

Definition at line 2755 of file crypto_cps2.c.

                                                                               {
    int i, box;
 
    for (box = 0; box < 4; box++) {
        // precalculate the input lookup
        for (i = 0; i < 256; i++) {
            out[box].input_lookup[i] = extract_inputs(i, in[box].inputs);
        }
        // precalculate the output masks
        for (i = 0; i < 64; i++) {
            int o = in[box].table[i];
            out[box].output[i] = 0;
            if (o & 1) {
                out[box].output[i] |= 1 << in[box].outputs[0];
            }
            if (o & 2) {
                out[box].output[i] |= 1 << in[box].outputs[1];
            }
        }
    }
}

References extract_inputs(), i, in, and out.

Referenced by cps2_crypt().

set_key()

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

static

Definition at line 2888 of file crypto_cps2.c.

                                                                                        {
    rz_return_val_if_fail(cry->user && key, false);
    ut32 *cps2key = (ut32 *)cry->user;
 
    cry->dir = direction;
    if (keylen == 8) {
        /* fix key endianness */
        const ut32 *key32 = (const ut32 *)key;
        cps2key[0] = rz_read_be32(key32);
        cps2key[1] = rz_read_be32(key32 + 1);
        return true;
    }
    return false;
}

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

update()

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

static

Definition at line 2912 of file crypto_cps2.c.

                                                           {
    rz_return_val_if_fail(cry->user && len > 0, false);
    ut32 *cps2key = (ut32 *)cry->user;
 
    size_t slen = len / 2;
    ut16 *output = RZ_NEWS0(ut16, slen);
    if (!output) {
        return false;
    }
    ut16 *input = RZ_NEWS0(ut16, slen);
    if (!input) {
        free(output);
        return false;
    }
    for (size_t i = 0; i < slen; i++) {
        input[i] = rz_read_at_le16(buf, i * 2);
    }
    /* TODO : control decryption errors */
    cps2_crypt(cry->dir, input, output, slen, cps2key, UPPER_LIMIT);
    for (size_t i = 0; i < slen; i++) {
        rz_write_at_le16((ut8 *)output, output[i], i * 2);
    }
    rz_crypto_append(cry, (const ut8 *)output, slen * 2);
    free(output);
    free(input);
    return true;
}

References cps2_crypt(), rz_crypto_t::dir, free(), i, input(), len, output, rz_crypto_append(), RZ_NEWS0, rz_read_at_le16(), rz_return_val_if_fail, rz_write_at_le16(), UPPER_LIMIT, and rz_crypto_t::user.

Variable Documentation

fn1_groupA

const int fn1_groupA[8] = { 10, 4, 6, 7, 2, 13, 15, 14 }

static

Definition at line 134 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn1_groupB

const int fn1_groupB[8] = { 0, 1, 3, 5, 8, 9, 11, 12 }

static

Definition at line 135 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn1_r1_boxes

const struct sbox fn1_r1_boxes[4]

static

Definition at line 138 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn1_r3_boxes

const struct sbox fn1_r3_boxes[4]

static

Definition at line 138 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn1_r4_boxes

const struct sbox fn1_r4_boxes[4]

static

Definition at line 138 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn1_rz_boxes

const struct sbox fn1_rz_boxes[4]

static

Definition at line 138 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn2_groupA

const int fn2_groupA[8] = { 6, 0, 2, 13, 1, 4, 14, 7 }

static

Definition at line 137 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn2_groupB

const int fn2_groupB[8] = { 3, 5, 9, 10, 8, 15, 12, 11 }

static

Definition at line 138 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn2_r1_boxes

const struct sbox fn2_r1_boxes[4]

static

Definition at line 138 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn2_r3_boxes

const struct sbox fn2_r3_boxes[4]

static

Definition at line 138 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn2_r4_boxes

const struct sbox fn2_r4_boxes[4]

static

Definition at line 138 of file crypto_cps2.c.

Referenced by cps2_crypt().

fn2_rz_boxes

const struct sbox fn2_rz_boxes[4]

static

Definition at line 138 of file crypto_cps2.c.

Referenced by cps2_crypt().

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

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

Definition at line 2967 of file crypto_cps2.c.

rz_crypto_plugin_cps2

RzCryptoPlugin rz_crypto_plugin_cps2

Initial value:

= {
    .name = "cps2",
    .author = "pancake,esanfelix,pof",
    .license = "LGPL-3",
    .set_key = set_key,
    .get_key_size = get_key_size,
    .use = cps2_use,
    .update = update,
    .init = cps2_init,
    .fini = cps2_fini,
}

Definition at line 2954 of file crypto_cps2.c.