DES加解密BMP文件及其分析

这几天，我们实验课有一个DES加密及其分析的实验，我把代码贴出来，大家参考一下。
实验是对bmp文件进行加密与加密，有ECB，跟CBC两种加解密模式，以及一些雪崩效应、完整性测试、S盒的差分分布等等。

main.cpp

以下内容为程序代码:

//main.cpp
#include "DES.h"
#include
#include
#include
using namespace std;

void Encrypt_Mode(void);
void Test_Mode(void);

int main()
{
    int choose;

    cout<<"\t\t\t#### S-BOX Design ####"<    cout<<"1.Use Standard S-Box\n2.Use Random S-Box\n3.Use Linearity S-Box\n4.My Design S-Box"<    cout<<"Your Choose: ";
    cin>>choose;

     if( (choose != 1) && (choose != 2) && (choose != 3) && (choose != 4) )
    {
        cout<<"Error Choose!"<        return 1;
    }
    system("cls");

    switch(choose)
    {
    case 1:
        break;
    case 2:
        GetRandSBox();
        break;
    case 3:
        GetLineSBox();
        break;
    case 4:
        MySBox();
        break;
    }

    cout<<"\t\t\t#### DES Encrypt System ####"<    cout<<"1.Encrypt Mode\n2.Test Mode"<    cout<<"Your Choose: ";
    cin>>choose;

    system("cls");

    switch(choose)
    {
    case 1:
        Encrypt_Mode();    
        break;
    case 2:
        Test_Mode();
        break;
    default:
        cout<<"Error Choose!"<    }

    return 0;
}

////////////////////////////////////////////////////////////////////////////////////
void Encrypt_Mode()
{
    uvar32 FileSize,Offset,DataSize;

    char IV[]="wang yao";
    char key[8]={1,9,8,7,0,3,1,4};
    char plaint[8]={0},crypt[8]={0};
    //string Header;
    char Header[HEAD_LEN];

    ifstream fin;
    ofstream fout;

    int choose;
    while(true)
    {
        cout<<"\t\t\tDES Encrypt BMP File System"<        cout<<"\n1.EBC ENCRYPT\n2.EBC DECRYPT\n3.CBC ENCRYPT\n4.CBC DECRYPT\n5.Exit"<        cout<<"Your Choose: ";

        cin>>choose;

        if(choose == 5)
            break;
        else if( (choose != 1) && (choose != 2) && (choose != 3) && (choose != 4) )
        {
            cout<<"Wrong Choose!"<            break;
        }

        cout << "Enter the file's name: ";
        string filename;
        cin >> filename;

        ifstream fin(filename.c_str(),ios::binary);
        string outfilename = filename;
        outfilename = "out_" + outfilename;
        ofstream fout(outfilename.c_str(),ios::binary);

        if(!fin || !fout)
        {
            cout<<"Open File Error!"<            return;
        }

        fin.seekg(2); //Skip "BM"(the head of the BMP file)
        fin.read((char*)&FileSize ,sizeof(uvar32)); //Get the BMP File Size

        fin.seekg(sizeof(uvar32),ios_base::cur); //Skip the Reserved Field
        fin.read((char*)&Offset  ,sizeof(uvar32)); //Get the Offset of the Real Size

        DataSize = FileSize - Offset; //Get the Data Size;Also can be done by "DataSize" Field in the Header

        //Set the Key
        Des_SetKey(key);

        //Copy the Header to encrypt file
        fin.seekg(ios::beg);
        fin.read(Header,Offset);
        fout.write(Header,Offset);

        memcpy(crypt,IV,8); //Get the IV key
        //Do DES Encrypt
        for(int i=0;i < DataSize/8;i++)
        {
            fin.read(plaint,8);

            switch(choose)
            {
            case 1: //ECB DES ENCRYPT
                ECB_Des_Run(crypt,plaint, ENCRYPT);
                fout.write(crypt,8);
                break;
            case 2: //ECB DES DECRYPT
                ECB_Des_Run(crypt,plaint, DECRYPT);
                fout.write(crypt,8);
                break;
            case 3: //CBC DES ENCRYPT
                CBC_Des_Run(crypt,plaint, ENCRYPT);
                fout.write(crypt,8);
                break;
            case 4: //CBC DES DECRYPT
                CBC_Des_Run(crypt,plaint, DECRYPT);
                fout.write(crypt,8);
                memcpy(crypt,plaint,8); //Get the IV key
            }
        }

        system("cls");
    }

    fin.close();
    fout.close();

    system("pause");

}

