home *** CD-ROM | disk | FTP | other *** search
/ The Elite Hackers Toolkit / TheEliteHackersToolkitVolume1_1998.rar / HACKERS.BIN / appcraks / SHADOW10.ZIP / SHADOW.ASM
Assembly Source File  |  1998-01-21  |  14KB  |  299 lines
  1. %TITLE  "Shadow v1.0 Beta - COM encryptor by Tailgunner"
  2.  
  3.         IDEAL           ; ideal mode r0x ;)
  4.  
  5.         JUMPS           ; allow jumps bigger then 128 bytes
  6.         MODEL   tiny
  7.  
  8. CR      EQU     0Dh     ; ASCII for carriage return
  9. LF      EQU     0Ah     ; ASCII for line feed
  10.  
  11.         DATASEG
  12.  
  13. Intro           DB      '───═[ Shadow COM encryptor version 1.0 beta ]═───',LF,CR
  14.                 DB      '           Coded in 1998 by Tailgunner',LF,CR,'$'
  15. NoCTail         DB      LF,CR,'  ■ Directions : shadow <filename.com>',LF,CR,'$'
  16. Opening         DB      LF,CR,'  ■ Opening file ...$'
  17. Allocate        DB      LF,CR,'  ■ Allocating memory ...$'
  18. Reading         DB      LF,CR,'  ■ Reading from input file ...$'
  19. Crypting        DB      LF,CR,'  ■ Mutating code ...$'
  20. Writing         DB      LF,CR,'  ■ Writing to output file : $'
  21. Done            DB      LF,CR,'  ■ Job complete!',LF,CR,'$'
  22. ErrOpen         DB      LF,CR,'  ■ Error : File not found!',LF,CR,'$'
  23. ErrRead         DB      LF,CR,'  ■ Error reading from file!',LF,CR,'$'
  24. ErrWrite        DB      LF,CR,'  ■ Error writing to output file!',LF,CR,'$'
  25. ErrCreate       DB      LF,CR,'  ■ Error creating output file!',LF,CR,'$'
  26. ErrAlloc        DB      LF,CR,'  ■ Error allocating memory!',LF,CR,'$'
  27. ; ---------------------------------------------------------------------------
  28. Handle          DW      0               ; storage for file handle
  29. Jump            DB      0E9h            ; code for a JMP
  30. FSize           DW      0               ; file size holder
  31. CrpSize         DW      0               ; filesize / 2 + 1 (for loop)
  32. CTailStor       DW      0               ; points to beginning of command tail
  33. CTailSize       DW      0               ; size of command tail
  34. MemAddr         DW      0               ; New DS address
  35. Key             DB      0               ; encryption key from clock
  36. XORKey          DW      0               ; stores final key value
  37. NewFile         DB      0Dh DUP (0),LF,CR,'$'   ; output file name
  38.  
  39.         CODESEG
  40.  
  41.         ORG     100h
  42.         P386
  43.         
  44. Start:
  45.         lea     dx,[Intro]              ; load 'Intro' message
  46.         call    Print                   ; print the message   
  47.         mov     cl,[ds:80h]             ; get command tail length
  48.         or      cl,cl                   ; anything there?
  49.         jnz     FoundCmd                ; if so move on ...
  50.         lea     dx,[NoCTail]            ; print 'NoCTail' message
  51.         call    Print
  52.         jmp     Exit                    
  53.  
  54. FoundCmd:
  55.         call    GetCmdTail              ; procedure to get params on cmdtail
  56.         lea     dx,[Opening]            ; load 'Opening' message
  57.         call    Print                   ; print the message
  58.         call    OpenFile                ; open file from command tail
  59.         jnc     FileOpen                ; jump if there is no errors
  60.         lea     dx,[ErrOpen]            ; load 'ErrOpen' message
  61.         call    Print                   ; print the message
  62.         jmp     Exit
  63.  
  64. FileOpen:
  65.         mov     [Handle],ax             ; move file handle into 'Handle'        
  66.         lea     dx,[Allocate]           ; load 'Allocate' message
  67.         call    Print                   ; print the message
  68.         call    MemAllocate             ; procedure to allocate memory
  69.         jnc     StartRead               ; if everything is ok, jump on...
  70.         lea     dx,[ErrAlloc]           ; print 'ErrAlloc' message
  71.         call    Print                   ; print the message
  72.         jmp     Exit
  73.  
  74. StartRead:
  75.         mov     [MemAddr],ax            ; MemAddr <-- address of new memory
  76.         lea     dx,[Reading]            ; load 'Reading' message
  77.         call    Print                   ; print the message
  78.         call    ReadFile                ; read input file into memory
  79.         jnc     Encryp                  ; if everything is ok, move on
  80.         lea     dx,[ErrRead]            ; load 'ErrRead' message
  81.         call    Print                   ; print the message
  82.         jmp     Exit
  83.  
  84. Encryp:
  85.         call    CloseFile               ; close input file
  86.         mov     ah,2Ch                  ; get time from clock
  87.         int     21h
  88.         xor     dl,dh                   ; dh = Seconds, dl = Hundredths
  89.         mov     [Key],dl                ; move random key into 'Key'
  90.         mov     bx,[FSize]              ; bx = filesize (key for encryption)
  91.         mov     cx,bx                   ; also need filesize in cx for loop
  92.         movzx   dx,dl                   ; move dl to dx
  93.         xor     bx,dx                   ; bx = filesize dx = random Value
  94.         mov     [XORKey],bx             ; save XORKey for Decrypt procedure
  95.         lea     dx,[Crypting]           ; load 'Crypting' message
  96.         call    Print                   ; print the message
  97.  
  98.         shr     cx,1                    ; divide filesize by 2
  99.         inc     cx                      ; add one in case of remainder
  100.         mov     [CrpSize],cx            ; save for adding to Decrypt proc
  101.         mov     ax,[MemAddr]            ; move 'MemAddr' into ax
  102.         push    ds es                   ; save ds and es to the stack
  103.         mov     ds,ax                   ; ds points to the allocated mem
  104.         mov     es,ax                   ; ... and so does es
  105.         xor     dx,dx                   ; ds:dx points to start of filebuf
  106.         xor     si,si                   ; ds:si
  107.         xor     di,di                   ; es:di
  108. Loop1:
  109.         lodsw                           ; load word to ax
  110.         xor     ax,bx                   ; crypt it with bx
  111.         stosw                           ; store it back on di
  112.         xchg    bl,bh                   ; switch bl with bh
  113.         not     bx                      ; get ones complement of bx
  114.         loop    Loop1                   ; loop back for the next word
  115.  
  116.         pop     es ds                   ; restore old ds and es
  117.         call    NewFName                ; comfile.com --> comfile.sdw
  118.  
  119. FNameStr:
  120.         mov     si,[CTailStor]          ; si points to start of command tail
  121.         lea     di,[NewFile]            ; di points to 'NewFile' variable
  122.         mov     cx,[CTailSize]          ; command tail length in cx
  123.         dec     cx                      ; we don't need the null 0 at the end
  124.  
  125. Loop2:
  126.         lodsb
  127.         stosb                           ; put new filename into NewFile
  128.         loop    Loop2
  129.  
  130. OK:
  131.         lea     dx,[Writing]            ; load 'Writing' message
  132.         call    Print                   ; print the message
  133.         lea     dx,[NewFile]            ; load 'NewFile' (new file name)
  134.         call    Print                   ; print the filename
  135.         call    CreateFile              ; create output file
  136.         jnc     Continue                ; if everything is ok jump on
  137.         lea     dx,[ErrCreate]          ; load 'ErrCreate' message
  138.         call    Print                   ; print the message
  139.         jmp     Exit
  140.  
  141. Continue:
  142.         mov     [Handle],ax             ; put file handle into 'Handle'
  143.         mov     cx,03h                  ; cx = number of bytes to write
  144.         lea     dx,[Jump]               ; dx points to start of bytes
  145.         mov     bx,[Handle]             ; put file handle into bx
  146.         call    WriteFile               ; write the bytes to file
  147.         jnc     WriteOK                 ; if everything is good, jump
  148.         lea     dx,[ErrWrite]           ; load 'ErrWrite' message
  149.  
  150. WriteOK:
  151.         mov     cx,[CrpSize]            
  152.         mov     [word ptr PtchSize+1],cx
  153.         mov     cx,[XORKey]
  154.         mov     [word ptr PtchCrp+1],cx
  155.  
  156. ; The above routine may be a bit confusing so i'll explain ;)
  157. ; CrpSize = Half the filesize, we need this in the Decrypt procedure because
  158. ; we are crypting word values. XORKey = the encryption key that was
  159. ; created when the input file buffer was crypted farther up in the source.
  160. ; mov [word ptr PatchSize+1],cx patches the Decrypt procedure before it
  161. ; is written to the output file. The same thing goes for the XORKey.
  162.  
  163.  
  164.         push    ds                      ; save ds to the stack
  165.         mov     cx,[FSize]              ; load filesize into cx
  166.         mov     bx,[Handle]             ; bx contains file handle
  167.         mov     ax,[MemAddr]            ; load address of allocated mem in ax
  168.         mov     ds,ax                   ; ds now points to allocated memory
  169.         xor     dx,dx                   ; ds:dx points to file buffer
  170.         call    WriteFile               ; write the buffer to output file
  171.         pop     ds                      ; restore old ds
  172.  
  173.         lea     dx,[Decrypt]            ; dx points to start of Decrypt proc
  174.         mov     cx,(Marker-Decrypt)     ; number of bytes to write 
  175.         mov     bx,[Handle]             ; move file handle into bx
  176.         call    WriteFile               ; write the decrypt procedure to file
  177.         call    CloseFile               ; close the output file
  178.         lea     dx,[Done]               ; load 'Done' message
  179.         call    Print                   ; print the message
  180.  
  181. Exit:
  182.         mov     ah,4Ch                  ; function 4Ch = terminate process
  183.         int     21h
  184.  
  185. PROC    Print
  186.         mov     ah,09h                  ; function 4Ch = print string
  187.         int     21h
  188.         ret
  189. ENDP    Print
  190.  
  191. PROC    GetCmdTail
  192.         inc     cx                      ; cx = length to scan
  193.         mov     [CTailSize],cx          ; save command tail size to CTailSize
  194.         mov     di,81h                  ; 81h = start of command tail
  195.         mov     al,' '
  196.         repe    scasb                   ; scan bytes while al = ' '
  197.         lea     dx,[di-01h]             ; dx points to beginning of tail
  198.         mov     [CTailStor],dx          ; also put in CTailStor
  199.         repne   scasb                   ; scan while al <> ' '
  200.         dec     di
  201.         xor     al,al                   ; null terminate the parameter
  202.         stosb                           ;
  203.         ret
  204. ENDP    GetCmdTail
  205.  
  206. PROC    OpenFile
  207.         mov     dx,[CTailStor]          ; dx points to filename from CTailStor
  208.         mov     ax,3D02h                ; open file for read/write
  209.         int     21h
  210.         ret
  211. ENDP    OpenFile
  212.  
  213. PROC    MemAllocate
  214.         mov     ah,4Ah                  ; modify allocated memory blocks
  215.         mov     bx,1000h                ; make 1000h byte paragraphs
  216.         int     21h
  217.         mov     ah,48h                  ; allocate memory blocks
  218.         mov     bx,1000h                ; allocate 1000h blocks
  219.         int     21h
  220.         ret
  221. ENDP    MemAllocate
  222.  
  223. PROC    ReadFile
  224.         mov     bx,[Handle]             ; move file handle into bx
  225.         mov     cx,0FFFFh               ; maximum number of bytes to read
  226.         mov     ax,[MemAddr]            ; ax has address of allocated mem
  227.         push    ds                      ; save old ds
  228.         mov     ds,ax                   ; we are reading file into new mem
  229.         xor     ax,ax                   ; clear ax
  230.         xor     dx,dx                   ; ds:dx points to allocated mem
  231.         mov     ah,3Fh                  ; function 3Fh = read from file
  232.         int     21h
  233.         pop     ds                      ; restore old ds
  234.         mov     [FSize],ax              ; save filesize to FSize
  235.         ret
  236. ENDP    ReadFile
  237.  
  238. PROC    NewFName
  239.         mov     cx,[CTailSize]          ; load command tail size into cx
  240.         xor     di,di                   ; clear di
  241.         mov     di,[CTailStor]          ; di points to first char on cmdtail
  242.         mov     al,'.'
  243.         repne   scasb                   ; scan bytes while al <> '.'
  244.         mov     al,'s'                  ;
  245.         stosb                           ;
  246.         mov     al,'d'                  ; create new filename extention
  247.         stosb                           ;
  248.         mov     al,'w'                  ;
  249.         stosb                           ;
  250.         ret
  251. ENDP    NewFName
  252.  
  253. PROC    CloseFile
  254.         mov     bx,[Handle]             ; move handle into bx
  255.         mov     ah,3Eh                  ; function 3Eh = close file
  256.         int     21h
  257.         ret
  258. ENDP    CloseFile
  259.  
  260. PROC    CreateFile
  261.         mov     dx,[CTailStor]          ; dx points to filename from CTailStor
  262.         xor     cx,cx                   ; clear cx
  263.         mov     ah,3Ch                  ; function 3Ch = create file
  264.         int     21h
  265.         ret
  266. ENDP    CreateFile
  267.  
  268. PROC    WriteFile
  269.         mov     ah,40h                  ; function 40h = write bytes to file
  270.         int     21h
  271.         ret
  272. ENDP    WriteFile
  273.  
  274. PROC    Decrypt
  275. PtchSize:
  276.         mov     cx,0                    ; byte ptr from above patches the 0
  277. PtchCrp:
  278.         mov     bx,0                    ; byte ptr from above patches the 0
  279.         mov     si,103h                 ; start of crypted code
  280.         mov     di,100h                 ; decrypt to cs:0100h
  281. Lp:
  282.         lodsw                           ; load word to decrypt into ax
  283.         xor     ax,bx                   ; crypt it!
  284.         stosw                           ; overwrite encrypted code
  285.         xchg    bl,bh                   ; exchange bl with bh
  286.         not     bx                      ; get ones complement of bx 
  287.         loop    Lp
  288. Return:
  289.         push    100h                    ; ret to cs:100h
  290.         ret
  291. ENDP    Decrypt
  292.  Marker  DB      0                      ; marker for the end of procedure
  293.  
  294.         END     Start
  295.  
  296.  
  297.  
  298.  
  299.