Форум программистов, компьютерный форум, киберфорум
Наши страницы
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Nik-
20 / 20 / 11
Регистрация: 12.07.2015
Сообщений: 343
#1

Задача сравнить хеш с хешами из базы - C++

09.11.2015, 17:38. Просмотров 169. Ответов 0
Метки нет (Все метки)

Cтолкнулся с проблемой, что мне надо хранить хеши файлов в базе, все нормально. Теперь нужно, чтобы хеш, который надо проверить сравнивался с хешами из базы. Вот тут уже проблема. Программа запускается,но не показывает текст, который должна после исполнения команды сканирования. Что надо сделать для работы программы. (Для удобства предоставлю все заг. файлы, чтобы можно было компилировать, а сама проблема в файле scan.h). Спасибо.

Сканнер.cpp

http://www.cyberforum.ru/cpp-beginners/thread456470.html
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include "stdafx.h"
#include "md5.h"
#include "base.h"
#include "scan.h"
#include <iostream>
 
using namespace std;
 
int main()
{
    MD5 md5;//Переменная md5 для ф-ции хеширования
    char* pathToFile = new char[128];//Массив для хранения пути к файлу
 
    cout << "Enter the full path to file: ";
    cin >> pathToFile;//Записываем в массив путь к файлу
    cout << "MD5 of this file is: ";
    puts(md5.digestFile(pathToFile));//MD5 хеш файла
 
    int choise = 0;
    while (cout << "Enter nuumber what you want to do: ", cin >> choise) 
    {
        switch (choise)
        {
            case 1://Добавление в базу MD5 хеша файла
            {
                addToBase(pathToFile);//Ф-ция добавления
                cout << "MD5 is added to base.\n";
                break;
            }
            case 2://Показ содержимого базы
            {
                cout << "Base:\n";
                showTheBase();//Ф-ция показа содержимого
                break;
            }
            case 3://Ф-ция сканирования(не работает)
            {
                scan(pathToFile);
                break;
            }
            default:
                cout << "\nEnter 'add' to add md5 to base" << endl;
        }
    }
        
    system("pause");
    return 0;
}
scan.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#pragma once
#ifndef SCAN_H_INCLUDED
#define SCAN_H_INCLUDED
 
#include <fstream>
#include <iostream>
#include "md5.h"
 
using namespace std;
 
void scan(char* pathToFile) //pathToFile - путь к файлу
{
    MD5 md5;//Для ф-ции хеширования
    //md5.digestFile(pathToFile) - сама ф-ия хеширования(встретится в коде ниже)
    ifstream fprint("BASE.bas");
    int count = 0;
 
    while (!fprint.eof())
    {
        if (fprint.get() == '\n')
            count++; //Подсчет кол-ва строк в файле
    }
 
    char* buffer = new char[count + 1]; //Массив, в который будет записываться текст из файла
 
    while (!fprint.eof())
    {
        fprint.getline(buffer, count);//Записываем содержимое файла в массив по предложению
        if (md5.digestFile(pathToFile) == buffer) //Сравнивание хешей (Не работает)
        {
            cout << "Virusov net\n";
            break;
        }
        //Здесь надо сделать, чтобы если в файле нет такого хеша, то выводилась какая-либо надпись
    }
    fprint.close();//Закрываем файл
}
 
#endif

base.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#pragma once
#ifndef BASE_H_INCLUDED
#define BASE_H_INCLUDED
 
#include <iostream>
#include <fstream>
#include <string.h>
 
using namespace std;
 
void addToBase(char* pathToFile)//Ф-ция добавления в базу MD5 хеша файла
{
    MD5 md5;
    ofstream fout;//Поток записи в файл
    fout.open("BASE.bas", ios_base::app);//Открываем файл для записи в конец
 
    if (!(fout.is_open()))//Проверка на открытие
        cerr << "can't open file!";
 
    fout << md5.digestFile(pathToFile);//Записываем в базу MD5 хеш файла
    fout << endl;//Переходим на новою строку в файле
    fout.close();//Закрываем файл
}
 
void showTheBase()//Ф-ция показа базы
{
    ifstream fprint("BASE.bas");//Поток открытия файла для чтения 
    int count = 0;//Кол-во символов в файле
 
    while (fprint.get() != EOF) ++count;//Подсчитываем кол-во символов в файле
    char *buffer = new char[count];//Создаем динам. массив для записи содерж. файла в него
 
    fprint.clear();//Очищаем файл от ошибок после работы с ним
    fprint.seekg(0);//Ставим указатель в начало файла 
    fprint.get(buffer, count, '\0');//Записываем содержимое файла в массив
    fprint.close();//Закрываем файл
    cout << buffer << endl; //Выводим текст файла
    delete[]buffer;//Очищаем заполненный массив
}
#endif
md5.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
#pragma once
#ifndef MD5_H_INCLUDED
#define MD5_H_INCLUDED
 
 
#include <stdio.h>
#include <string.h>
 