void Test_Mode()
{
    bool PlaintBits1[64]={0},PlaintBits2[64]={0}; //Snowslip_Test
    bool PlaintBits[PLAINT_SIZE][64]; //Completeness_Test
    int choose;

    while (true)
    {
        cout<<"\t\t\t#### DES Test Mode ####"<        cout<<"1.Snowslip Test\n2.Completeness Test\n3.Differential Cryptanalysis Test\n4.Exit"<        cout<<"Your Choose: ";
        cin>>choose;

        if (choose == 4)
            break;

        switch(choose)
        {
        case 1:
            //Snowslip_Test
            GetRandPlaint_Snowslip(PlaintBits1,PlaintBits2);
            Snowslip_Test(PlaintBits1,PlaintBits2);
            break;
        case 2:
            //Completeness_Test
            GetRandPlaint_Complete(PlaintBits);
            Completeness_Test(PlaintBits);
            break;
        case 3:
            Differential_Analysis();
            break;
        default:
            cout<<"Error Choose!"<        }
        
        system("pause");
        system("cls");
    }

}
//~main.cpp

des.h

以下内容为程序代码:

//DES.h
#ifndef DES_H
#define DES_H

//Used by Copy BMP FileHeader
#define HEAD_LEN 65536
//Used by Test Mode
#define PLAINT_SIZE 64

typedef unsigned int uvar32;
//typedef unsigned short int uvar16;

enum CHOOSE{ENCRYPT,DECRYPT};

//////////////////////////////////////////////////////////////////////////

// 加/解密 Type—ENCRYPT:加密,DECRYPT:解密
void ECB_Des_Run(char Out[8], char In[8], bool Type=ENCRYPT);
// 设置密钥
void Des_SetKey(const char Key[8]);

static void F_func(bool In[32], const bool Ki[48]);// f 函数
static void S_func(bool Out[32], const bool In[48]);// S 盒代替
static void Transform(bool *Out, bool *In, const char *Table, int len);// 变换
static void Xor(bool *InA, const bool *InB, int len);// 异或
static void RotateL(bool *In, int len, int loop);// 循环左移
static void ByteToBit(bool *Out, const char *In, int bits);// 字节组转换成位组
static void BitToByte(char *Out, const bool *In, int bits);// 位组转换成字节组

//////////////////////////////////////////////////////////////////////////
//Build S-Box
void GetRandSBox(void);
void GetLineSBox(void);
void MySBox(void);
//////////////////////////////////////////////////////////////////////////
//CBC Mode
void CBC_Des_Run(char Out[8], char In[8], bool Type);
///////////////////////////////////////////////////////////////////////////
//Test Mode
void Snowslip_Test(bool Plaint1[64],bool Plaint2[64]);
void GetRandPlaint_Snowslip(bool PlaintBits1[64],bool PlaintBits2[64]);
void Completeness_Test(bool Text[PLAINT_SIZE][64]);
void GetRandPlaint_Complete(bool PlaintBits[PLAINT_SIZE][64]);
void Differential_Analysis(void);
void int2bin(int var,bool *bin,int bin_size);
int bin2int(bool bin[],int bin_size);
void S_Box_single(bool In[6],bool Out[4],int num);

#endif

des.cpp
以下内容为程序代码:

//DES.cpp
#include
#include
#include
#include
#include "DES.h"
using namespace std;

////////////////////////////////////////////////////////////////////
// initial permutation IP
const static char IP_Table[64] = {
    58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
    62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
    57, 49, 41, 33, 25, 17,  9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
    61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
};
// final permutation IP^-1
const static char IPR_Table[64] = {
    40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
    38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
    36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
    34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41,  9, 49, 17, 57, 25
};
// expansion operation matrix
static const char E_Table[48] = {
    32,  1,  2,  3,  4,  5,  4,  5,  6,  7,  8,  9,
    8,  9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
    16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
    24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32,  1
};
// 32-bit permutation function P used on the output of the S-boxes
const static char P_Table[32] = {
    16, 7, 20, 21, 29, 12, 28, 17, 1,  15, 23, 26, 5,  18, 31, 10,
    2,  8, 24, 14, 32, 27, 3,  9,  19, 13, 30, 6,  22, 11, 4,  25
};
// permuted choice table (key)
const static char PC1_Table[56] = {
    57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
    10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
    63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
    14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
};
// permuted choice key (table)
const static char PC2_Table[48] = {
    14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
    23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
    41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
    44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
};
// number left rotations of pc1
const static char LOOP_Table[16] = {
    1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
};

