Как поместить алгоритм, призванное на бумаге в рабочий код C? ⇐ Python

[Anonymous]

Я пытаюсь улучшить атаку на pkzip , минимизируя рабочую нагрузку и требования, поэтому Pkzip использует это:

Код: Выделить всё

key0[i] = key0[i-1]>>8 ^ crctab[key0[i-1]&0xFF ^ plaintext[i]];
key1[i] = (key1[i-1] + (key0[i]&0xFF))* Const + 1;
key2[i] = key2[i-1]>>8 ^ crctab[key2[i-1]&0xFF ^ (key1[i]>>24)];
< /code>
обновить свой клавиш или внутреннее состояние и это: < /p>
tmp = (key2[i] |3)&0xFFFF; // notice: makes the last 16 bits of key2 odd
key3[i] = ((tmp*(tmp ^ 1))>>8)&0xFF;//notice: this is ((x**2)-x)//256 mod 256 or (x*(x + or - 1))//256 mod 256
ciphertext[i] = plaintext[i] ^ key3[i];

, чтобы вывести байт-ключ3 и шифровать открытый текст в Ciphertext, но такие программы, как Pkcrak 22 Возможные значения Key2 для позиции I, что слишком много, поэтому я обнаружил это:
Учитывает 3 последовательных значения открытого текста и шифровый текст, мы можем получить 3 последовательного ключа3 Значения и каждая ключа3 значение имеет 256 возможных последних 16-битных значений, что слишком много, если только соединение между 16-битным значением для ключа3 и key3 [i-1 ] не является найдено. < /p>
Следовательно: < /p>
import math
n= int(65536)

x = 0xc90b #this is key2[i-1] |3
y = 0x2f17# this is key2 | 3

a = ((x*x) - x) % n # we havent divided this by 256 for simplicity
b = ((y*y) - y) % n # so the result of a ^ b is 16 bit or simply (e
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define CRCPOLY 0xedb88320
#define CONSTx 0x08088405U /* 134775813 */
#define MSB(x) (((x)>>24)&0xFF)
#define MSBMASK 0xFF000000U
#define CRC32(x,c) (((x)>>8)^crctab[((x)^(c))&0xff])

uint32_t crctab[256];
int numKey2s = 0;

const uint8_t plain[8]= {
0x64, 0x14, 0x9A, 0xC7, 0xB2, 0x96, 0xC0, 0x15
};
uint8_t cipher[8]= {

};

uint8_t key3[8]= {

};

uint32_t k0 = 0x12345678,t0;
uint32_t k1 = 0x23456789,t1;
uint32_t k2 = 0x34567890,t2;

static void mkCrcTab( ){
unsigned int i, j, c;
for( i = 0; i < 256; i++ )
{
c = i;
for( j = 0; j < 8; j++ )
if( c&1 )
c = (c>>1) ^ CRCPOLY;
else
c = (c>>1);
crctab = c;
}
}