#pragma region MD5 defines
// Constants for MD5Transform routine.
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
 
 
 
 
 
 
static unsigned char PADDING[64] = {
    0x80, 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
};
 
// F, G, H and I are basic MD5 functions.
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
 
// ROTATE_LEFT rotates x left n bits.
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
 
// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
// Rotation is separate from addition to prevent recomputation.
#define FF(a, b, c, d, x, s, ac) { \
  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
  (a) = ROTATE_LEFT ((a), (s)); \
  (a) += (b); \
  }
#define GG(a, b, c, d, x, s, ac) { \
  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
  (a) = ROTATE_LEFT ((a), (s)); \
  (a) += (b); \
  }
#define HH(a, b, c, d, x, s, ac) { \
  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
  (a) = ROTATE_LEFT ((a), (s)); \
  (a) += (b); \
  }
#define II(a, b, c, d, x, s, ac) { \
  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
  (a) = ROTATE_LEFT ((a), (s)); \
  (a) += (b); \
  }
#pragma endregion
 
typedef unsigned char BYTE;
 
// POINTER defines a generic pointer type
typedef unsigned char *POINTER;
 
// UINT2 defines a two byte word
typedef unsigned short int UINT2;
 
// UINT4 defines a four byte word
typedef unsigned long int UINT4;
 
 
// convenient object that wraps
// the C-functions for use in C++ only
class MD5
{
private:
    struct __context_t {
        UINT4 state[4];                                   /* state (ABCD) */
        UINT4 count[2];        /* number of bits, modulo 2^64 (lsb first) */
        unsigned char buffer[64];                         /* input buffer */
    } context;
 
#pragma region static helper functions
    // The core of the MD5 algorithm is here.
    // MD5 basic transformation. Transforms state based on block.
    static void MD5Transform(UINT4 state[4], unsigned char block[64])
    {
        UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 
        Decode(x, block, 64);
 
        /* Round 1 */
        FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
        FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
        FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */
        FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
        FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
        FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
        FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
        FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
        FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
        FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
        FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
        FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
        FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
        FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
        FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
        FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 
                                                /* Round 2 */
        GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
        GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
        GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
        GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
        GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
        GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
        GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
        GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
        GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
        GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
        GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
        GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
        GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
        GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
        GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
        GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 
                                                /* Round 3 */
        HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
        HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
        HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
        HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
        HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
        HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
        HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
        HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
        HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
        HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
        HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
        HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */
        HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
        HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
        HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
        HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */
 
                                               /* Round 4 */
        II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
        II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
        II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
        II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
        II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
        II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
        II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
        II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
        II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
        II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
        II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
        II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
        II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
        II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
        II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
        II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */
 
        state[0] += a;
        state[1] += b;
        state[2] += c;
        state[3] += d;
 
        // Zeroize sensitive information.
        memset((POINTER)x, 0, sizeof(x));
    }
 
    // Encodes input (UINT4) into output (unsigned char). Assumes len is
    // a multiple of 4.
    static void Encode(unsigned char *output, UINT4 *input, unsigned int len)
    {
        unsigned int i, j;
 
        for (i = 0, j = 0; j < len; i++, j += 4) {
            output[j] = (unsigned char)(input[i] & 0xff);
            output[j + 1] = (unsigned char)((input[i] >> 8) & 0xff);
            output[j + 2] = (unsigned char)((input[i] >> 16) & 0xff);
            output[j + 3] = (unsigned char)((input[i] >> 24) & 0xff);
        }
    }
 
    // Decodes input (unsigned char) into output (UINT4). Assumes len is
    // a multiple of 4.
    static void Decode(UINT4 *output, unsigned char *input, unsigned int len)
    {
        unsigned int i, j;
 
        for (i = 0, j = 0; j < len; i++, j += 4)
            output[i] = ((UINT4)input[j]) | (((UINT4)input[j + 1]) << 8) |
            (((UINT4)input[j + 2]) << 16) | (((UINT4)input[j + 3]) << 24);
    }
#pragma endregion
 
 
public:
    // MAIN FUNCTIONS
    MD5()
    {
        Init();
    }
 
    // MD5 initialization. Begins an MD5 operation, writing a new context.
    void Init()
    {
        context.count[0] = context.count[1] = 0;
 
        // Load magic initialization constants.
        context.state[0] = 0x67452301;
        context.state[1] = 0xefcdab89;
        context.state[2] = 0x98badcfe;
        context.state[3] = 0x10325476;
    }
 
