|
String im Exe-Text verschlüsseln
Hi,
wie kann man bei so einem fall
Code:
das wort 'geheimes Passwort' im Exe-Quelltext verbergen/unsichtbar machen?
if Edit1.Text = 'geheimes Passwort' then TuIrgendwas()
|
Re: String im Exe-Text verschlüsseln
Hatten wir gerade. Resultat der Diskussion: geht nicht vernünftig und sicher.
|
Re: String im Exe-Text verschlüsseln
Zitat:
Wenns allerdings um eine Rückentschlüsselung geht, geb ich natürlich Luckie vollkommen Recht. Hatte bzw. habe nämlich auch genau das Problem in einem Programm bei mir. Aus über den Umweg von Public/Private Keys gibts da keine vernünftige Lösung. Gruß, Tom |
Re: String im Exe-Text verschlüsseln
Dann mache ich die Exe mit einem HexEditor auf und sehe den Hash-Wert. :roll:
|
Re: String im Exe-Text verschlüsseln
Zitat:
Ich mein, was fängst du mit den Hash Wert alleine an. Was du ntürlich machen kannst, ist aus einem if edit1.text = 'hashwert'... ein if edit1.text <> 'hashwert' then... Ein sehr beliebtes Spiel um Programme zu hacken :wink: Gruß, Tom |
Re: String im Exe-Text verschlüsseln
Delphi-Quellcode:
Sollte schon etwas schwerer dann in der exe zusammen zu suchen sein
function getmypassword:String;
var v1: Array [1..17] of Char; LCount: Integer; begin v1[1] := 'g'; v1[2] := 'e'; v1[3] := 'h'; v1[4] := 'e'; v1[5] := 'i'; v1[6] := 'm'; [...] result := ''; for LCount := 1 to 17 do result := result + v1[LCount]; end; [...] if Edit1.Text = getmypassword then TuIrgendwas(); Wenn du sicher gehen willst das es nicht so einfach zu hacken ist mach noch paar routinen rein die während des auführens prüfen ob die exe noch orginal ist (checksummenwert) |
Re: String im Exe-Text verschlüsseln
Liste der Anhänge anzeigen (Anzahl: 1)
Hallo Leute,
ich bin auch noch nicht von Luckie's Meinung so ganz überzeugt. Irgendwie läßt sich mit Sicherheit jedes Passwort knacken, aber selbst das sollte mit einem vertretbaren Aufwand machbar sein. Das geheime Passwort soll ja wohl bloß nicht gleich sichtbar sein, wenn man sich mit einem Hex-Editor die EXE anschaut. Natürlich könnte mich Luckie (oder jemand anders, der sich damit auskennt,) überzeugen, wenn hier morgen das richtige Passwort steht. Hoffentlich bin ich dann nicht allzu sehr deprimiert :stupid: Anbei die erforderliche EXE-Datei. mfg eddy |
Re: String im Exe-Text verschlüsseln
Code:
Leider sind meine Assembler Kenntnisse mehr als begrenzt. Aber das ist die Button-Click Routine. Jemand der etwas mehr von Assembler versteht, sollte das mühelos knacken können. ;)
00445110 55 push ebp
00445111 8BEC mov ebp, esp 00445113 B90B000000 mov ecx, $0000000B 00445118 6A00 push $00 0044511A 6A00 push $00 0044511C 49 dec ecx 0044511D 75F9 jnz 00445118 0044511F 53 push ebx 00445120 8BD8 mov ebx, eax 00445122 33C0 xor eax, eax 00445124 55 push ebp * Possible String Reference to: 'éAÝûÿë´[‹å]Ã' | 00445125 6886564400 push $00445686 ***** TRY | 0044512A 64FF30 push dword ptr fs:[eax] 0044512D 648920 mov fs:[eax], esp 00445130 8D45EC lea eax, [ebp-$14] 00445133 BA07000000 mov edx, $00000007 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 00445138 B99C564400 mov ecx, $0044569C 0044513D 4A dec edx 0044513E 3B51FC cmp edx, [ecx-$04] 00445141 7205 jb 00445148 * Reference to: System.Proc_00402C04 | 00445143 E8BCDAFBFF call 00402C04 00445148 42 inc edx 00445149 8A5411FF mov dl, byte ptr [ecx+edx-$01] 0044514D 885001 mov [eax+$01], dl 00445150 C60001 mov byte ptr [eax], $01 00445153 8D55EC lea edx, [ebp-$14] 00445156 8D45E8 lea eax, [ebp-$18] * Reference to: System.Proc_00402894 | 00445159 E836D7FBFF call 00402894 0044515E 8D45E4 lea eax, [ebp-$1C] 00445161 BA05000000 mov edx, $00000005 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 00445166 B99C564400 mov ecx, $0044569C 0044516B 4A dec edx 0044516C 3B51FC cmp edx, [ecx-$04] 0044516F 7205 jb 00445176 * Reference to: System.Proc_00402C04 | 00445171 E88EDAFBFF call 00402C04 00445176 42 inc edx 00445177 8A5411FF mov dl, byte ptr [ecx+edx-$01] 0044517B 885001 mov [eax+$01], dl 0044517E C60001 mov byte ptr [eax], $01 00445181 8D55E4 lea edx, [ebp-$1C] 00445184 8D45E8 lea eax, [ebp-$18] 00445187 B102 mov cl, $02 * Reference to: System.Proc_00402864 | 00445189 E8D6D6FBFF call 00402864 0044518E 8D55E8 lea edx, [ebp-$18] 00445191 8D45E0 lea eax, [ebp-$20] * Reference to: System.Proc_00402894 | 00445194 E8FBD6FBFF call 00402894 00445199 8D45E4 lea eax, [ebp-$1C] 0044519C BA08000000 mov edx, $00000008 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 004451A1 B99C564400 mov ecx, $0044569C 004451A6 4A dec edx 004451A7 3B51FC cmp edx, [ecx-$04] 004451AA 7205 jb 004451B1 * Reference to: System.Proc_00402C04 | 004451AC E853DAFBFF call 00402C04 004451B1 42 inc edx 004451B2 8A5411FF mov dl, byte ptr [ecx+edx-$01] 004451B6 885001 mov [eax+$01], dl 004451B9 C60001 mov byte ptr [eax], $01 004451BC 8D55E4 lea edx, [ebp-$1C] 004451BF 8D45E0 lea eax, [ebp-$20] 004451C2 B103 mov cl, $03 * Reference to: System.Proc_00402864 | 004451C4 E89BD6FBFF call 00402864 004451C9 8D55E0 lea edx, [ebp-$20] 004451CC 8D45D8 lea eax, [ebp-$28] * Reference to: System.Proc_00402894 | 004451CF E8C0D6FBFF call 00402894 004451D4 8D45E4 lea eax, [ebp-$1C] 004451D7 BA14000000 mov edx, $00000014 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 004451DC B99C564400 mov ecx, $0044569C 004451E1 4A dec edx 004451E2 3B51FC cmp edx, [ecx-$04] 004451E5 7205 jb 004451EC * Reference to: System.Proc_00402C04 | 004451E7 E818DAFBFF call 00402C04 004451EC 42 inc edx 004451ED 8A5411FF mov dl, byte ptr [ecx+edx-$01] 004451F1 885001 mov [eax+$01], dl 004451F4 C60001 mov byte ptr [eax], $01 004451F7 8D55E4 lea edx, [ebp-$1C] 004451FA 8D45D8 lea eax, [ebp-$28] 004451FD B104 mov cl, $04 * Reference to: System.Proc_00402864 | 004451FF E860D6FBFF call 00402864 00445204 8D55D8 lea edx, [ebp-$28] 00445207 8D45F8 lea eax, [ebp-$08] * Reference to: System.Proc_00403B58 | 0044520A E849E9FBFF call 00403B58 0044520F 8D45EC lea eax, [ebp-$14] 00445212 BA07000000 mov edx, $00000007 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 00445217 B99C564400 mov ecx, $0044569C 0044521C 4A dec edx 0044521D 3B51FC cmp edx, [ecx-$04] 00445220 7205 jb 00445227 * Reference to: System.Proc_00402C04 | 00445222 E8DDD9FBFF call 00402C04 00445227 42 inc edx 00445228 8A5411FF mov dl, byte ptr [ecx+edx-$01] 0044522C 885001 mov [eax+$01], dl 0044522F C60001 mov byte ptr [eax], $01 00445232 8D55EC lea edx, [ebp-$14] 00445235 8D45E8 lea eax, [ebp-$18] * Reference to: System.Proc_00402894 | 00445238 E857D6FBFF call 00402894 0044523D 8D45E4 lea eax, [ebp-$1C] 00445240 BA09000000 mov edx, $00000009 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 00445245 B99C564400 mov ecx, $0044569C 0044524A 4A dec edx 0044524B 3B51FC cmp edx, [ecx-$04] 0044524E 7205 jb 00445255 * Reference to: System.Proc_00402C04 | 00445250 E8AFD9FBFF call 00402C04 00445255 42 inc edx 00445256 8A5411FF mov dl, byte ptr [ecx+edx-$01] 0044525A 885001 mov [eax+$01], dl 0044525D C60001 mov byte ptr [eax], $01 00445260 8D55E4 lea edx, [ebp-$1C] 00445263 8D45E8 lea eax, [ebp-$18] 00445266 B102 mov cl, $02 * Reference to: System.Proc_00402864 | 00445268 E8F7D5FBFF call 00402864 0044526D 8D55E8 lea edx, [ebp-$18] 00445270 8D45E0 lea eax, [ebp-$20] * Reference to: System.Proc_00402894 | 00445273 E81CD6FBFF call 00402894 00445278 8D45E4 lea eax, [ebp-$1C] 0044527B BA02000000 mov edx, $00000002 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 00445280 B99C564400 mov ecx, $0044569C 00445285 4A dec edx 00445286 3B51FC cmp edx, [ecx-$04] 00445289 7205 jb 00445290 * Reference to: System.Proc_00402C04 | 0044528B E874D9FBFF call 00402C04 00445290 42 inc edx 00445291 8A5411FF mov dl, byte ptr [ecx+edx-$01] 00445295 885001 mov [eax+$01], dl 00445298 C60001 mov byte ptr [eax], $01 0044529B 8D55E4 lea edx, [ebp-$1C] 0044529E 8D45E0 lea eax, [ebp-$20] 004452A1 B103 mov cl, $03 * Reference to: System.Proc_00402864 | 004452A3 E8BCD5FBFF call 00402864 004452A8 8D55E0 lea edx, [ebp-$20] 004452AB 8D45D8 lea eax, [ebp-$28] * Reference to: System.Proc_00402894 | 004452AE E8E1D5FBFF call 00402894 004452B3 8D45E4 lea eax, [ebp-$1C] 004452B6 BA14000000 mov edx, $00000014 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 004452BB B99C564400 mov ecx, $0044569C 004452C0 4A dec edx 004452C1 3B51FC cmp edx, [ecx-$04] 004452C4 7205 jb 004452CB * Reference to: System.Proc_00402C04 | 004452C6 E839D9FBFF call 00402C04 004452CB 42 inc edx 004452CC 8A5411FF mov dl, byte ptr [ecx+edx-$01] 004452D0 885001 mov [eax+$01], dl 004452D3 C60001 mov byte ptr [eax], $01 004452D6 8D55E4 lea edx, [ebp-$1C] 004452D9 8D45D8 lea eax, [ebp-$28] 004452DC B104 mov cl, $04 * Reference to: System.Proc_00402864 | 004452DE E881D5FBFF call 00402864 004452E3 8D55D8 lea edx, [ebp-$28] 004452E6 8D45F4 lea eax, [ebp-$0C] * Reference to: System.Proc_00403B58 | 004452E9 E86AE8FBFF call 00403B58 004452EE 8D45EC lea eax, [ebp-$14] 004452F1 BA0E000000 mov edx, $0000000E * Possible String Reference to: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' | 004452F6 B9C0564400 mov ecx, $004456C0 004452FB 4A dec edx 004452FC 3B51FC cmp edx, [ecx-$04] 004452FF 7205 jb 00445306 * Reference to: System.Proc_00402C04 | 00445301 E8FED8FBFF call 00402C04 00445306 42 inc edx 00445307 8A5411FF mov dl, byte ptr [ecx+edx-$01] 0044530B 885001 mov [eax+$01], dl 0044530E C60001 mov byte ptr [eax], $01 00445311 8D55EC lea edx, [ebp-$14] 00445314 8D45E8 lea eax, [ebp-$18] * Reference to: System.Proc_00402894 | 00445317 E878D5FBFF call 00402894 0044531C 8D45E4 lea eax, [ebp-$1C] 0044531F BA09000000 mov edx, $00000009 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 00445324 B99C564400 mov ecx, $0044569C 00445329 4A dec edx 0044532A 3B51FC cmp edx, [ecx-$04] 0044532D 7205 jb 00445334 * Reference to: System.Proc_00402C04 | 0044532F E8D0D8FBFF call 00402C04 00445334 42 inc edx 00445335 8A5411FF mov dl, byte ptr [ecx+edx-$01] 00445339 885001 mov [eax+$01], dl 0044533C C60001 mov byte ptr [eax], $01 0044533F 8D55E4 lea edx, [ebp-$1C] 00445342 8D45E8 lea eax, [ebp-$18] 00445345 B102 mov cl, $02 * Reference to: System.Proc_00402864 | 00445347 E818D5FBFF call 00402864 0044534C 8D55E8 lea edx, [ebp-$18] 0044534F 8D45E0 lea eax, [ebp-$20] * Reference to: System.Proc_00402894 | 00445352 E83DD5FBFF call 00402894 00445357 8D45E4 lea eax, [ebp-$1C] 0044535A BA03000000 mov edx, $00000003 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 0044535F B99C564400 mov ecx, $0044569C 00445364 4A dec edx 00445365 3B51FC cmp edx, [ecx-$04] 00445368 7205 jb 0044536F * Reference to: System.Proc_00402C04 | 0044536A E895D8FBFF call 00402C04 0044536F 42 inc edx 00445370 8A5411FF mov dl, byte ptr [ecx+edx-$01] 00445374 885001 mov [eax+$01], dl 00445377 C60001 mov byte ptr [eax], $01 0044537A 8D55E4 lea edx, [ebp-$1C] 0044537D 8D45E0 lea eax, [ebp-$20] 00445380 B103 mov cl, $03 * Reference to: System.Proc_00402864 | 00445382 E8DDD4FBFF call 00402864 00445387 8D55E0 lea edx, [ebp-$20] 0044538A 8D45D8 lea eax, [ebp-$28] * Reference to: System.Proc_00402894 | 0044538D E802D5FBFF call 00402894 00445392 8D45E4 lea eax, [ebp-$1C] 00445395 BA08000000 mov edx, $00000008 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 0044539A B99C564400 mov ecx, $0044569C 0044539F 4A dec edx 004453A0 3B51FC cmp edx, [ecx-$04] 004453A3 7205 jb 004453AA * Reference to: System.Proc_00402C04 | 004453A5 E85AD8FBFF call 00402C04 004453AA 42 inc edx 004453AB 8A5411FF mov dl, byte ptr [ecx+edx-$01] 004453AF 885001 mov [eax+$01], dl 004453B2 C60001 mov byte ptr [eax], $01 004453B5 8D55E4 lea edx, [ebp-$1C] 004453B8 8D45D8 lea eax, [ebp-$28] 004453BB B104 mov cl, $04 * Reference to: System.Proc_00402864 | 004453BD E8A2D4FBFF call 00402864 004453C2 8D55D8 lea edx, [ebp-$28] 004453C5 8D45D0 lea eax, [ebp-$30] * Reference to: System.Proc_00402894 | 004453C8 E8C7D4FBFF call 00402894 004453CD 8D45E4 lea eax, [ebp-$1C] 004453D0 BA14000000 mov edx, $00000014 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 004453D5 B99C564400 mov ecx, $0044569C 004453DA 4A dec edx 004453DB 3B51FC cmp edx, [ecx-$04] 004453DE 7205 jb 004453E5 * Reference to: System.Proc_00402C04 | 004453E0 E81FD8FBFF call 00402C04 004453E5 42 inc edx 004453E6 8A5411FF mov dl, byte ptr [ecx+edx-$01] 004453EA 885001 mov [eax+$01], dl 004453ED C60001 mov byte ptr [eax], $01 004453F0 8D55E4 lea edx, [ebp-$1C] 004453F3 8D45D0 lea eax, [ebp-$30] 004453F6 B105 mov cl, $05 * Reference to: System.Proc_00402864 | 004453F8 E867D4FBFF call 00402864 004453FD 8D55D0 lea edx, [ebp-$30] 00445400 8D45F0 lea eax, [ebp-$10] * Reference to: System.Proc_00403B58 | 00445403 E850E7FBFF call 00403B58 00445408 BADC564400 mov edx, $004456DC 0044540D 8D45E8 lea eax, [ebp-$18] * Reference to: System.Proc_00402894 | 00445410 E87FD4FBFF call 00402894 00445415 8D45EC lea eax, [ebp-$14] 00445418 BA06000000 mov edx, $00000006 * Possible String Reference to: '0123456789' | 0044541D B9E8564400 mov ecx, $004456E8 00445422 4A dec edx 00445423 3B51FC cmp edx, [ecx-$04] 00445426 7205 jb 0044542D * Reference to: System.Proc_00402C04 | 00445428 E8D7D7FBFF call 00402C04 0044542D 42 inc edx 0044542E 8A5411FF mov dl, byte ptr [ecx+edx-$01] 00445432 885001 mov [eax+$01], dl 00445435 C60001 mov byte ptr [eax], $01 00445438 8D55EC lea edx, [ebp-$14] 0044543B 8D45E8 lea eax, [ebp-$18] 0044543E B102 mov cl, $02 * Reference to: System.Proc_00402864 | 00445440 E81FD4FBFF call 00402864 00445445 8D55E8 lea edx, [ebp-$18] 00445448 8D45CC lea eax, [ebp-$34] * Reference to: System.Proc_00403B58 | 0044544B E808E7FBFF call 00403B58 00445450 FF75CC push dword ptr [ebp-$34] 00445453 FF75F8 push dword ptr [ebp-$08] 00445456 68FC564400 push $004456FC 0044545B FF75F0 push dword ptr [ebp-$10] 0044545E 68FC564400 push $004456FC 00445463 6808574400 push $00445708 00445468 68FC564400 push $004456FC 0044546D FF75F4 push dword ptr [ebp-$0C] 00445470 8D45C8 lea eax, [ebp-$38] 00445473 BA13000000 mov edx, $00000013 * Possible String Reference to: 'abcdefghijklmnopqrstuvwxyz' | 00445478 B99C564400 mov ecx, $0044569C 0044547D 4A dec edx 0044547E 3B51FC cmp edx, [ecx-$04] 00445481 7205 jb 00445488 * Reference to: System.Proc_00402C04 | 00445483 E87CD7FBFF call 00402C04 00445488 42 inc edx 00445489 8A5411FF mov dl, byte ptr [ecx+edx-$01] * Reference to: System.Proc_00403ADC | 0044548D E84AE6FBFF call 00403ADC 00445492 FF75C8 push dword ptr [ebp-$38] 00445495 68FC564400 push $004456FC 0044549A FF75F0 push dword ptr [ebp-$10] * Possible String Reference to: '....' | 0044549D 6814574400 push $00445714 004454A2 8D45FC lea eax, [ebp-$04] 004454A5 BA0C000000 mov edx, $0000000C * Reference to: System.Proc_00403C74 | 004454AA E8C5E7FBFF call 00403C74 004454AF B201 mov dl, $01 * Reference to control TFPasswort.lblerg : TLabel | 004454B1 8B83DC020000 mov eax, [ebx+$02DC] * Reference to: Controls.Proc_0042282C | 004454B7 E870D3FDFF call 0042282C 004454BC B201 mov dl, $01 * Reference to control TFPasswort.T1 : TTimer | 004454BE 8B83E0020000 mov eax, [ebx+$02E0] * Reference to : TTimer._PROC_00441EBC() | 004454C4 E8F3C9FFFF call 00441EBC 004454C9 8D55C4 lea edx, [ebp-$3C] * Reference to control TFPasswort.edPW : TEdit | 004454CC 8B83D4020000 mov eax, [ebx+$02D4] * Reference to: Controls.Proc_00422914 | 004454D2 E83DD4FDFF call 00422914 004454D7 8B55C4 mov edx, [ebp-$3C] 004454DA 8B45FC mov eax, [ebp-$04] * Reference to: System.Proc_00403CC4 | 004454DD E8E2E7FBFF call 00403CC4 004454E2 757F jnz 00445563 004454E4 8D55BC lea edx, [ebp-$44] * Possible String Reference to: 'geht' | 004454E7 B824574400 mov eax, $00445724 * Reference to: Buttons.Proc_0044233C | 004454EC E84BCEFFFF call 0044233C 004454F1 FF75BC push dword ptr [ebp-$44] 004454F4 68FC564400 push $004456FC * Possible String Reference to: 'wohl' | 004454F9 6834574400 push $00445734 004454FE 68FC564400 push $004456FC * Possible String Reference to: 'doch' | 00445503 6844574400 push $00445744 00445508 68FC564400 push $004456FC * Possible String Reference to: 'nicht' | 0044550D 6854574400 push $00445754 00445512 68FC564400 push $004456FC * Possible String Reference to: 'vernünftig' | 00445517 6864574400 push $00445764 0044551C 68FC564400 push $004456FC * Possible String Reference to: 'und' | 00445521 6878574400 push $00445778 00445526 68FC564400 push $004456FC * Possible String Reference to: 'sicher' | 0044552B 6884574400 push $00445784 00445530 8D45C0 lea eax, [ebp-$40] 00445533 BA0D000000 mov edx, $0000000D * Reference to: System.Proc_00403C74 | 00445538 E837E7FBFF call 00403C74 0044553D 8B55C0 mov edx, [ebp-$40] * Reference to control TFPasswort.lblerg : TLabel | 00445540 8B83DC020000 mov eax, [ebx+$02DC] * Reference to: Controls.Proc_00422944 | 00445546 E8F9D3FDFF call 00422944 * Reference to control TFPasswort.lblerg : TLabel | 0044554B 8B83DC020000 mov eax, [ebx+$02DC] * Reference to field TLabel.OFFS_0058 | 00445551 8B4058 mov eax, [eax+$58] 00445554 BA0000FF00 mov edx, $00FF0000 * Reference to : TIcon._PROC_004143C4() | 00445559 E866EEFCFF call 004143C4 0044555E E9D1000000 jmp 00445634 00445563 8D55B8 lea edx, [ebp-$48] * Reference to control TFPasswort.edPW : TEdit | 00445566 8B83D4020000 mov eax, [ebx+$02D4] * Reference to: Controls.Proc_00422914 | 0044556C E8A3D3FDFF call 00422914 00445571 8B45B8 mov eax, [ebp-$48] 00445574 8B15906D4400 mov edx, [$00446D90] 0044557A 8B12 mov edx, [edx] * Reference to: System.Proc_00403CC4 | 0044557C E843E7FBFF call 00403CC4 00445581 755F jnz 004455E2 00445583 8D55B0 lea edx, [ebp-$50] * Possible String Reference to: 'das' | 00445586 B894574400 mov eax, $00445794 * Reference to: Buttons.Proc_0044233C | 0044558B E8ACCDFFFF call 0044233C 00445590 FF75B0 push dword ptr [ebp-$50] 00445593 68FC564400 push $004456FC * Possible String Reference to: 'wäre' | 00445598 68A0574400 push $004457A0 0044559D 68FC564400 push $004456FC * Possible String Reference to: 'wohl' | 004455A2 6834574400 push $00445734 004455A7 68FC564400 push $004456FC * Possible String Reference to: 'doch' | 004455AC 6844574400 push $00445744 004455B1 68FC564400 push $004456FC * Possible String Reference to: 'zu' | 004455B6 68B0574400 push $004457B0 004455BB 68FC564400 push $004456FC * Possible String Reference to: 'einfach' | 004455C0 68BC574400 push $004457BC 004455C5 8D45B4 lea eax, [ebp-$4C] 004455C8 BA0B000000 mov edx, $0000000B * Reference to: System.Proc_00403C74 | 004455CD E8A2E6FBFF call 00403C74 004455D2 8B55B4 mov edx, [ebp-$4C] * Reference to control TFPasswort.lblerg : TLabel | 004455D5 8B83DC020000 mov eax, [ebx+$02DC] * Reference to: Controls.Proc_00422944 | 004455DB E864D3FDFF call 00422944 004455E0 EB3F jmp 00445621 * Possible String Reference to: 'das' | 004455E2 B894574400 mov eax, $00445794 004455E7 8D55A8 lea edx, [ebp-$58] * Reference to: Buttons.Proc_0044233C | 004455EA E84DCDFFFF call 0044233C 004455EF FF75A8 push dword ptr [ebp-$58] 004455F2 68FC564400 push $004456FC * Possible String Reference to: 'war' | 004455F7 68CC574400 push $004457CC 004455FC 68FC564400 push $004456FC * Possible String Reference to: 'nichts' | 00445601 68D8574400 push $004457D8 00445606 8D45AC lea eax, [ebp-$54] 00445609 BA05000000 mov edx, $00000005 * Reference to: System.Proc_00403C74 | 0044560E E861E6FBFF call 00403C74 00445613 8B55AC mov edx, [ebp-$54] * Reference to control TFPasswort.lblerg : TLabel | 00445616 8B83DC020000 mov eax, [ebx+$02DC] * Reference to: Controls.Proc_00422944 | 0044561C E823D3FDFF call 00422944 * Reference to control TFPasswort.lblerg : TLabel | 00445621 8B83DC020000 mov eax, [ebx+$02DC] * Reference to field TLabel.OFFS_0058 | 00445627 8B4058 mov eax, [eax+$58] 0044562A BAFF000000 mov edx, $000000FF * Reference to : TIcon._PROC_004143C4() | 0044562F E890EDFCFF call 004143C4 00445634 33C0 xor eax, eax 00445636 5A pop edx 00445637 59 pop ecx 00445638 59 pop ecx 00445639 648910 mov fs:[eax], edx ****** FINALLY | * Possible String Reference to: '[‹å]Ã' | 0044563C 688D564400 push $0044568D 00445641 8D45A8 lea eax, [ebp-$58] 00445644 BA04000000 mov edx, $00000004 * Reference to: System.Proc_00403958 | 00445649 E80AE3FBFF call 00403958 0044564E 8D45B8 lea eax, [ebp-$48] * Reference to: System.Proc_00403934 | 00445651 E8DEE2FBFF call 00403934 00445656 8D45BC lea eax, [ebp-$44] 00445659 BA02000000 mov edx, $00000002 * Reference to: System.Proc_00403958 | 0044565E E8F5E2FBFF call 00403958 00445663 8D45C4 lea eax, [ebp-$3C] * Reference to: System.Proc_00403934 | 00445666 E8C9E2FBFF call 00403934 0044566B 8D45C8 lea eax, [ebp-$38] 0044566E BA02000000 mov edx, $00000002 * Reference to: System.Proc_00403958 | 00445673 E8E0E2FBFF call 00403958 00445678 8D45F0 lea eax, [ebp-$10] 0044567B BA04000000 mov edx, $00000004 * Reference to: System.Proc_00403958 | 00445680 E8D3E2FBFF call 00403958 00445685 C3 ret 00445686 E941DDFBFF jmp 004033CC 0044568B EBB4 jmp 00445641 ****** END | 0044568D 5B pop ebx 0044568E 8BE5 mov esp, ebp 00445690 5D pop ebp 00445691 C3 ret |
Re: String im Exe-Text verschlüsseln
Hallo Lucki,
mit welchem Programm nimmst Du die Dekompilierung nach Assembler vor? Ich würde mir das gern mal komplett anschauen. Meine Assemblerkenntnisse sind zwar schon ein wenig eingestaubt, aber wer weiß, wofür es gut ist. Davon mal abgesehen, es geht ja nicht darum, einen unknackbaren Schutz, den es bei Software ja sowieso nicht gibt, zu benutzen, sondern wohl eher darum, daß nicht jeder, der gerade mal mit einem Hex-Editor (oder F3 im NortonCommander) die lesbaren Zeichenketten in einer EXE-Datei angucken kann, mit 5 Minuten rumprobieren den Schutz überwinden kann. Und sowohl Otto-Normal-Nutzer sowie Möchter-Gern-Hacker Karl wissen mit Assembler sowieso nichts anzufangen. (Es gibt Leute, die denken bei Assembler eher an die Borg "Sie werden assimiliert" als an Maschinencode). mfg eddy |
Re: String im Exe-Text verschlüsseln
@eddy
1. Die Dekompilierung geht mit Disassemblern. 2. Jeder orderntliche Hacker beherrscht Assembler. 3. Es wird nicht dein Passwort selbst gecrackt, sondern es geht viel schneller und einfacher, den Sprungbefehl zu modifizieren (von "Springe nur wenn Passwort richtig" in "Springe immer"). Da kannst du dein Passwort noch so gut verschlüsseln und verstecken, wenn dein Sprungbefehl so einfach zu cracken ist. Da reibt sich jeder Nachwuchshacker die Hände. |
Re: String im Exe-Text verschlüsseln
Liste der Anhänge anzeigen (Anzahl: 1)
Also, ich hab eddy's proggy ganz einfach gecrackt ... wie mikko sagte, einfach. Hier der Beweis:
[edit] :wall: original hochgeladen ... :wall: |
Re: String im Exe-Text verschlüsseln
Hi c113plpbr,
:cheers: gegen Depressionen :cheers: :cheers: :cheers: Ich denk mir was neues aus mfg eddy |
Re: String im Exe-Text verschlüsseln
Hi! Am Rande dieses Threads hätte ich mal dazu ne Frage: Ist es möglich, es unmöglich (:mrgreen:) zu machen, ein Programm zu dissamblieren? Also z.B. wenn ich mein Prog mit diesem UPX (hieß das so? :guebel:) packe, kann man es dann trotzdem noch anstandslos dissamblieren und z.B. diesen "Sprungbefehl" manipulieren?
Man liest sich, Stanlay :hi: |
Re: String im Exe-Text verschlüsseln
Man muss es aber vorher erst wieder entpacken. Und das geht mit UPX ja auch.
|
Re: String im Exe-Text verschlüsseln
Prinzipiell geht das entpacken eines jeden Packers. Die AV-Leute benutzen dazu Emulatoren ;) ... die EXE entpackt sich dann freiwillig (muss sie ja eh) und wird dann in diesem Zustand gespeichert und disassembliert.
Nein, es gibt keine absolut sichere Möglichkeit. Schwerer machen kannst du es immer ... aber mehr auch nicht. |
Re: String im Exe-Text verschlüsseln
Na gut, ich hab ja nur gemeint :)
Danke für eure Antworten! Man liest sich, Stanlay :hi: |
Re: String im Exe-Text verschlüsseln
Könnte man da auch Photoshop, Counterstrike, etc, disassemblieren?
|
Re: String im Exe-Text verschlüsseln
Hier ist die Diskussion, die ich meiner:
 http://www.delphipraxis.net/internal...192&highlight= Man beachte den beitrag von hagen. |
