我试图通过使用线程找到56位的密钥来打破des算法,对于27位的密钥大小,它工作得很好,但是当它变得更高时,进程会被linux内核杀死。我不明白为什么?我用htop来查看发生了什么,看起来它毫无理由地使用了大量内存和交换内存。我再次检查了我的代码,但看起来没什么内存泄漏。请帮帮我。

    # include <stdio.h>
# include <fstream>
# include <string.h>
# include <iostream>
# include <stdlib.h>
# include <math.h>
# include <pthread.h>
# include <fstream>
# include <streambuf>
using namespace std;
int flag=0;
int thread=0;


struct common_thread_param{
    int bin[56];
    char plain_text[1000];
    char cipher_text[1000];
    int thread;
} p1,p2,p3,p4;  // for 4 threads


struct result{
    int key_mod[64];
    int thread;
} res;  // for 4 threads






class Des
{
public:
    int keyi[16][48],
    total[64],
    left[32],
    right[32],
    ck[28],
    dk[28],
    expansion[48],
    z[48],
    xor1[48],
    sub[32],
    p[32],
    xor2[32],
    temp[64],
    pc1[56],
    ip[64],
    inv[8][8];

    char final[1000];
    void IP();
    void PermChoice1(int[64]);
    void PermChoice2();
    void Expansion();
    void inverse();
    void xor_two();
    void xor_oneE(int);
    void xor_oneD(int);
    void substitution();
    void permutation();
    void keygen(int[64]);
    char * Encrypt(char *, int[64]);
    char * Decrypt(char *, int[64]);
};
void Des::IP() //Initial Permutation
{
    int k = 58, i;
    for (i = 0; i<32; i++)
    {
    ip[i] = total[k-1];
    if (k - 8>0)  k = k - 8;
    else       k = k + 58;
    }
    k = 57;
    for (i = 32; i<64; i++)
    {
    ip[i] = total[k-1];
    if (k - 8>0)   k = k - 8;
    else     k = k + 58;
    }
}
void Des::PermChoice1(int key_mod[64]) //Permutation Choice-1
{
    int k = 57, i;
    for (i = 0; i<28; i++)
    {
    pc1[i] = key_mod[k - 1];
    if (k - 8>0)    k = k - 8;
    else      k = k + 57;
    }
    k = 63;
    for (i = 28; i<52; i++)
    {
    pc1[i] = key_mod[k - 1];
    if (k - 8>0)    k = k - 8;
    else         k = k + 55;
    }
    k = 28;
    for (i = 52; i<56; i++)
    {
    pc1[i] = key_mod[k - 1];
    k = k - 8;
    }

}
void Des::Expansion() //Expansion Function applied on `right' half
{
    int exp[8][6], i, j, k;
    for (i = 0; i<8; i++)
    {
    for (j = 0; j<6; j++)
    {
    if ((j != 0) || (j != 5))
    {
    k = 4 * i + j;
    exp[i][j] = right[k - 1];
    }
    if (j == 0)
    {
    k = 4 * i;
    exp[i][j] = right[k - 1];
    }
    if (j == 5)
    {
    k = 4 * i + j;
    exp[i][j] = right[k - 1];
    }
    }
    }
    exp[0][0] = right[31];
    exp[7][5] = right[0];

    k = 0;
    for (i = 0; i<8; i++)
    for (j = 0; j<6; j++)
    expansion[k++] = exp[i][j];
}
void Des::PermChoice2()
{
    int per[56], i, k;
    for (i = 0; i<28; i++) per[i] = ck[i];
    for (k = 0, i = 28; i<56; i++) per[i] = dk[k++];

    z[0] = per[13];
    z[1] = per[16];
    z[2] = per[10];
    z[3] = per[23];
    z[4] = per[0];
    z[5] = per[4];
    z[6] = per[2];
    z[7] = per[27];
    z[8] = per[14];
    z[9] = per[5];
    z[10] = per[20];
    z[11] = per[9];
    z[12] = per[22];
    z[13] = per[18];
    z[14] = per[11];
    z[15] = per[3];
    z[16] = per[25];
    z[17] = per[7];
    z[18] = per[15];
    z[19] = per[6];
    z[20] = per[26];
    z[21] = per[19];
    z[22] = per[12];
    z[23] = per[1];
    z[24] = per[40];
    z[25] = per[51];
    z[26] = per[30];
    z[27] = per[36];
    z[28] = per[46];
    z[29] = per[54];
    z[30] = per[29];
    z[31] = per[39];
    z[32] = per[50];
    z[33] = per[46];
    z[34] = per[32];
    z[35] = per[47];
    z[36] = per[43];
    z[37] = per[48];
    z[38] = per[38];
    z[39] = per[55];
    z[40] = per[33];
    z[41] = per[52];
    z[42] = per[45];
    z[43] = per[41];
    z[44] = per[49];
    z[45] = per[35];
    z[46] = per[28];
    z[47] = per[31];
}
void Des::xor_oneE(int round) //for Encrypt
{
    int i;
    for (i = 0; i<48; i++)
    xor1[i] = expansion[i] ^ keyi[round - 1][i];
}
void Des::xor_oneD(int round) //for Decrypt
{
    int i;
    for (i = 0; i<48; i++)
    xor1[i] = expansion[i] ^ keyi[16 - round][i];
}

