process gets killed by linux kernel? - linux

Question

I am trying to break the DES algorithms by finding the key of 56 bits using threads, it works fine for key sizes of 27 bit but when it goes higher the process gets killed by linux kernel. I dont understand why? I've used htop to see what is happening it looks like it is using a lot of memory and the swap memory for no reason . I've checked my code again but it seems fine i dont see any memory leaks. Please help me out.
# 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];
}
}

Answer 1

It sounds like your process is being terminated by the Linux OOM-killer, is that what you are saying? If so, then you will have to dig around to find out why using the standard tools, or else show us your code so we can see what might be happening.
One could speculate that in going from n bits to 2n bits (e.g. 27 to 54 bits or higher) you are not merely doubling the keyspace but exponentially increasing it, since n+1 bit key lengths imply a search space an order of magnitude larger than n bit ones. I could quite easily see how that might make your memory demands higher.