//extern char S_Box[8][4][16];
// The (in)famous S-boxes
//const static char S_Box[8][4][16] = {
static char S_Box[8][4][16] = {
    // S1
    14,     4,    13,     1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
    0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
    4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
    15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13,
    // S2
    15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
    3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
    0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
    13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9,
    // S3
    10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
    13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
    13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
    1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12,
    // S4
    7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
    13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
    10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
    3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14,
    // S5
    2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
    14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
    4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
    11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3,
    // S6
    12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
    10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
    9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
    4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13,
    // S7
    4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
    13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
    1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
    6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12,
    // S8
    13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
    1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
    7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
    2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
};

//////////////////////////////////////////////////////////////////////////

static bool SubKey[16][48];// 16圈子密钥

//////////////////////////////////////////////////////////////////////////
void ECB_Des_Run(char Out[8], char In[8], bool Type)
{
    static bool M[64], Tmp[32], *Li = &M[0], *Ri = &M[32];
    ByteToBit(M, In, 64);
    Transform(M, M, IP_Table, 64);
    if( Type == ENCRYPT ){
        //fk(L,R) = (L^F(R,SK),R)
        for(int i=0; i<16; i++) {
            memcpy(Tmp, Ri, 32);
            F_func(Ri, SubKey[i]);
            Xor(Ri, Li, 32);
            memcpy(Li, Tmp, 32);
        }
    }else{
        for(int i=15; i>=0; i--) {
            memcpy(Tmp, Li, 32);
            F_func(Li, SubKey[i]);
            Xor(Li, Ri, 32);
            memcpy(Ri, Tmp, 32);
        }
    }
    Transform(M, M, IPR_Table, 64);
    BitToByte(Out, M, 64);
}

void CBC_Des_Run(char Out[8], char In[8], bool Type)
{
    static bool M[64],N[64], Tmp[32], *Li = &M[0], *Ri = &M[32];
    ByteToBit(M, In, 64);
    ByteToBit(N, Out, 64);
    if (Type == ENCRYPT)
        Xor(M,N, 64);
    
    Transform(M, M, IP_Table, 64);
    if( Type == ENCRYPT ){
        //fk(L,R) = (L^F(R,SK),R)
        for(int i=0; i<16; i++) {
            memcpy(Tmp, Ri, 32);
            F_func(Ri, SubKey[i]);
            Xor(Ri, Li, 32);
            memcpy(Li, Tmp, 32);
        }
    }else{
        for(int i=15; i>=0; i--) {
            memcpy(Tmp, Li, 32);
            F_func(Li, SubKey[i]);
            Xor(Li, Ri, 32);
            memcpy(Ri, Tmp, 32);
        }
    }
    Transform(M, M, IPR_Table, 64);

    if(Type == DECRYPT)
        Xor(M,N, 64);

    BitToByte(Out, M, 64);
    //BitToByte(In, N, 64);
}

void Des_SetKey(const char Key[8])
{
    static bool K[64], *KL = &K[0], *KR = &K[28];
    ByteToBit(K, Key, 64);
    //PC1 Transform
    Transform(K, K, PC1_Table, 56);
    for(int i=0; i<16; i++) {
        RotateL(KL, 28, LOOP_Table[i]); //Left shift circle
        RotateL(KR, 28, LOOP_Table[i]);
        //PC2 Transform
        Transform(SubKey[i], K, PC2_Table, 48);
    }
}

//A Round of DES
void F_func(bool In[32], const bool Ki[48])
{
    static bool MR[48];
    //E Transform
    Transform(MR, In, E_Table, 48);
    Xor(MR, Ki, 48);
    S_func(In, MR); //S BOX
    //P Transform
    Transform(In, In, P_Table, 32);
}

//S BOX
/*
void S_func(bool Out[32], const bool In[48])
{
    //i<8 <==> 8's S-BOX;In(6)==>Out(4)
    for(char i=0,j,k; i<8; i++,In+=6,Out+=4) {
        j = (In[0]<<1) + In[5];
        k = (In[1]<<3) + (In[2]<<2) + (In[3]<<1) + In[4];
        ByteToBit(Out, &S_Box[i][j][k], 4);
    }
}
*/

