#define ROTR32_8(x) ( ( ( x << 24 ) & 0xFFFFFFFF ) | \
( ( x & 0xFFFFFFFF ) >> 8 ) )
#define ROTR32(x,t) ( ((x) >> (t)) + ((x) << (32 – t)) )
#define ROTL32(x,t) ( ((x) << (t)) + ((x) >> (32 – t)) )

#define ROTR16_1(x) ( ( ( x << 15 ) & 0xFFFF ) | \
( ( x & 0xFFFF ) >> 1 ) )
#define ROTL16_1(x) ( ( ( x >> 15 ) & 0xFFFF ) | \
( ( x & 0xFFFF ) << 1 ) )

#define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0×80 ) ? 0x1B : 0×00 ) )
#define MUL(x,y) ( ( x && y ) ? pow[(log[x] + log[y]) % 255] : 0 )

#define u8 unsigned char
#define u16 unsigned int
#define u32 unsigned long int

#define C1 0xD62F59FB
#define C2 0xD597BEF1
#define C3 0xE4F92E2D
#define C4 0xFF6EC9AB
#define C5 0xF2DCE89B
#define C6 0x636CB246

u32 WK[5]; /*Whitening Key*/
u32 KFA[3]; /*kunci FA*/
u32 SK[12],XL, XR, YL, YR; /*Round Key*/
u32 gA,gB,gC;

#define BC3_FROUND(XL,XR,YL,YR,SK) \
{ \
YL = XR; \
YR = Tbl0[ ( u8 ) ( XR >> 24 ) ] ^ \
Tbl1[ ( u8 ) ( XR >> 16 ) ] ^ \
Tbl2[ ( u8 ) ( XR >> 8 ) ] ^ \
Tbl3[ ( u8 ) ( XR ) ] ^ SK ^ XL; \
} \

#define BC3_FAR(a,b,c,d) \
{ \
c=ROTL32((a & KFA[1]),1) ^ b; \
d=(ROTR32(c,1)|KFA[2])^a; \
}

#define BC3_FAinverse(a,b,c,d) \
{ \
d = (ROTR32(b,1)|KFA[2])^a; \
c = ROTL32((d&KFA[1]),1)^b; \
}

Download bc3.h

Berikut adalah File bc3.c

#include <stdio.h>
#include <time.h>
#include <conio.h>
#include “BC3.h”

u32 Tbl0[256],Tbl1[256],Tbl2[256],Tbl3[256];

static u8 SBox[256] = /* SBox_BC3 */
{
0xbb,0x8b,0x9e,0xdf,0×42,0xd8,0xf7,0x1f,0×52,0xd7,0×26,0×80,0x3e,0×20,0×17,0x5b,
0xf1,0×94,0x5e,0xee,0×78,0×91,0x7a,0x3c,0×62,0×53,0×24,0xf6,0xc2,0×97,0xe3,0x8d,
0xc4,0xfc,0x5f,0xad,0×40,0x2b,0xa4,0×16,0x4c,0×50,0xbc,0×90,0xca,0×60,0×96,0×50,
0×81,0xba,0x4e,0×10,0xc0,0xd5,0×49,0xc3,0×48,0x3d,0xf0,0xb0,0xde,0×76,0xdb,0xf4,
0xe6,0xcd,0×56,0xed,0x6c,0xf8,0xb6,0xc0,0×36,0×82,0x2e,0x7c,0xda,0x4a,0×92,0xdd,
0x7f,0xd4,0×99,0xb8,0×71,0×28,0xe9,0×33,0xac,0×68,0×66,0x9f,0x1b,0x7d,0×88,0×00,
0xa8,0×43,0xc1,0x1c,0×34,0xfd,0×59,0x8f,0xcf,0xd9,0xf0,0xc5,0xbd,0×46,0×31,0×14,
0x1e,0xf3,0xc6,0×58,0x3b,0×87,0xe5,0x6e,0x6f,0xdc,0xa9,0xb4,0×21,0x5d,0×30,0×39,
0x9d,0xcc,0x6b,0×23,0xd0,0×65,0×98,0x9a,0×73,0×77,0x7b,0×69,0×70,0xd0,0×37,0×64,
0xea,0×57,0xe1,0xeb,0x8a,0xce,0xe0,0xf5,0x4d,0xe4,0x5c,0×45,0×54,0xab,0×83,0x9c,
0x8e,0x2f,0×40,0×74,0xcb,0×70,0×55,0x2d,0×86,0xaa,0xb3,0xa3,0×29,0xec,0×51,0xe0,
0xfb,0x8c,0xe2,0xd6,0×12,0xe8,0×10,0xa5,0xa0,0xd2,0xef,0x9b,0×93,0×11,0×35,0xd3,
0x1d,0×79,0x1a,0xb5,0×25,0×18,0xb7,0xaf,0x2c,0x4f,0xff,0xa2,0xc8,0×13,0×22,0×60,
0xe7,0xbf,0×44,0x3a,0xc7,0×41,0xbe,0xd1,0×15,0xfa,0x6a,0×67,0×95,0×80,0xb2,0xa1,
0×19,0xae,0x4b,0x7e,0xc9,0xfe,0×85,0xb0,0×38,0x5a,0×27,0xa0,0×89,0×47,0×84,0×75,
0xb1,0xa6,0x3f,0×30,0×20,0×63,0×72,0xf2,0xa7,0x2a,0xf9,0×61,0×32,0x6d,0xb9,0×90
};

