Пароль в 13 символов и XOR

Здравствуйте.

Маюсь с вычислением пароля.

Подскажите плиз, возможно ли:



Алгоритм:

к введенному паролю (adcd) прибавляется константа (1234)

в проге есть защитая константа (скорее всего формируется при создании пароля) длиной 18 байт (ABCD)

Затем идет последовательный xor, т.е.

A xor a, A xor b, ..., A xor 4

B xor a, B xor b, ..., B xor 4

что получается в результете, сравнивается с константой (которая тоже зашита в проге)



Вопрос: возможно ли обойтись без перебора (brute-force), зная что пароль состоит из 13 прописных символов алфавита?

 

как именно прибавляется ? конкретный пример ? Да и вообще код покажи

 

infern0: abcd - строка, к ней прибаляется еще 4 символа = abcd1234.

(кусок из брутфорсера)



...

mov edi, offset szPassword2

mov esi, offset szPassword // тек. пароль

push edi

mov al, byte ptr[esi]



@Start:

mov [edi], al

inc ecx, 1

mov al, byte ptr[esi]

add esi, 1

inc edi

test al, al

jnz @Start



mov dword ptr[edi], $6C713741 // константа

...



p.s. Если есть дельфи, могу приаттачить исходники

 

пароль "passwordconst"

защитная константа "protectconst"

как именно пройдет xor что-бы в итоге получить 4 байта ?

 

infern0: почему 4? Я же написал - 18.

Есть поксоренная строка = 18 знаков.

Есть строка которая должна получиться = 18.

Введенный пароль('abcd') + "A7ql" ($6C713741)

 

Кусок где ксорит:



mov esi, offset BredStr

mov edi, 18 // длина заксореноой

pop ecx // длина пароля

mov ebp, offset szPassword2

xor edx, edx



@L0:

xor eax, eax

test edi, edi

jle @L2



@L1:

mov bl, dl

add bl, byte ptr [edx+ebp]

xor byte ptr [eax+esi], bl

inc eax

cmp eax, edi

jl @L1



@L2:

inc edx

cmp edx, ecx

jl @L0

 

Код (Text):

1.  
2. void xorString(char *BredStr, char *szPassword2)
3. {
4.     int edi = 18;   // strlen(BredStr) ???
5.     int ecx = strlen(szPassword2);
6.  
7.     for (int edx = 0; edx < ecx; +=edx)
8.     {
9.         for (int eax = 0; eax < edi; ++eax)
10.         {
11.             unsigned char bl = edx;
12.             bl += szPassword[edx];
13.             BreadStr[eax] ^= bl;
14.         }
15.     }
16. }
17.  

на входе szPassword2 - это введенный пароль, дополненный некой строкой, BredStr - это другая константная строка ?

и в итоге BredStr сравнивается с некоей третьей строкой, так ?

 

infern0: к сожалению я не силен в си

совершенно верно, BredStr и "некая третья строка" - известные константы.

 

какие символы могут быть в пароле и покажи реальные значения для bredstr, третьей строки и строки дополнения к паролю

и еще - длина пароля известна ? или любой длины может быть ?

 

infern0: длина пароля - 13 символов из прописных букв английского алфавита.



Вот реальные строки:



BredStr: "$D4,$EF,$CD,$EE,$C2,$EA,$B0,$B4,$B2,$B3, $C7,$E8,$CD,$E4,$B7,$B4,$B9,$A0"

Строка, которая должна получиться: "UnLoCk1532FiLe658!"

Дополнение к паролю: "A7ql"

 

13 символов пароля жестко заданы ? Или можно меньше ?

ps: т.е. итоговая строка пароля получается 17 символов ?

 

infern0: 13 символов - жестко. Меньше не знаю, отбрутфорсил до 9 символа(не считая дополнения), совпадений не было (применял только анг. прописные).

p.s. итоговая строка = 17 символов.

 

Сорри, в этих объяснениях и низкоуровневых листингах без контекста я мало что понял.

Верно ли, что

1. К введенному паролю присоединяется строка, результат имеет вид "парольA7ql"

2. Каждый символ строки BredStr ксорится с каждым (т.е. со всеми) символом увеличенного пароля, результат там же в BredStr.

3. Проксоренный бред сравнивается с константой.



?



Если так, то перебирать тут ничего не нужно. Xor - операция аддитивная, так что от пароля остается фактически один байт, равный сумме (xor) всех его символов.



Пароль строится следующим образом

1. s = BredStr xor 'unlock....' (посимвольно)

2. с = s[1] xor ... xor s[18]

3. с = с xor 'A' xor '7' xor 'q' xor 'l'

4. строится строка заданной длины (13 символов), xor-сумма символов которой равна с.

 

в пункте 2 к каждому символу пароля прибавляется его порядковый номер.

Т.е. если я все правильно понял:

Код (Text):

1.  
2. bred[i] ^= (pass[0] + 0) ^ (pass[1] + 1) ^ ... ^ (pass[16] + 16), где i = 0...17
3.  

причем pass[13] ... pass[16] известны.

Алгоритм взаимно обратим. Автор просто взял строку пароля и строку "UnLoCk1532FiLe658!", прогнал через алгоритм и получил "$D4,$EF,$CD,$EE,$C2,$EA,$B0,$B4,$B2,$B3, $C7,$E8,$CD,$E4,$B7,$B4,$B9,$A0"

 

QuickeneR: все верно. Понятное объяснение, но разве построение строки не есть перебор? Попутный вопрос - возможны ли коллизии при построении строки?

 

swn

Так, подожди. Порядковые номера байт увеличенного пароля прибавляются, как выше infern0 написал или нет?

 

QuickeneR: да, infern0 правильно написал

 

Тогда зачем мое описание подтверждать, там же этого нету ?! Ну, народ...



Ok, буду думать дальше

 

сорри, я сам протупил.

 

Не, думать сложно. Лучше все же перебором.



В случае, когда пароль состоит только из больших английских букв, трех символов достаточно, чтобы получить любое возможное значение xor-байта. Соответственно их и перебираем, а остальные 10 заполняем чем попало.

Код (Text):

1.  
2. {$APPTYPE CONSOLE}
3. uses SysUtils;
4. label Found;
5. var
6.   BredStr:string = #$D4#$EF#$CD#$EE#$C2#$EA#$B0#$B4#$B2#$B3#$C7#$E8#$CD#$E4#$B7#$B4#$B9#$ A0;
7.   TestStr:string ='UnLoCk1532FiLe658!';
8.   AddStr:string = 'A7ql';
9.   i:integer;
10.   c:byte; c1,c2,c3:char;
11.   s:string='';
12. begin
13.   c:=byte(BredStr[1]) xor byte(TestStr[1]);
14.   for i:=13 to 16 do c:=c xor (byte(AddStr[i-13+1]) + i);
15.   for i:=0 to 9 do begin
16.     s:=s+'A';
17.     c:=c xor (byte('A')+i);
18.   end;
19.   for c1:='A' to 'Z' do
20.     for c2:='A' to 'Z' do
21.       for c3:='A' to 'Z' do
22.         if (byte(c1) + 10) xor (byte(c2) + 11) xor (byte(c3) + 12) = c then begin
23.           s:=s+c1+c2+c3; goto Found;
24.         end;
25.   writeln('Error'); exit;
26. Found:
27.   writeln('Found password: ',s);
28.   s:=s+AddStr; c:=0; write('Test: ');
29.   for i:=1 to 17 do c:=c xor (byte(s[i]) + i-1);
30.   for i:=1 to 18 do write(char(byte(BredStr[i]) xor c));
31.   writeln;
32. end.
33.