void Des::substitution()
{
    int s1[4][16] =
    {
    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
    };

    int s2[4][16] =
    {
    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
    };

    int s3[4][16] =
    {
    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
    };

    int s4[4][16] =
    {
    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
    };

    int s5[4][16] =
    {
    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
    };

    int s6[4][16] =
    {
    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
    };

    int s7[4][16] =
    {
    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
    };

    int s8[4][16] =
    {
    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
    };
    int a[8][6], k = 0, i, j, p, q, count = 0, g = 0, v;

    for (i = 0; i<8; i++)
    {
    for (j = 0; j<6; j++)
    {
    a[i][j] = xor1[k++];
    }
    }

    for (i = 0; i<8; i++)
    {
    p = 1;
    q = 0;
    k = (a[i][0] * 2) + (a[i][5] * 1);
    j = 4;
    while (j>0)
    {
    q = q + (a[i][j] * p);
    p = p * 2;
    j--;
    }
    count = i + 1;
    switch (count)
    {
    case 1:
    v = s1[k][q];
    break;
    case 2:
    v = s2[k][q];
    break;
    case 3:
    v = s3[k][q];
    break;
    case 4:
    v = s4[k][q];
    break;
    case 5:
    v = s5[k][q];
    break;
    case 6:
    v = s6[k][q];
    break;
    case 7:
    v = s7[k][q];
    break;
    case 8:
    v = s8[k][q];
    break;
    }

    int d, i = 3, a[4];
    while (v>0)
    {
    d = v % 2;
    a[i--] = d;
    v = v / 2;
    }
    while (i >= 0)
    {
    a[i--] = 0;
    }

    for (i = 0; i<4; i++)
    sub[g++] = a[i];
    }
}

void Des::permutation()
{
    p[0] = sub[15];
    p[1] = sub[6];
    p[2] = sub[19];
    p[3] = sub[20];
    p[4] = sub[28];
    p[5] = sub[11];
    p[6] = sub[27];
    p[7] = sub[16];
    p[8] = sub[0];
    p[9] = sub[14];
    p[10] = sub[22];
    p[11] = sub[25];
    p[12] = sub[4];
    p[13] = sub[17];
    p[14] = sub[30];
    p[15] = sub[9];
    p[16] = sub[1];
    p[17] = sub[7];
    p[18] = sub[23];
    p[19] = sub[13];
    p[20] = sub[31];
    p[21] = sub[26];
    p[22] = sub[2];
    p[23] = sub[8];
    p[24] = sub[18];
    p[25] = sub[12];
    p[26] = sub[29];
    p[27] = sub[5];
    p[28] = sub[21];
    p[29] = sub[10];
    p[30] = sub[3];
    p[31] = sub[24];
}

void Des::xor_two()
{
    int i;
    for (i = 0; i<32; i++)
    {
    xor2[i] = left[i] ^ p[i];
    }
}

void Des::inverse()
{
    int p = 40, q = 8, k1, k2, i, j;
    for (i = 0; i<8; i++)
    {
    k1 = p;
    k2 = q;
    for (j = 0; j<8; j++)
    {
    if (j % 2 == 0)
    {
    inv[i][j] = temp[k1 - 1];
    k1 = k1 + 8;
    }
    else if (j % 2 != 0)
    {
    inv[i][j] = temp[k2 - 1];
    k2 = k2 + 8;
    }
    }
    p = p - 1;
    q = q - 1;
    }
}