void BC3_gen_tables( void )
{
int i;
u8 x, y;
u8 pow[256];
u8 log[256];

/* Buat tabel perkalian dengan MDS */

for( i = 0; i < 256; i++ )
{
x = (unsigned char) SBox[i]; y = XTIME( x );

Tbl0[i] = (u32) ( x ^ y ) ^
( (u32) x << 8 ) ^
( (u32) x << 16 ) ^
( (u32) y << 24 );

Tbl0[i] &= 0xFFFFFFFF;

Tbl1[i] = ROTR32_8( Tbl0[i] );
Tbl2[i] = ROTR32_8( Tbl1[i] );
Tbl3[i] = ROTR32_8( Tbl2[i] );

}

}

void BC3_keysch(u32 ku[4])
{
int i; /* ku[0] || ku[1] || ku[2] || ku[3] */
u32 KA,KB,KC,KD,KE,KF,KG;

XL = ku[0]^ku[2]; XR = ku[1]^ku[3];
BC3_FROUND(XL,XR,YL,YR,C1);
BC3_FROUND(YL,YR,XL,XR,C2);
XL ^= ku[0]; XR ^= ku[1];
BC3_FROUND(XL,XR,YL,YR,C3);
BC3_FROUND(YL,YR,XL,XR,C4);
XL ^= ku[2]; XR ^= ku[3];
KA = XL ; KB = XR;
BC3_FROUND(XL,XR,YL,YR,C5);
BC3_FROUND(YL,YR,XL,XR,C6);
KC = XL; KD = XR;

KE = KA | KB ^ KC;
KF = KA & KB ^ KD;
KG = KC & KD ^ KA;

WK[1]= KE&KF^KG;
WK[2]= KF|KG^KE;

SK[1] = KE&WK[2]^KF;
SK[2] = KE&KF^WK[1];
SK[3] = WK[1]|WK[2]^SK[2];
SK[4] = SK[1]|WK[2]^SK[3];
KFA[1]= C1&KE^SK[4];
SK[5] = C2&WK[2]^SK[3];
SK[6] = SK[1]|SK[2]^SK[5];
SK[7] = SK[6]&WK[2]^KFA[1];
KFA[2]= SK[1]&SK[5]^SK[6];
SK[8] = C3&SK[3]^SK[7];
SK[9] = ROTR32(SK[5],1)^SK[3];
SK[10]= SK[8]&SK[4]^SK[5];
SK[11]= SK[3]&SK[5]^SK[6];
WK[3] = SK[9]&SK[4]^SK[6];
WK[4] = SK[2]&SK[8]^SK[9];
}

void BC3_encrypt(u32 XL, u32 XR)
{/* input ronde = XL||XR */
u32 a,b,c,d;
int i;

XL ^= WK[1]; XR ^= WK[2];

BC3_FROUND(XL,XR,YL,YR,SK[1]); /*ronde 1*/
BC3_FROUND(YL,YR,XL,XR,SK[2]); /*ronde 2*/
BC3_FROUND(XL,XR,YL,YR,SK[3]); /*ronde 3*/
BC3_FROUND(YL,YR,XL,XR,SK[4]); /*ronde 4 keluaran = XR||XL*/
BC3_FAR(XL,XR,YL,YR);
BC3_FROUND(YL,YR,XL,XR,SK[5]); /*ronde 5*/
BC3_FROUND(XL,XR,YL,YR,SK[6]); /*ronde 6*/
BC3_FROUND(YL,YR,XL,XR,SK[7]); /*ronde 7*/
BC3_FAinverse(XL,XR,YL,YR);
BC3_FROUND(YL,YR,XL,XR,SK[8]); /*ronde 8*/
BC3_FROUND(XL,XR,YL,YR,SK[9]); /*ronde 9*/
BC3_FROUND(YL,YR,XL,XR,SK[10]); /*ronde 10*/

/*ronde terakhir*/

YR = XR ^ WK[4];
YL = Tbl0[ ( u8 ) ( XR >> 24 ) ] ^
Tbl1[ ( u8 ) ( XR >> 16 ) ] ^
Tbl2[ ( u8 ) ( XR >> 8 ) ] ^
Tbl3[ ( u8 ) ( XR ) ] ^ SK[11] ^ WK[3] ^ XL;
}