void S_func(bool Out[32], const bool In[48])
{
    //i<8 <==> 8's S-BOX;In(6)==>Out(4)
    for(char i=0,j,k; i<8; i++,In+=6,Out+=4) {
        j = (In[0]<<1) + In[5];
        k = (In[1]<<3) + (In[2]<<2) + (In[3]<<1) + In[4];
        ByteToBit(Out, &S_Box[i][j][k], 4);
    }
}

//Trabsform through TABLE
void Transform(bool *Out, bool *In, const char *Table, int len)
{
    static bool Tmp[256];
    for(int i=0; i        Tmp[i] = In[ Table[i]-1 ];
    memcpy(Out, Tmp, len);
}
void Xor(bool *InA, const bool *InB, int len)
{
    for(int i=0; i        InA[i] ^= InB[i];
}
void RotateL(bool *In, int len, int loop)
{
    static bool Tmp[256];
    //Store the first (loop) bits to Tmp
    memcpy(Tmp, In, loop);
    //Copy the end of                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        the (len-loop) bits to the front of In
    memcpy(In, In+loop, len-loop);
    //Move the Stored (loop) bits to the end of Nes In
    memcpy(In+len-loop, Tmp, loop);
}
void ByteToBit(bool *Out, const char *In, int bits)
{
    for(int i=0; i        Out[i] = (In[i/8]>>(i%8)) & 1;
    //Get the last of the Byte
}
void BitToByte(char *Out, const bool *In, int bits)
{
    memset(Out, 0, (bits+7)/8);
    for(int i=0; i        Out[i/8] |= In[i]<<(i%8);
}


void GetRandSBox()
{
    int Temp[16]={0},MaxIndex=15;

    for(int i=0;i<16;i++)
        Temp[i] = i;

    //    int Mark[16]={0};
    srand((unsigned)time(NULL));

    for(int i = 0;i<8;i++)
    {
        for(int j=0;j<4;j++)
        {
            //RandBOX(S_Box[i][j]);
            for(int k=0;k<16;k++)
            {
                int temp = rand()%(MaxIndex+1);
                S_Box[i][j][k] = Temp[temp];

                if (MaxIndex > temp)
                    Temp[temp] = Temp[MaxIndex];

                MaxIndex--;
                //    cout<            }
            MaxIndex = 15;
            for(int l=0;l<16;l++)
                Temp[l] = l;
        }
    }
}
/*
void GetRandSBox()
{
    int Mark[16]={0};
    srand((unsigned)time(NULL));

    for(int i = 0;i<8;i++)
        for(int j=0;j<4;j++)
        {
            //RandBOX(S_Box[i][j]);
            for(int k=0;k<16;k++)
            {
GETRAND:
                int temp = rand()%16;
                if(Mark[temp] == 0)
                {
                    S_Box[i][j][temp] = k;
                    //cout<                    Mark[temp] = 1;
                }
                else
                    goto GETRAND;
            }
            //Reset the Mark
            for (int k=0;k<16;k++)
                Mark[k] = 0;
        }
}

*/
//Input:(a,b,c,d,e,f)
//Output:(b,c,d,e)
//(a,b,c,d,e,f)==>(b,c,d,e)
//Also can be: (a,b,c,d,e,f)==>(b,c,a^d,e^f)
void GetLineSBox(void)
{
        for(int j=0;j<4;j++)
            //RandBOX(S_Box[i][j]);
            for(int k=0;k<16;k++)
                    for(int i = 0;i<8;i++)
                        S_Box[i][j][k] = k;
}

//Input:(a,b,c,d,e,f)
//Output:(q,r,s,t)
// q=abcd^00ef
// r=abef^00cd
// s=cdef^00ab
// t=cdab^ef00
void MySBox(void)
{

}
//////////////////////////////////////////////////////////////////////////
//Test Mode Method
void Snowslip_Test(bool Plaint1[64],bool Plaint2[64])
{
    static bool Tmp[32], *Li1 = &Plaint1[0], *Ri1 = &Plaint1[32];
    static bool *Li2 = &Plaint2[0], *Ri2 = &Plaint2[32];

    //ByteToBit(M, In, 64);
    //Transform(M, M, IP_Table, 64);
    
        //fk(L,R) = (L^F(R,SK),R)
        for(int i=0; i<16; i++) {
            memcpy(Tmp, Ri1, 32);
            F_func(Ri1, SubKey[i]);
            Xor(Ri1, Li1, 32);
            memcpy(Li1, Tmp, 32);
            
            memcpy(Tmp, Ri2, 32);
            F_func(Ri2, SubKey[i]);
            Xor(Ri2, Li2, 32);
            memcpy(Li2, Tmp, 32);

            int count = 0;
            for (int j=0;j<64;j++)
                if (Plaint1[j] != Plaint2[j])
                    count++;

            //cout<<"The "<            cout<<"The "<        }
}

void Completeness_Test(bool Text[PLAINT_SIZE][64])
{
    static bool Tmp[32], *Li , *Ri;
    int count[64][2]={0};

    //ByteToBit(M, In, 64);
    //Transform(M, M, IP_Table, 64);

    for(int i=0;i    {
        Li = &Text[i][0];
        Ri = &Text[i][32];
        //fk(L,R) = (L^F(R,SK),R)
        for(int j=0; j<16; j++)
        {
            memcpy(Tmp, Ri, 32);
            F_func(Ri, SubKey[i]);
            Xor(Ri, Li, 32);
            memcpy(Li, Tmp, 32);
        }
        
        for (int k = 0;k < 64;k++)
        {
            if (Text[i][k] == 0)
                count[k][0]++;
            else
                count[k][1]++;
        }
    }

    //Get the frequency
    cout<<"Every bit is 0's frequency: "<    for (int i=0;i<64;i++)
        cout<<"The "<}

void GetRandPlaint_Snowslip(bool PlaintBits1[64],bool PlaintBits2[64])
{
    //    char Out1[8]={0},Out2[8]={0};
    //static bool PlaintBits1[64],PlaintBits2[64];

    srand((unsigned)time(NULL));
    int tempindex = rand()%64;
    int tempvalue = rand()%2;

    PlaintBits1[tempindex] = tempvalue;
    PlaintBits2[tempindex] = tempvalue ^1;

    for(int i = 0;i<64;i++)
        if (i != tempindex)
        {
            tempvalue = rand()%2;
            PlaintBits1[i] = tempvalue;
            PlaintBits2[i] = tempvalue;
        }
}

void GetRandPlaint_Complete(bool PlaintBits[PLAINT_SIZE][64])
{
    srand((unsigned)time(NULL));
    int tempindex = rand()%64;
    int tempvalue1 = rand()%2;

    for (int i=0;i    {
        PlaintBits[i][tempindex] = tempvalue1;
        for(int j = 0;j<64;j++)
            if (j != tempindex)
            {
                int tempvalue2 = rand()%2;
                PlaintBits[i][j] = tempvalue2;
            }
    }
}

void Differential_Analysis(void)
{
    int count[8][64][16]={0};//Used count the Differential Distributing

    for (int i = 0;i<8;i++)
    {
        cout<<"The "<        for (int l=0;l<16;l++)
            cout<<" "<        cout<
        for (int j = 0;j<64;j++)
        {
            bool In[6]={0};
            int2bin(j,In,6);
            for (int k=0;k<64;k++)
            {
                bool In1[6]={0},In2[6]={0},Out1[4]={0},Out2[4]={0};
                int2bin(k,In1,6);
                S_Box_single(In1,Out1,i);
                int2bin(j^k,In2,6); //    Xor(In,In1,6);
                S_Box_single(In2,Out2,i);

                Xor(Out1,Out2,4); //Out1 <== Out1 ^ Out2 (Out == Out1)
                count[i][j][bin2int(Out1,4)] ++;
            }
            cout<            for (int l=0;l<16;l++)
                cout<            cout<        }
        cout<        system("pause");
    }
}

void S_Box_single(bool In[6],bool Out[4],int num)
{
    int Line = 2*In[0] + In[5];
    int Row = 8*In[1]+4*In[2]+2*In[3]+In[4];

    int2bin(S_Box[num][Line][Row],Out,4);
}
void int2bin(int var,bool *bin,int bin_size)
{
    char temp = (unsigned char)var;

    for(int i=0;i    {
        bin[i] = temp & 0x01;
        temp >>= 1;
    }
}

int bin2int(bool bin[],int bin_size)
{
    int var = 0;

    for(int i=0;i        var = 2*var + bin[bin_size-1-i];

    return var;
}