char * Des::Encrypt(char *Text1, int key_mod[64])
{
    int i, a1, j, nB, m, iB, k, K, B[8], n, t, d, round;
    char *Text = new char[1000];
    strcpy(Text, Text1);
    i = strlen(Text);
    int mc = 0;
    a1 = i % 8;
    if (a1 != 0) for (j = 0; j<8 - a1; j++, i++) Text[i] = ' ';
    Text[i] = '\0';
    keygen(key_mod);
    for (iB = 0, nB = 0, m = 0; m<(strlen(Text) / 8); m++) //Repeat for TextLenth/8 times.
    {
    for (iB = 0, i = 0; i<8; i++, nB++)
    {
    n = (int)Text[nB];
    for (K = 7; n >= 1; K--)
    {
    B[K] = n % 2;  //Converting 8-Bytes to 64-bit Binary Format
    n /= 2;
    }
    for (; K >= 0; K--) B[K] = 0;
    for (K = 0; K<8; K++, iB++) total[iB] = B[K]; //Now `total' contains the 64-Bit binary format of 8-Bytes
    }
    IP(); //Performing initial permutation on `total[64]'
    for (i = 0; i<64; i++) total[i] = ip[i]; //Store values of ip[64] into total[64]

    for (i = 0; i<32; i++) left[i] = total[i]; //     +--> left[32]
    // total[64]--|
    for (; i<64; i++) right[i - 32] = total[i]; //            +--> right[32]
    for (round = 1; round <= 16; round++)
    {
    Expansion(); //Performing expansion on `right[32]' to get  `expansion[48]'
    xor_oneE(round); //Performing XOR operation on expansion[48],z[48] to get xor1[48]
    substitution();//Perform substitution on xor1[48] to get sub[32]
    permutation(); //Performing Permutation on sub[32] to get p[32]
    xor_two(); //Performing XOR operation on left[32],p[32] to get xor2[32]
    for (i = 0; i<32; i++) left[i] = right[i]; //Dumping right[32] into left[32]
    for (i = 0; i<32; i++) right[i] = xor2[i]; //Dumping xor2[32] into right[32]
    }
    for (i = 0; i<32; i++) temp[i] = right[i]; // Dumping   -->[ swap32bit ]
    for (; i<64; i++) temp[i] = left[i - 32]; //    left[32],right[32] into temp[64]

    inverse(); //Inversing the bits of temp[64] to get inv[8][8]
    /* Obtaining the Cypher-Text into final[1000]*/
    k = 128;
    d = 0;
    for (i = 0; i<8; i++)
    {
    for (j = 0; j<8; j++)
    {
    d = d + inv[i][j] * k;
    k = k / 2;
    }
    final[mc++] = (char)d;
    k = 128;
    d = 0;
    }
    } //for loop ends here
    final[mc] = '\0';
    return(final);
}

int common_thread_function(struct common_thread_param * data, Des d){
    long i = 0;

    int key_mod[64] =
    {
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0
    };

    long quotient = 0, temp = 0;
    for (unsigned long long int y = 0; y < pow(2,25); y++){
    if(flag ==1)
    break;
    i = 55;
    quotient = temp;
    if(flag!=0)
    break;
    //quotient = 16385;
    while (quotient != 0){

    data->bin[i--] = quotient % 2;

    quotient = quotient / 2;

    }
    temp++;
    int sum = 0, f = 0;
    for (int j = 0; j < 56; j++){
    sum = sum + data->bin[j];
    key_mod[f] = data->bin[j];
    f++;

    if (f % 8 == 7){
    if (sum % 2 == 0){
    key_mod[f] = 1;
    }
    else{
    key_mod[f] = 0;
    }
    f++;
    sum = 0;
    }
    }
    //cout << key_mod;
    if (strcmp(d.Encrypt(data->plain_text, key_mod), data->cipher_text) == 0){

    flag=1;
    memcpy(res.key_mod,key_mod,64*sizeof(int));
    res.thread = data->thread;
    thread = res.thread;
    break;
    }

    }
    return flag;
}