int main(){

mkCrcTab( );

uint8_t pw[10] = {
0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x00
};

uint32_t ky0 = k0; // FNV offset basis for 32-bit
uint32_t ky1 = k1; // FNV prime for 32-bit
uint32_t ky2 = k2;
uint16_t tmp;
uint8_t bt;

for (int i = 0; i < 10; i++) {
ky0 = CRC32( ky0, pw );
ky1 = (k1 + (ky0&0xff))*CONSTx + 1;
ky2 = CRC32( ky2, MSB(ky1) );
printf("%08X %08X %08X\n",ky0,ky1,ky2);
}
t0 =ky0;
t1 = ky1;
t2 = ky2;
printf("===================================\n");
for (int i = 0; i < 8; i++) {
ky0 = CRC32( ky0, plain );
ky1 = (k1 + (ky0&0xff))*CONSTx + 1;
ky2 = CRC32( ky2, MSB(ky1) );
printf("%08X %08X %08X\n",ky0,ky1,ky2);
tmp = ky2 | 3;
bt = ((tmp*(tmp ^ 1))>>8)&0xFF;
cipher = plain ^ bt;
key3 = bt;
}
printf("===================================\n");
printf("plain : ");
for(int i =0; i
< /blockquote>
, чтобы протестировать мою теорию, но когда я использовал код ниже, чтобы увидеть, находится ли значение Key2, которое я нашел, используя вышеуказанный код для позиции 4 внутри списка. Сгенерировано алгоритмом, я не получаю его правильного значения, и теперь я смущен, является ли это моим кодированием или самого алгоритма ошибочна или неверно истолкован. : < /p>
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define CRCPOLY 0xedb88320
#define CONSTx 0x08088405U /* 134775813 */
#define KEY2SPACE (124)&0xFF)
#define MAXDELTA (0x00FFFFFFU+0xFFU)
#define MSBMASK 0xFF000000U
#define CRC32(x,c) (((x)>>8)^crctab[((x)^(c))&0xff])

uint32_t crctab[256],crcbymsb[256],crcbylsb[256];
uint32_t *key2i;
uint16_t tmptaba[256],tmptabb[256],tmptabc[256],lkpc[65536],lkpa[65536];
uint8_t idxbylsb[256], idxbymsb[256];

const uint8_t plain[8]= {
0x64, 0x14, 0x9A, 0xC7, 0xB2, 0x96, 0xC0, 0x15
};
const uint8_t cipher[8]= {
0xEF, 0x20, 0xDC, 0x4C, 0x11, 0x9A, 0x78, 0xEB

};

static void mkCrcTab( ){
unsigned int i, j, c;
for( i = 0; i < 256; i++ )
{
c = i;
for( j = 0; j < 8; j++ )
if( c&1 )
c = (c>>1) ^ CRCPOLY;
else
c = (c>>1);
crctab = c;
crcbymsb[c>>24] = c;
crcbylsb[c&0xFF] = c;
idxbymsb[c>>24] = i;
idxbylsb[c&0xFF] = i;
}
}

void generate( int n ){
int i,j, d;
uint8_t e, ea;
uint32_t cr[4],cr1[4];
uint16_t ls16a,ls16b,ls16c,eq,eq1;
printf("Generating possible key2_%d values...", n );
ea = KEY3(n-1) ^ KEY3(n);
e = KEY3(n-2) ^ KEY3(n-1);
for( i = 3; i < 256; i+=4 ){
ls16b = tmptabb;
eq = (int) sqrt( (double) ((256*ea) ^ (ls16b*(ls16b ^ 1))&0xFFFF));
ls16c = lkpc[eq];
cr[0] = crcbylsb[(ls16b>>8) ^ (ls16c&0xFF)];
cr[1] = crcbylsb[(ls16b>>8) ^ ((ls16c-1)&0xFF)];
cr[2] = crcbylsb[(ls16b>>8) ^ ((ls16c-2)&0xFF)];
cr[3] = crcbylsb[(ls16b>>8) ^ ((ls16c-3)&0xFF)];
eq1 = (int) sqrt( (double) ((256*e) ^ (ls16b*(ls16b ^ 1))&0xFFFF));
ls16a = lkpa[eq1];
cr1[0] = crcbylsb[(ls16a>>8) ^ (ls16b&0xFF)];
cr1[1] = crcbylsb[(ls16a>>8) ^ ((ls16b-1)&0xFF)];
cr1[2] = crcbylsb[(ls16a>>8) ^ ((ls16b-2)&0xFF)];
cr1[3] = crcbylsb[(ls16a>>8) ^ ((ls16b-3)&0xFF)];
for(j=0; j >8) ^ cr[d])&0xFFFF0000) | (ls16c-d);
}
}

}

printf("done.\nFound %d possible key2-values.\n", numKey2s );
}

int main(){
uint16_t kt,bk,idx;
uint8_t dt;
int x=0, y=0, z=0;

key2i = malloc(KEY2SPACE * sizeof(uint32_t));
if (!key2i) {
perror("Memory allocation failed");
exit(EXIT_FAILURE);
}
//load tmptabb
for(uint16_t i=0; i < 0xFFFF; i++){
kt = i | 3;
dt = ((kt*(kt ^ 1))>>8)&0xFF;
if(dt == KEY3(2)){
tmptabb[y++] = i;
}
if(dt == KEY3(3)){
tmptabc[z++] = i;
}
if(dt == KEY3(1)){
tmptaba[x++] = i;
}
}
//load lookup tables
for(int k =3; k < 256; k+=4){
bk = tmptaba[k];
idx = (int) sqrt( (bk*(bk ^ 1))&0xFFFF);
lkpa[idx] = bk;
bk = tmptabc[k];
idx = (int) sqrt( (bk*(bk ^ 1))&0xFFFF);
lkpc[idx] = bk;
}
mkCrcTab();
generate(3);
for(int w =0; w < numKey2s; w++){
printf("%08X\n", key2i[w]);
}
}
< /code>
Я не знаю, где я пошел не так, и теперь я не могу продолжить свое исследование о поиске математических отношений между Key2 и Key0 из -за этого. < /p>
< P> Спасибо.

Подробнее здесь: https://stackoverflow.com/questions/794 ... ing-c-code