/* Alogoritma enkripsi = dekripsi hanya urutan subkey saling berkebalikan
Dipisahkan pembuatannya untuk mengejar kecepatan (meskipun mungkin selisih sedikit) */

void BC3_decrypt( u32 XL, u32 XR)
{
u32 buf; /* input ronde = XL||XR */
int i;
XL ^= WK[3]; XR ^= WK[4];

BC3_FROUND(XL,XR,YL,YR,SK[11]); /*ronde 1*/
BC3_FROUND(YL,YR,XL,XR,SK[10]); /*ronde 2*/
BC3_FROUND(XL,XR,YL,YR,SK[9]); /*ronde 3*/
BC3_FROUND(YL,YR,XL,XR,SK[8]); /*ronde 4 keluaran = XR||XL*/
BC3_FAR(XL,XR,YL,YR);
BC3_FROUND(YL,YR,XL,XR,SK[7]); /*ronde 5*/
BC3_FROUND(XL,XR,YL,YR,SK[6]); /*ronde 6*/
BC3_FROUND(YL,YR,XL,XR,SK[5]); /*ronde 7*/
BC3_FAinverse(XL,XR,YL,YR);
BC3_FROUND(YL,YR,XL,XR,SK[4]); /*ronde 8*/
BC3_FROUND(XL,XR,YL,YR,SK[3]); /*ronde 9*/
BC3_FROUND(YL,YR,XL,XR,SK[2]); /*ronde 10*/

/*ronde terakhir*/

YR = XR ^ WK[2];
YL = Tbl0[ ( u8 ) ( XR >> 24 ) ] ^
Tbl1[ ( u8 ) ( XR >> 16 ) ] ^
Tbl2[ ( u8 ) ( XR >> 8 ) ] ^
Tbl3[ ( u8 ) ( XR ) ] ^SK[1]^ WK[1] ^ XL;
}

int main(void)
{
int i,j,k,l,jum;
u8 in[8],out[8];

u32 ku[4];
u32 data32,X,Y;
u16 data16;
clock_t start, end;
float waktu;

printf(“BC3 : The 64-bit encryption algorithm\n”);
BC3_gen_tables();
printf(“\n\nTES KECEPATAN BC3 UNTUK ENKRIPSI 2 X 1 JUTA BLOK\n”);

start = clock();
for(i=0;i<2000000;i++)
BC3_encrypt(XL, XR);

end = clock();
printf(“\nTotal Waktu 2 juta kali Enkripsi 64 bit = %f detik”, (end – start) / CLK_TCK);

for(i=0;i<4;i++)
ku[i] = 0;
ku[0]=0×00100000;

BC3_keysch(ku);

printf(“\n\nTES KECEPATAN Keyschedule BC3 untuk 2 JUTA BLOK\n”);
start = clock();
for(i=0;i<2000000;i++)
BC3_keysch(ku);

end = clock();
waktu = (end – start) / CLK_TCK;
printf(“\nTotal Waktu 2 juta kali Keyschedule = %f detik”,waktu );

printf(“\n\n\n\t============ TEST VECTOR ============”);

for(i=0;i<4;i++)
ku[i] = 0;

printf(“\n\nMasterkey \t: “);
for(i=0;i<4;i++)
printf(“%x “,ku[i]); /* 128 bit */
printf(” (128 bit)”);
BC3_keysch(ku);

/*Masukan plaintext*/
XL = 0×80000000; XR = 0×80000000;
YL = 0; YR = 0;
printf(“\nPlaintext \t: %X %X\n”,XL, XR);

BC3_encrypt(XL, XR);
printf(“\nCiphertext \t: %X %X\n”,YL,YR);
XL = YL; XR = YR; YR = 0;
BC3_decrypt(XL,XR);
printf(“\nHasil dekripsi \t: %X %X\n”,YL,YR);

printf(“\n\n\t============ ooo0ooo ============\n”);

for(i=0;i<4;i++)
ku[i] = 0;
ku[3]=0×0000001;

printf(“\n\nMasterkey \t: “);
for(i=0;i<4;i++)
printf(“%x “,ku[i]); /* 128 bit */
printf(” (128 bit)”);
BC3_keysch(ku);

/*Masukan plaintext*/
XL = 0×80000000; XR = 0×80000000;
YL = 0; YR = 0;
printf(“\nPlaintext \t: %X %X\n”,XL, XR);

BC3_encrypt(XL, XR);
printf(“\nCiphertext \t: %X %X\n”,YL,YR);
XL = YL; XR = YR; YR = 0;
BC3_decrypt(XL,XR);
printf(“\nHasil dekripsi \t: %X %X\n”,YL,YR);

printf(“\n\n\t============ ooo0ooo ============\n”);

ku[0]=0×12345678; ku[1]=0×12345678; ku[2]=0×12345678; ku[3]=0×12345678;
printf(“\n\nMasterkey \t: “);
for(i=0;i<4;i++)
printf(“%x “,ku[i]); /* 128 bit */
printf(” (128 bit)”);
BC3_keysch(ku);

/*Masukan plaintext*/
XL = 0xaabbccdd; XR = 0xeeff0011;
YL = 0; YR = 0;
printf(“\nPlaintext \t: %X %X\n”,XL, XR);

BC3_encrypt(XL, XR);
printf(“\nCiphertext \t: %X %X\n”,YL,YR);
XL = YL; XR = YR; YR = 0;
BC3_decrypt(XL,XR);
printf(“\nHasil dekripsi \t: %X %X\n”,YL,YR);

printf(“\n\n\t============ SELESAI ============\n\n”);

getch();
return 0;
}

