int crackMD5(char *hash, char *cs, int passlen) {
clut_device dev; // device struct
cl_event evt; // performance measurement event
cl_kernel kernel; // execution kernel
cl_int ret; // error code
double td;
int cs_len, sync_flag;
long chunk, disp;
unsigned char bin_hash[HASH_SIZE];
cs_len = strlen(cs);
sync_flag = 0;
strToBin(hash, bin_hash, 2*HASH_SIZE);
disp = DISPOSITIONS(cs_len, passlen);
chunk = DISP_PER_CORE(disp, AVAILABLE_THREADS);
debug("HOST", "Numero di disposizione da calcolare per stream processing unit = %lu\n", chunk);
clut_open_device(&dev, PATH_TO_KERNEL);
clut_print_device_info(&dev);
/* ----------------------------------------- Create execution kernel ----------------------------------------- */
kernel = clCreateKernel(dev.program, KERNEL_NAME, &ret);
clut_check_err(ret, "Fallita la creazione del kernel");
/* ----------------------------------- Create memory buffers on the device ----------------------------------- */
cl_mem dchunk = clCreateBuffer(dev.context, CL_MEM_READ_WRITE, sizeof(long), NULL, &ret);
if (ret)
clut_panic(ret, "Fallita l'allocazione della memoria sul device per la memorizzazione del chunk");
cl_mem dhash = clCreateBuffer(dev.context, CL_MEM_READ_ONLY, HASH_SIZE * sizeof(unsigned char), NULL, &ret);
if (ret)
clut_panic(ret, "Fallita l'allocazione della memoria sul device per la memorizzazione dell'hash");
cl_mem charset = clCreateBuffer(dev.context, CL_MEM_READ_ONLY, cs_len * sizeof(char), NULL, &ret);
if (ret)
clut_panic(ret, "Fallita l'allocazione della memoria sul device per la memorizzazione del charset");
cl_mem charset_size = clCreateBuffer(dev.context, CL_MEM_READ_ONLY, sizeof(int), NULL, &ret);
if (ret)
clut_panic(ret, "Fallita l'allocazione della memoria sul device per la memorizzazione della taglia del charset");
cl_mem dpasslen = clCreateBuffer(dev.context, CL_MEM_READ_ONLY, sizeof(int), NULL, &ret);
if (ret)
clut_panic(ret, "Fallita l'allocazione della memoria sul device per la memorizzazione della taglia del charset");
//cl_mem sync = clCreateBuffer(dev.context, CL_MEM_READ_WRITE, AVAILABLE_CORES * sizeof(int), NULL, &ret);
cl_mem sync = clCreateBuffer(dev.context, CL_MEM_READ_WRITE, sizeof(int), NULL, &ret);
if (ret)
clut_panic(ret, "Fallita l'allocazione della memoria sul device per la memorizzazione del flag di sync");
cl_mem dcracked = clCreateBuffer(dev.context, CL_MEM_READ_WRITE, HASH_SIZE, NULL, &ret);
if (ret)
clut_panic(ret, "Fallita l'allocazione della memoria sul device per la memorizzazione della password in chiaro");
cl_mem computed_hash = clCreateBuffer(dev.context, CL_MEM_READ_WRITE, HASH_SIZE * sizeof(unsigned char), NULL, &ret);
if (ret)
clut_panic(ret, "Fallita l'allocazione della memoria sul device per la memorizzazione della password in chiaro");
/* ----------------------------------- Write memory buffers on the device ------------------------------------ */
ret = clEnqueueWriteBuffer(dev.queue, dchunk, CL_TRUE, 0, sizeof(long), &chunk, 0, NULL, NULL);
if(ret)
clut_panic(ret, "Fallita la scrittura del chunk sul buffer di memoria del device");
ret = clEnqueueWriteBuffer(dev.queue, dhash, CL_TRUE, 0, HASH_SIZE * sizeof(unsigned char), (int *)bin_hash, 0, NULL, NULL);
if(ret)
clut_panic(ret, "Fallita la scrittura dell'hash sul buffer di memoria del device");
ret = clEnqueueWriteBuffer(dev.queue, charset, CL_TRUE, 0, cs_len * sizeof(char), cs, 0, NULL, NULL);
if(ret)
clut_panic(ret, "Fallita la scrittura del charset sul buffer di memoria del device");
ret = clEnqueueWriteBuffer(dev.queue, charset_size, CL_TRUE, 0, sizeof(int), &cs_len, 0, NULL, NULL);
if(ret)
clut_panic(ret, "Fallita la scrittura della taglia del charset sul buffer di memoria del device");
ret = clEnqueueWriteBuffer(dev.queue, dpasslen, CL_TRUE, 0, sizeof(int), &passlen, 0, NULL, NULL);
if(ret)
clut_panic(ret, "Fallita la scrittura della taglia del charset sul buffer di memoria del device");
//ret = clEnqueueWriteBuffer(dev.queue, sync, CL_TRUE, 0, AVAILABLE_CORES * sizeof(int), &sync_flag, 0, NULL, NULL);
ret = clEnqueueWriteBuffer(dev.queue, sync, CL_TRUE, 0, sizeof(int), &sync_flag, 0, NULL, NULL);
if(ret)
clut_panic(ret, "Fallita la scrittura della taglia del charset sul buffer di memoria del device");
/* --------------------------------- Set the arguments to our compute kernel --------------------------------- */
ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), &dchunk);
ret |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &dhash);
ret |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &charset);
ret |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &charset_size);
ret |= clSetKernelArg(kernel, 4, sizeof(cl_mem), &dpasslen);
ret |= clSetKernelArg(kernel, 5, sizeof(cl_mem), &sync);
ret |= clSetKernelArg(kernel, 6, sizeof(cl_mem), &dcracked);
ret |= clSetKernelArg(kernel, 7, sizeof(cl_mem), &computed_hash);
clut_check_err(ret, "Fallito il setting degli argomenti del kernel");
/* ---------------------------------------- Execute the OpenCL kernel ---------------------------------------- */
size_t global_dim[] = { AVAILABLE_THREADS };
ret = clEnqueueNDRangeKernel(dev.queue, kernel, 1, NULL, global_dim, NULL, 0, NULL, &evt);
if(ret)
clut_check_err(ret, "Fallita l'esecuzione del kernel");
/* -------------------------- Read the device memory buffer to the local variable ---------------------------- */
//int found[80];
int found;
int digest[HASH_SIZE/sizeof(int)];
char *password = (char *) malloc(passlen * sizeof(char) + 1);
memset(password, 0, passlen * sizeof(char) + 1);
//memset(found, 0, AVAILABLE_CORES * sizeof(int));
//ret = clEnqueueReadBuffer(dev.queue, sync, CL_TRUE, 0, AVAILABLE_CORES * sizeof(int), found, 0, NULL, NULL);
ret = clEnqueueReadBuffer(dev.queue, sync, CL_TRUE, 0, sizeof(int), &found, 0, NULL, NULL);
if(ret)
clut_check_err(ret, "Fallimento nel leggere se la password e' stata trovata con successo");
debug("HOST", "La password e' stata trovata dal kernel OpenCL? ");
/*int i;
for(i=0; i<AVAILABLE_CORES; i++){
printf(" %d ", found[i]);
}
printf("\n");*/
if(found){
ret = clEnqueueReadBuffer(dev.queue, dcracked, CL_TRUE, 0, HASH_SIZE, digest, 0, NULL, NULL);
if(ret)
clut_check_err(ret, "Fallimento nel leggere la password");
printf("Si. Password: %s\n", (char *)digest);
}
else
printf("No.\n");
/* ------------------------------------- Return kernel execution time ---------------------------------------- */
td = clut_get_duration(evt);
debug("HOST","Kernel duration: %f secs\n", td);
/* ----------------------------------------------- Clean up -------------------------------------------------- */
ret = clReleaseKernel(kernel);
ret |= clReleaseMemObject(dchunk);
ret |= clReleaseMemObject(dhash);
ret |= clReleaseMemObject(charset);
ret |= clReleaseMemObject(charset_size);
ret |= clReleaseMemObject(dpasslen);
ret |= clReleaseMemObject(sync);
ret |= clReleaseMemObject(dcracked);
ret |= clReleaseMemObject(computed_hash);
clut_check_err(ret, "Rilascio di risorse fallito");
clFinish(dev.queue);
clut_close_device(&dev);
return 0;
}
void FAT::save() {
string _output = "";
stringstream ss;
//STORE ROOT SECTION
for( int i = 0; i < 512; i++ ){
if( _root[i]._free ){
_output += "0x000000";
}else{
//STORE IF IS FREE
_output += _root[i]._free ? "0x000000" : "0x111111";
_output += ",";
//STORE NAME
string str( _root[i].name );
_output += strToBin(str);
_output += ",";
//STORE IF IS A DIRECTORY
_output += _root[i]._dir ? "0x000010" : "0x000020";
_output += ",";
//STORE CREATION DATE
ss << _root[i]._cDate;
_output += strToBin( ss.str() );
_output += ",";
//STORE CLUSTER
ss.str("");
ss << _root[i]._cluster;
_output += strToBin( ss.str() );
_output += ",";
//STORE SIZE
unsigned int mask = 1 << (sizeof(int)*8-1);
for( int j = 0; j < sizeof(int)*8; j++ ){
if( (_root[i]._size & mask) == 0 )
_output += '0';
else
_output += '1';
mask >>= 1;
}
_output += ",";
//STORE RESERVED
string rese( _root[i].reserved );
_output += strToBin( rese );
}
_output += ";";
}
_output += "$";
//STORE FAT SECTION
for( int i = 0; i < 65535; i++ ){
ss.str("");
ss << _FAT[i];
_output += strToBin( ss.str() );
_output += ",";
}
_output += "$";
for( int i = 0; i < 65535; i++ ){
ss.str("");
ss << _FAT[i];
_output += strToBin( ss.str() );
_output += ",";
}
_output += "$";
//STORE DATA REGION
for( int i = 0; i < 65535; i++ ){
if( _dataRegion[i].entries == NULL && _dataRegion[i].buffer == NULL ){
for( int j = 0; j < 32768; j++ )
_output += "0";
}else if( _dataRegion[i].entries == NULL && _dataRegion[i].buffer != NULL ){
string out( _dataRegion[i].buffer );
_output += out;
}else if( _dataRegion[i].entries != NULL && _dataRegion[i].buffer == NULL ){
for( int j = 0; j < 128; j++ ){
//STORE IF IS FREE
_output += _dataRegion[i].entries[j]._free ? "0x000000" : "0x111111";
_output += ",";
//STORE NAME
string str( _dataRegion[i].entries[j].name );
_output += strToBin(str);
_output += ",";
//STORE IF IS A DIRECTORY
_output += _dataRegion[i].entries[j]._dir ? "0x000010" : "0x000020";
_output += ",";
//STORE CREATION DATE
ss << _dataRegion[i].entries[j]._cDate;
_output += strToBin( ss.str() );
_output += ",";
//STORE CLUSTER
ss.str("");
ss << _dataRegion[i].entries[j]._cluster;
_output += strToBin( ss.str() );
_output += ",";
//STORE SIZE
unsigned int mask = 1 << (sizeof(int)*8-1);
for( int x = 0; x < sizeof(int)*8; x++ ){
if( (_dataRegion[i].entries[j]._size & mask) == 0 )
_output += '0';
else
_output += '1';
mask >>= 1;
}
_output += ",";
//STORE RESERVED
string rese( _dataRegion[i].entries[j].reserved );
_output += strToBin( rese );
if( j < 127 )
_output += "#";
}
}
_output += ";";
}
//WRITE IN FILE
remove("OS.fat");
//ofstream _file;
//_file.open( "OS.fat", ofstream::out );
//_file << _output;
//_file.close();
FILE * pFile;
pFile = fopen ("OS.fat", "wb");
fwrite (_output.c_str() , sizeof(char), 268713984, pFile);
fclose (pFile);
}