    // MD5 block update operation. Continues an MD5 message-digest
    // operation, processing another message block, and updating the
    // context.
    void Update(
        unsigned char *input,   // input block
        unsigned int inputLen) // length of input block
    {
        unsigned int i, index, partLen;
 
        // Compute number of bytes mod 64
        index = (unsigned int)((context.count[0] >> 3) & 0x3F);
 
        // Update number of bits
        if ((context.count[0] += ((UINT4)inputLen << 3))
            < ((UINT4)inputLen << 3))
            context.count[1]++;
        context.count[1] += ((UINT4)inputLen >> 29);
 
        partLen = 64 - index;
 
        // Transform as many times as possible.
        if (inputLen >= partLen) {
            memcpy((POINTER)&context.buffer[index], (POINTER)input, partLen);
            MD5Transform(context.state, context.buffer);
 
            for (i = partLen; i + 63 < inputLen; i += 64)
                MD5Transform(context.state, &input[i]);
 
            index = 0;
        }
        else
            i = 0;
 
        /* Buffer remaining input */
        memcpy((POINTER)&context.buffer[index], (POINTER)&input[i], inputLen - i);
    }
 
    // MD5 finalization. Ends an MD5 message-digest operation, writing the
    // the message digest and zeroizing the context.
    // Writes to digestRaw
    void Final()
    {
        unsigned char bits[8];
        unsigned int index, padLen;
 
        // Save number of bits
        Encode(bits, context.count, 8);
 
        // Pad out to 56 mod 64.
        index = (unsigned int)((context.count[0] >> 3) & 0x3f);
        padLen = (index < 56) ? (56 - index) : (120 - index);
        Update(PADDING, padLen);
 
        // Append length (before padding)
        Update(bits, 8);
 
        // Store state in digest
        Encode(digestRaw, context.state, 16);
 
        // Zeroize sensitive information.
        memset((POINTER)&context, 0, sizeof(context));
 
        writeToString();
    }
 
    /// Buffer must be 32+1 (nul) = 33 chars long at least
    void writeToString()
    {
        int pos;
 
        for (pos = 0; pos < 16; pos++)
            sprintf(digestChars + (pos * 2), "%02x", digestRaw[pos]);
    }
 
 
public:
    // an MD5 digest is a 16-byte number (32 hex digits)
    BYTE digestRaw[16];
 
    // This version of the digest is actually
    // a "printf'd" version of the digest.
    char digestChars[33];
 
    /// Load a file from disk and digest it
    // Digests a file and returns the result.
    char* digestFile(char *filename)
    {
        Init();
 
        FILE *file;
 
        int len;
        unsigned char buffer[1024];
 
        if ((file = fopen(filename, "rb")) == NULL)
            printf("%s can't be opened\n", filename);
        else
        {
            while (len = fread(buffer, 1, 1024, file))
                Update(buffer, len);
            Final();
 
            fclose(file);
        }
 
        return digestChars;
    }
 
    /// Digests a byte-array already in memory
    char* digestMemory(BYTE *memchunk, int len)
    {
        Init();
        Update(memchunk, len);
        Final();
 
        return digestChars;
    }
 
    // Digests a string and prints the result.
    char* digestString(char *string)
    {
        Init();
        Update((unsigned char*)string, strlen(string));
        Final();
 
        return digestChars;
    }
};
 
 
#endif // MD5_H_INCLUDED
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
09.11.2015, 17:38
Я подобрал для вас темы с готовыми решениями и ответами на вопрос Задача сравнить хеш с хешами из базы (C++):

Сравнить несколько продуктов из базы данных, сложить их калорийность и вывести общую сумму
Помогите пожалуйста с ошибкой#include &quot;stdafx.h&quot; #include &lt;iostream&gt; #include...

Задача на обработку символьных строк (сравнить введённую строку с шаблоном)
Здравствуйте. Задача на обработку последовательности символов такая: Программа...

Задача на обработку символьных данных (сравнить строку введенным с клавиатуры, и вывести результат сравнение
Здравствуйте. Задача на обработку символьных данных такая: Сравнить...

Хеш базы данных
Как средствами Qt получить хеш всей базы данных? Интересует возможность...

Вытащить хеш пароля из базы для проверки
Есть таблица 'users': id, email, password. Есть логин форма email, password....

0
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
09.11.2015, 17:38
Привет! Вот еще темы с решениями:

Математические операции с хешами ? в чем можно их произвести ?
Суть вот в чем подскажите программу которая способна умножить поделить сложить...

Как сравнить переменную со строкой базы данных или как присвоить переменной значение строки базы данных ?
подскажите пожалуйста как мне сравнить переменную типа string с каким нибудь...

Сравнить 2 даты из базы
Доброго времени суток нужно сравнить 2 даты и базы данных и если одна больше...

Для формирования хеш-адреса использовать хеш-функцию универсального хеширования
Для формирования хеш-адреса использовать хеш-функцию универсального хеширования...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
1
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2018, vBulletin Solutions, Inc.
Рейтинг@Mail.ru