Download bc3.c

Deskripsi BC3

BC3 menggunakan struktur Feistel seperti DES, sehingga dapat menggunakan algoritma enkripsi dan dekripsi yang sama. BC3 memiliki masukan / keluaran 64 bit dan kunci 128 bit. Bagian pengacakan BC3 terdiri atas 11 ronde regular dan 2 ronde khusus.

Gambar 1 Algoritma BC3

Fungsi FA didefinisikan sebagai:

Sedangkan fungsi FA^-1 didefinisikan sebagai

Bila masukan fungsi F dinyatakan dengan x sebanyak 32 bit, dan keluaran fungsi F dinyatakan dengan y (32 bit), maka

di mana P adalah operasi perkalian secara polinomial dengan matrik M yang bertujuan untuk mendapatkan difusi yang optimal. S adalah operasi subtitusi terhadap masukan masukan x₀,x₁,x₂,x₃. operasi S dilakukan terhadap setiap byte masukan. K merupakan subkey k₀,k₁,k₂,k₃.

Kotak subtitusi (dalam hexadesimal) :

Cara penggunaan. Masukan kotak subtitusi 0 akan diganti dengan bb_x, masukan 1 diganti dengan 8b_x , masukan 16 desimal diganti f1_x dan seterusnya.

Matrik M berupa :

Key schedule BC3:

Bagian ini mengandung bagian persiapan subkey. Kunci utama BC3 berupa kunci sepanjang 128 bit K = K1 || K2. K1 dan K2 masing-masing berukuran 64 bit.

Gambar 2. Bagian awal keyschedule BC3

Dari gambar di atas dapat disusun sebagai berikut:

Pembentukan subkey selengkapnya adalah sebagai berikut :

Keamanan

BC3 dirancang agar mampu bertahan dalam menghadapi berbagai analisis sandi seperti analisis sandi linear, diferensial, impossible differential attack, linear hull, interpolation attack, algebraic attack, related-key attack, slide attack, dan square attack.

Analisis sandi adalah metode untuk memecahkan algoritma kriptografi.

Cara lain untuk memeriksa keamanan algoritma kriptografi adalah dengan memeriksa sifat statistik output algoritma. Di antara metodenya adalah memeriksa apakah setiap perubahan 1 bit masukan akan mengubah rata-rata setengah bit keluaran.

Pada umumnya, algoritma yang lolos analisis sandi, otomatis juga akan lolos tes statistik, akan tetapi tidak berlaku hal yang sebaliknya. Oleh karena itu, meskipun analisis sandi seringkali jauh lebih sulit dilakukan daripada tes statistik, analisis sandi tetap harus dilakukan.

Sebagai contoh, DES merupakan algoritma enkripsi standar (de facto) internasional yang memiliki 16 ronde. Hanya dengan 8 ronde saja, DES terbukti sanggup bertahan terhadap berbagai tes statistik. Akan tetapi, DES 16 ronde masih dapat ditembus oleh analisis sandi linear dan diferensial.

Efisiensi

BC3 juga dirancang agar dapat diimplementasikan pada berbagai platform software/hardware secara efisien dan cepat. Dengan kesederhanaannya, BC3 mudah diimplementasikan dengan benar dan mudah diperiksa keamanannya.

Keistimewaan

Mempunyai kecepatan keyschedule lebih dari 200% dibanding AES. Memiliki keyschedule yang bersifat satu arah, sehingga penemuan subkey tidak otomatis mempermudah attacker untuk mendapatkan kunci utama, tidak seperti pada AES dan DES. Dengan demikian, BC3 sangat baik digunakan pada aplikasi yang sering menggunakan kunci yang berubah-ubah. Kotak subtitusinya juga sudah diperbaiki, sehingga kami harap akan lebih kebal terhadap algebraic attack dibanding AES.

Download disini