Re: String im Exe-Text verschlüsseln
Zitat:
|
Re: String im Exe-Text verschlüsseln
:gruebel: Ich habe Hangens klaren Aussagen entnommen, dass es überhaupt keine Möglichkeit gibt, das ganze sicher zu verstecken. Ich muss sagen, mir geistert immer noch dieses Umlenken von "Sprungbefehlen" im Kopf rum :pale: Wenn man das ja immer machen kann, wie könnte man denn sowas verhindern/extrem verkomplizieren? Nur mal so ansatzweise. Ich meine, dann wäre es ja sogar sinnlos, verschlüsselungskomponenten zu benutzen, weil die ja auch einen Code/Passwort haben wollen, das man Ihnen übergeben muss. :gruebel:
|
Re: String im Exe-Text verschlüsseln
http://www.s-a-ve.com/ -> FAQ -> ganz unten: AntiCracking Tipps. |
Re: String im Exe-Text verschlüsseln
hier nochmal nen link zu nem thread der hier schonmal gelaufen ist:
http://www.delphipraxis.net/internal...ect.php?t=8142ganz interessant, behandelt in etwa das gleiche thema, nur geht es hier (fast) nur ums cracken. Dort (und auf den dortigen links) finden sich anleitungen und tools mit denen man etwas weiter in dieses Gebiet blicken kann. Sind zwar sieben seiten, aber ich finde es hat sich gelohnt diesen thread nochmals auszugraben ... |
Re: String im Exe-Text verschlüsseln
Eine interessante Methode sind beispielsweise Fibers unter NT. Auch sollte es mit einem Fork() teilweise möglich sein zumindest Debugger auszutricksen. Hagen hat auch schon sehr schöne Beispiele angeboten, in denen der Hauptteil mit einer bekannten und sicheren Verschlüsselungsmethode verschlüsselt wurde und nur der richtige Key die Ausführung ermöglichte! Da der entsprechende Algo, wenn er gut getestet wurde (sicher nicht von dir oder mir sondern von Mathematikern!), sicher ist, ist es auch die EXE. Einen EXE-Dump nach Eingabe des korrekten Schlüssels verhindert es nicht. Ist also die Schlüssellänge kurz genug, bleibt noch immer Brute-Force.
Dongles sind auch eine Möglichkeit, IMO aber die unsicherste. Habe kurz vor Weihnachten sowas am Wickel gehabt ( Crypto-Box® Versa (CBV)). Da die Programme im Usermode laufen gibt es immer eine Schnittstelle zwischen Dongletreiber (Kernelmode) und Programm (Usermode) und das ist meist eine DLL. Ersetzt man diese, ist der Dongle überflüssig ... noch einfacher und nichtmal illegal (weil man ja nichts verändert) ist das Kopieren der Trojaner-DLL in das Programmverzeichnis, da der PE-Loader zuerst im Programmverzeichnis und dann im Suchpfad nach den DLLs sucht. Man behilft sich also mit einem bekannten Window-Mechanismus. Ausserdem ist das Programm ja gekauft, es ging nur darum das lästige Dongle-Hinundherschleppen zu vermeiden (und die Dinger brennen gern mal durch, der Softwarehersteller bietet einem dann meist kulanterweise an eine neue Lizenz zu erwerben :-()@c113plpbr: Der Thread ist langweilig und sinnlos (bis auf Hagens sehr schöne Ausführungen). |
Re: String im Exe-Text verschlüsseln
Zitat:
D.h. aber NICHT das z.B. eine von mir verschlüsselte Datei unsicher vor dem entschlüsseln durch einen Hacker ist auch wenn er die Sourcen meiner Verschlüsselungs-Software besitzt. Der Unterschied ist nämlich das das benutzte Passwort zur Verschlüsslung in einem Kopf gespeichert ist. Sozusagen ist das wichtige Geheimniss zur Entschlüssung in einer einbruchsicheren Hardware gespeichert. Als Softwareschutzt taugt dieser Weg aber nichts. Denn das benutzte Passwort zum Schutz der Software MUSS durch die Software selber zugreifbar sein. Es müsste im Falle eines Softwareschutzes irgendwo gespeichert werden, an einer Stelle wo der Hacker auch Zugriff hat. Somit macht die Grund-Thematik eines Softwareschutzes die Anwendung von sicherer Kryptgraphie sinnlos/überflüssig. Es sei denn man baut diese Kryptographie in Zusammenhang mit einbruchsicherer Hardware ein. Es gibt nun verschiedene Ansätze für einen Softwareschutz: 1.) die Benutzer-Einstellung zum Produkt und Firma wird geändert. D.h. der Support, Preis und Vertriebsweg der Software wird durch den Hersteller so abgeändert das der Benutzer KEIN Interesse daran hat die Software zu knacken. Z.b. OpenSource + Internet + 0 Euro Preis. 2.) die Softwareindustrie nimmt Einfluß auf die Politik und schafft Gesetze die das Hacken ansich verbieten. D.h. der totale Überwachungsstaat damit die Softwareindustrie auch überprüfen kann ob geknackt wird. Patente, der National Security Act der USA, DRM = Digital Rights Management, Regional Codes der DVD, Trustcenter usw. usw. sind solche Maßnahmen. 3.) Man benutzt zusätzliche Techniken und bringt einbruchsichere Hardware ins Spiel. Bei diesem Weg ist es aber WICHTIG das zu keinem einzigsten Zeitpunkt die Software vollständig entschlüsselt bzw. ungesichert ist. D.h. wenn man solche Hardwaresysteme zum Schutz benutzen will so muß diese zu jedem Zeitpunkt des Softwarevertriebes, Speicherung und auch während der Anwendungsphase mit dieser Hardware verbunden sein. Somit MUSS möglichst jede Information erstmal digital vorliegen (globale Digitalisierung der Informationen), die Vertiebskanäle und die Speicherung der Daten muß zu jedem Zeitpunkt verschlüsselt werden und immer auf Hardware erfolgen die einbruchsicher ist. Der Fritz-Chip innerhalb der CPU von PC's + das CPRM=Contens Protection Management innerhalb von Speicherkarten wie SD-/xD Cards oder IDE Festplatten + der MedialPlayer 9 mit der Einweg-Dekodierung von WMV Dateien (d.h. die Windows-Software ermöglicht KEINELEI Umkodieren von WMV Dateien) + die Schaffung von komerziellen Trustentern zur Verwaltung der nötigen Schlüssel=Identitäten sind solche Lösungen. NUR alle zusammen + entsprechhende Gesetze lösen das Problem. Dadurch wird Information=Wissen unfrei und kontrollierbar. Die Maßnahmen 2. und 3. kann man als derzeitigem Trend in der Welt beobachten. Denn den Einfluß und die finanzielle Macht der großen Konzerne ermöglicht diesen exakt diese Wege. Der Weg 1.) sprich der Trend zu OpenSource ist der derzeitige Anti-Weg zu 2) und 3) der freiheitsliebenden Menschen, entscheide dich. 4.) der Wettlauf mit dem Hacker ! Hier versucht der Programmerer mit allen Tricks zu verhindern das ein Hacker/Cracker die Software analysieren kann. Z.b. Anti-Disassembling um durch passives Disassembling den Hacker in die Irre zu leiten. Dabei nutzt der Programmierer sehr häufig Schwachstellen der durch die Cracker benutzten Disassembler aus. Das fatale daran !? Beginnt der Cracker zu cracken und schafft es auch, so knackt er NICHT nur die Software, sondern lernt nebenbei auch noch die Tricks des Programmieres. Bei der nächsten Software MUSS der Programmierer sich also absolut neue Maßnahmen einfallen lassen. Desweiteren werden häufig "polymorphe" Systeme verwendet. D.h. selbst-entpackender und verschlüsselter Programcode. Die Software verändert sich durch die Registration, sie ist polymorph. Hier in der DP gab es mal ein Thread der sich damit befasste. Mein Program das auf Verschlüsseltem-Programcode basierte der durch einen Polymorphen-Verschlüsselungsalgo beruht (sprich der Ver/entschlüsselungscode compiliert sich selber auf Grund des Registrationskey) wurde bis heute nicht geknackt. Aber! nur weil ICH der einzigste BIN der bis heute den richtigen Registrationscode in meinem KOPF gespeichert hat. Dies widerspricht aber der Softwaredistribution. Denn irgendwann muß ich dem Benutzter seinen RegCode senden. Dieser Benutzer kann aber nun die Software sich vollständig von selbst entschlüsseln lassen. IST der Benutzer ein Cracker so kann er damit also eine ungeschützte Softwarekopie herstellen. D.h. der reine Softwarebasierte Schutz einer Software WIDERSPRICHT immer der logischen Argumentation der heutigen Kryptographischen Systeme. Softwareschutz ist also gleichbedeutent mit Profitsicherung und Profitsicherung wird durch Politische Maßnahmen für entsprechende Gesetze zum Schutz des Privateigentumes erfolgen. Damit könnte man übertrieben behaupten das ein Cracker/Hacker immer gegen das heutige bestehende Gesellschaftliche System verstößt. Dir als Programmierer wird entweder der 1. oder 4. Weg übrigbleiben. Im 4. Weg verlierst du mit 99%'tiger Wahrscheinlchkeit immer gegen die Cracker/Hacker. Im 1. Weg schaffst du dir dagegen 99% der Menschheit zum Freund :) Softareschutz, Kryptographie usw. sind also UNSERE Berührungspunkte als Programmierer mit der Welt der Politik. Gruß Hagen |
Re: String im Exe-Text verschlüsseln
Zitat:
Ich muss vielleicht noch erklähren, wie ich darauf gekommen bin: Ich wollte demnächst ein Prog schreiben, indem man einzelne Einträge verschlüsseln können soll. Und als ich das jetzt gelesen hab, hab ich mir schon überlegt, diese Funktion nicht einfach wegzulassen. Aber jetzt bin ich ja wieder ein bisschen schlauer. :) Man liest sich, Stanlay :hi: |
Re: String im Exe-Text verschlüsseln
Ok, die Frage ist wieviel Prozent der Menschen du daran hindern willst das die Software geknackt ist.
Echte Profis wirst du durch einen reinen Softwarebasierten Schutz nicht aufhalten können. Allerdings, gerade echte Profis wählen die Software die sie knacken wollen sehr penibel aus. D.h. deine Software muß sich schon lohnen zu knacken, sie müsste also was ganz einmaliges können und zudem noch schweine teuer sein. Es gibt auch bei Crackern/Hackern sowas wie eine natürliche Fairness. Preiswerte Shareware für jederman die gut gecodet ist wird meistens verschont, denn davon gibts viel zu viele. Viel eher sind Programme der großen Konzzerne betroffen. Somit kannst auch du mit deiner Shareware noch deinen Lebensunterhalt verdienen. Das wichtige an deinem Konzept muß es sein, das du zusätzlich zu deiner guten und preiswerten Software einen guten Support bietest. Am besten ist es die eigentliche Software nur als Mittel zum Zweck zu betrachten. D.h. von dir angebotene und käufliche Information werden durch deine Software erst erlebbar. Der Anwender zahlt also NICHT für die Software sondern für die Informationen. Ein gutes Beispiel für diese Wirkungsweise war der Internet Explorer von Microsoft. Um das Windows-OS attracktiv zu machen wurde der IE als kostenlose Zusatzsoftware angeboten. Da dies aber in auslegbarer Weise als unlauterer Wettbewerb angesehen wurde, hat MS schlußendlich den IE als integralen Bestandteil in das Windows-OS integriert. Heute surfen ca. 90% aller Menschen mit dem IE !! Willst du aber Kryptographie in deine Software einbauen um die sensiblen Daten der Anwedner zu schützen dann gibt es sehr wohl sichere Verfahren. Denn nur IST es im Interesse des Benutzers seine Passwörter gut zu wählen und an für ihn sicheren Stellen zu speichern (Kopf). Gruß Hagen |
Re: String im Exe-Text verschlüsseln
Also zu cracken geht dein Prog in 5 Minuten (siehe c113plpbr).
Und dein Passwort lautet: "Leerzeichen"5geht Nicht - gibts Nicht.... |
Re: String im Exe-Text verschlüsseln
Es gibt nen supi disassembler der läuft die ganze zeit im Hintergrund. Und wenn man ne bestimmte tastenkombination drückt sieht man an welcher stelle der grad im programm is und erstpart sich somit das suchen nach der passwortabfrage. Einfach wenn die dumme passwortabfrage kommt tastenkombination drücken und schwubs - stelle die zu ändern ist gefunden
|
Re: String im Exe-Text verschlüsseln
Sorry, da haste aber ein Programm geknackt das garnicht von mir ist :)
Nein, das ist NICHT das Passwort meines Programmes ! Ich würde NIEMALS ein solches Passwort verwenden. Mein letztes Program nutzt einen 512 Bit Zufallsschlüssel, er representiert also keine Wörter, Sätze sondern reine binäre Bits. Ich rate dir aber nicht Zeit zu verschwenden. Mein Program kann nicht geknackt werden, zumindestens nicht mit der heutigen Technik, Wissen und Zeitaufwand. Gruß Hagen |
Re: String im Exe-Text verschlüsseln
@Mikko:
Es hat nichtmal fünf minuten gedauert ... egal, für das passwort war ich zu faul ... wie hast du das eigentlich rausgekriegt? @negaH: Ich glaube 'SirThornberry' meinte nicht dein Programm, sondern das von eddy das ich gecrackt habe ... deines ist relativ sicher, zumindest vor anfängern wie mir ... Ich hab do noch ne schutzidee: Psychotricks ... ob das funktioniert??? :?: |
Re: String im Exe-Text verschlüsseln
"disassembler", darf man nicht mit einem Debugger verwechseln. Fast jeder Debugger enthält auch einen Disassembler aber nicht jeder Disassmbler muß ein Debugger sein.
Wird mit einem aktiven Debugger ein Programm getracet dann kann man die "Anti-Disassembler" Tricks erkennen. Ein einfacher Disassembler-Trick ist zB. der Call-Stack-Trick. Dabei manipuliert man den aktiven Aufrufstack fun Proceduren so daß der Programmfluß an einer anderen Stelle weitergeht. Der passive Disassembler kann dies NICHT erkennen, er ist dummm. Dies sähe z.B. so aus:
Delphi-Quellcode:
Der Disassembler sieht nun einen Code der aus der Speicherstelle an Addresse on @MyProc einen Pointer lädt und dahin im program springt. Diese Speicherstelle @MyProc kann aber dynamisch während der Programmlaufzeit modifiziert werden. Diese Modifizierung kann abhänig vom RegCode sein.procedure Hiddenproc; begin end; var MyProc: procedure = HiddenProc; procedure CallHiddenProc; begin MyProc; // obiger Aufruf benutzt einen Indirekten Call, d.h. es wird an die Speicherstelle die in MyProc steht gesprungen. end; D.h. der Programmfluß wird auf direktem Weg dynamisiert. Nur mit einem aktiven Debugger kann man erhausbekommen wohin das Program tatsächlich springt. Natürlich ist obiger "Trick" kein Trick im eigentlichen Sinne sondern ein Normalzustand in heutigen Programmen. Obiges Beispiel ist aber das Minimal-Beispiel wie Disassembler ausgetrickst werden können. Hier mal ein anders:
Delphi-Quellcode:
Aber auch dieser Trick ist zu offensichtlich für gute Cracker, ein passiver Dissassembler kann aber NICHT mehr den Code in HiddenProc exakt identifizieren.
procedure HiddenProc;
begin ShowMessage('Hidden'); end; procedure MyCaller(Proc: Pointer); asm XCHG [ESP],EAX end; procedure CallHiddenProc; procedure DoCall; begin MyCaller(@HiddenProc); ShowMessage('Test'); end; begin DoCall; ShowMessage('Test1'); end; Gruß Hagen |
Re: String im Exe-Text verschlüsseln
JEDER Anti-Cracking/Debugging Trick ist auch ein Phsycholigischer Trick. D.h. man muss immer bei solchen Tricks die Phsycholigie des Hackers berücksichtigen. Alles andere ist stumpfsinniges anwenden von bekannten Tricks. Man muß also als Programmierer gleichermaßen Programmierer und auch Hacker sein. Ein Programmierer der nicht gleichzeitg auch Hacker ist wird niemals effiziente Anti-Hacker Tricks entwickeln können.
Ein Hacker ist: - faul - sehr hartnäckig - ein mensch der den Überblick sehr leicht verlieren kann - der meistens sehr gut linear in Assembler-Ebene denken kann, und somit die Auswürfe von Hochsprachen und deren OOP Konstrukte, DLL's, COM Bibliotheken hasst. - der Multitasking OS'e + Threading + Protected Mode nicht sehr liebt. - der selbst vor der knallharten Mathematik von echten Kryptosystemen kapitulieren muß Gruß Hagen |
Re: String im Exe-Text verschlüsseln
@c113plpbr
Mit 'nem Debugger. Ist fast genauso einfach gewesen wie das cracken, außer die Punkte am Schluß sind "nervig" gewesen (da der Debugger seine "leeren" Stellen auch als Punkte anzeigt). @negaH Ich meinte das Prog von eddy. PS: Achja, im Passwort muß man natürlich "Leerzeichen" auch als Zeichen selbst eingeben und nicht die Zeichenkette!!! |
| Alle Zeitangaben in WEZ +1. Es ist jetzt 14:43 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024-2025 by Thomas Breitkreuz