void *thread1(void *s)
{
    Des d;

    if(common_thread_function((struct common_thread_param *)s,d)==1 && thread == 1){
    cout << "Result Found\n";
    for (int k = 0; k < 64; k++)
    cout << res.key_mod[k];
    cout << "\n in Thread-" << res.thread << "\n" ;
    }

    pthread_exit(NULL);
}
void *thread2(void *s)
{
    Des d;

    if(common_thread_function((struct common_thread_param *)s,d)==1 && thread == 2){
    cout << "Result Found\n";
    for (int k = 0; k < 64; k++)
    cout << res.key_mod[k];
    cout << "\n in Thread-" << res.thread << "\n" ;
    }

    pthread_exit(NULL);
}

void *thread3(void *s)
{
    Des d;
    if(common_thread_function((struct common_thread_param *)s,d)==1 && thread == 3){
    cout << "Result Found\n";
    for (int k = 0; k < 64; k++)
    cout << res.key_mod[k];
    cout << "\n in Thread-" << res.thread << "\n" ;
    }
    pthread_exit(NULL);
}

void *thread4(void *s)
{
    Des d;
    if(common_thread_function((struct common_thread_param *)s,d)==1 && thread == 4){
    cout << "Result Found\n";
    for (int k = 0; k < 64; k++)
    cout << res.key_mod[k];
    cout << "\n in Thread-" << res.thread << "\n" ;
    }
    pthread_exit(NULL);
}

int main()
{
Des d2;



int bin_t1[56] =  {
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0
    };
    int bin_t2[56] =  {
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 1, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0
    };
    int bin_t3[56] =  {
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    1, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0
    };
    int bin_t4[56] =  {
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    1, 1, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0
    };

memcpy(p1.bin,bin_t1,56*sizeof(int));
memcpy(p2.bin,bin_t2,56*sizeof(int));
memcpy(p3.bin,bin_t3,56*sizeof(int));
memcpy(p4.bin,bin_t4,56*sizeof(int));

p1.thread =1;
p2.thread =2;
p3.thread =3;
p4.thread =4;
    char pt[1000];
    cin >> pt;


strcpy(p1.plain_text, pt);
strcpy(p2.plain_text, pt);
strcpy(p3.plain_text, pt);
strcpy(p4.plain_text, pt);


strcpy(p1.cipher_text, ct);
strcpy(p2.cipher_text, ct);
strcpy(p3.cipher_text, ct);
strcpy(p4.cipher_text, ct);

    pthread_t t1,t2,t3,t4;
    pthread_create(&t1,NULL,thread1,&p1);
    pthread_create(&t2,NULL,thread2,&p2);
    pthread_create(&t3,NULL,thread3,&p3);
    pthread_create(&t4,NULL,thread4,&p4);

    pthread_exit(NULL);

}

void Des::keygen(int key_mod[64])
{
    PermChoice1(key_mod);

    int i, j, k = 0;
    for (i = 0; i<28; i++)
    {
    ck[i] = pc1[i];
    }
    for (i = 28; i<56; i++)
    {
    dk[k] = pc1[i];
    k++;
    }
    int noshift = 0, round;
    for (round = 1; round <= 16; round++)
    {
    if (round == 1 || round == 2 || round == 9 || round == 16)
    noshift = 1;
    else
    noshift = 2;
    while (noshift>0)
    {
    int t;
    t = ck[0];
    for (i = 0; i<28; i++)
    ck[i] = ck[i + 1];
    ck[27] = t;
    t = dk[0];
    for (i = 0; i<28; i++)
    dk[i] = dk[i + 1];
    dk[27] = t;
    noshift--;
    }
    PermChoice2();
    for (i = 0; i<48; i++)
    keyi[round - 1][i] = z[i];
    }
}

最佳答案

听起来你的进程被LinuxOOM杀手终止了,你是这么说的吗?如果是这样的话,那么您就必须四处挖掘,找出使用标准工具的原因,或者向我们展示您的代码,以便我们可以看到可能发生的情况。
人们可以推测,从n位到2n位(例如27到54位或更高),你不仅仅是键空间的两倍,而是指数增长,因为n+1位的键长度意味着一个搜索空间比n位的要大一个数量级。我可以很容易地看出,这可能会使你的记忆力要求更高。

关于linux - 进程被Linux内核杀死?,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/31331796/

10-10 09:20