home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / UTILITY / FILE / UNEXEP10.ZIP / UNEXEPAC.ASM < prev    next >
Encoding:
Assembly Source File  |  1991-12-23  |  6.7 KB  |  287 lines
  1. ; Unpacks EXEPACKed files. Uses MS embedded unpacker, after installing a few
  2. ; position independant patches in it (to make it build the relocation table).
  3. ; Note that the EXEPACK process round the image size to paragraph boundaries,
  4. ; i e EXEPACK + UNEXEPAC may add up to 15 pad bytes at the file end.
  5.  
  6. ; Released to the Public Domain by Dan Norstedt 1991
  7.  
  8. ; Version 1.0
  9.  
  10. ; Build by:    MASM UNEXEPAC;
  11. ;        LINK UNEXEPAC;
  12. ;        EXE2BIN UNEXEPAC UNEXEPAC.COM
  13.  
  14. CODE    SEGMENT PUBLIC
  15.     ASSUME    CS:CODE,DS:CODE
  16.  
  17.     ORG    100H
  18.  
  19. START:    CLD
  20.     MOV    DI,Offset ZERBUF
  21.     XOR    AX,AX
  22.     MOV    CH,1
  23.     REP    STOSW            ; Set up a pad block (for reloc table)
  24.     CMP    Byte Ptr DS:[5DH],20H    ; Any argument?
  25.     JZ    READIN
  26.     MOV    DX,Offset USETXT    ; Display usage text
  27.     JMP    OUTMSG
  28. USETXT    DB    "Usage: UNEXEPAC <packedfile.EXE >unpacked.EXE$"
  29.  
  30. WRKSTK:
  31.  
  32. OUTMS2:    JMP    OUTMSG
  33.  
  34. READNX:    MOV    AX,DS
  35.     ADD    AX,0F80H
  36.     MOV    DS,AX            ; Adjust to next buffer
  37.     SUB    AX,Word Ptr CS:[2]    ; Overflow?
  38.     MOV    DX,Offset TOOTXT
  39.     JAE    OUTMS2
  40.     MOV    CX,AX            ; No, how much more can we read in?
  41.     SHL    CX,1
  42.     SHL    CX,1
  43.     SHL    CX,1
  44.     SHL    CX,1
  45.     CMP    AX,0F80H        ; Has CX a valid value < F800
  46.     JB    READIX            ; Yes, use it
  47. READIN:    MOV    CX,0F800H        ; Set up maximum read in chunk size
  48. READIX:    MOV    SP,Offset WRKSTK    ; Change stack to safe place:init code
  49.     MOV    AH,3FH
  50.     XOR    BX,BX
  51.     MOV    DX,Offset BUFFER    ; Read in data
  52.     INT    21H
  53.     MOV    DX,Offset REATXT
  54.     JC    OUTMS2
  55.     CMP    AX,CX            ; Got all we asked for?
  56.     JZ    READNX            ; Yes, try to get more
  57.     MOV    AX,CS
  58.     ADD    AX,Word Ptr CS:[BUFFER+08H]    ; Get load image offset (PARA)
  59.     ADD    AX,(Offset BUFFER-Offset START+100H)/10H-10H ; Buffer offset
  60.     MOV    ES,AX                ; Save faked PSP paragraph
  61.     ADD    AX,10H
  62.     MOV    Word Ptr CS:[EXEBASE],AX    ; Save load image offset
  63.     ADD    AX,Word Ptr CS:[BUFFER+16H]
  64.     MOV    DS,AX                ; Save faked CS
  65.     MOV    SI,Word Ptr CS:[BUFFER+14H]    ; Get faked IP
  66.     CMP    Word Ptr [SI-2],"BR"        ; Check for EXEPACK signature
  67.     MOV    DX,Offset NOPTXT
  68.     JNZ    OUTMSG                ; Isn't EXEPACKed, tell user
  69.     CMP    Word Ptr CS:[BUFFER+06H],0    ; Any relocation entries?
  70.     JNZ    OUTMSG                ; Yes, we can't handle it
  71.     CLD
  72.     MOV    CX,100H                ; Patch exe unpacker code
  73. FINDEX:    LODSB
  74.     CMP    AL,03H                ; Find code where exe unpacker
  75.     LOOPNZ    FINDEX                ; is about to transfer control
  76.     CMP    Word Ptr [SI],01F0H        ; to the now unpacked program
  77.     LOOPNZ    FINDEX
  78.     JNZ    OUTMSG
  79.     MOV    Byte Ptr [SI-1],0EAH        ; Replace it by a JMP Far
  80.     MOV    Word Ptr [SI],Offset UNPDON    ; straight to our own code
  81.     LODSW
  82.     MOV    Word Ptr [SI],CS
  83.     MOV    Byte Ptr [SI+2],9AH        ; Use overflow to a CALL Far
  84.     MOV    Word Ptr [SI+3],Offset WRIREL    ; island to our reloc table
  85.     MOV    Word Ptr [SI+5],CS        ; write routine
  86.     MOV    Byte Ptr [SI+7],0C3H        ; RET Near
  87.     MOV    BX,SI                ; Save call island offset
  88.     MOV    SI,Word Ptr CS:[BUFFER+14H]    ; Reload exe unpacker offset
  89.     MOV    CX,100H
  90. FINDRE:    LODSB
  91.     CMP    AL,26H                ; Look for ADD ES:[DI],DX
  92. FINDRX:    LOOPNZ    FINDRE
  93.     JCXZ    GOAHEA
  94.     CMP    Word Ptr [SI],1D01H
  95.     JNZ    FINDRX
  96.     MOV    Byte Ptr [SI-1],0E8H        ; Replace it to CALL Near to
  97.     SUB    BX,SI                ; our call island
  98.     MOV    [SI],BX
  99.     ADD    BX,SI
  100.     JMP    Short FINDRX            ; Repeat; there may be more
  101.  
  102. WERROR:    MOV    DX,Offset WRITXT
  103. OUTMSG:    MOV    AH,9
  104.     PUSH    CS
  105.     POP    DS
  106.     INT    21H                ; Write error message
  107.     MOV    AX,4C01H
  108.     INT    21H
  109.  
  110. GOAHEA    PROC    FAR                ; Declare for RET Far at end
  111.     MOV    AH,40H
  112.     MOV    BX,1
  113.     MOV    CX,1CH                ; Write exe header template:
  114.     XOR    DX,DX                ; Fill in real values later
  115.     INT    21H
  116.     JC    WERROR
  117.     PUSH    DS
  118.     PUSH    Word Ptr CS:[BUFFER+14H]    ; Jump to MS exe unpacker
  119.     PUSH    ES
  120.     POP    DS                ; DS and ES set up as expected
  121.     RET                    ; SS and SP is our stack but
  122. GOAHEA    ENDP                    ; the unpacker doesn't care
  123.  
  124. WRIREL    PROC    FAR
  125.     PUSH    AX
  126.     PUSH    BX
  127.     PUSH    CX
  128.     PUSH    DX
  129.     PUSH    DS
  130.     MOV    AX,ES                ; Compute real value
  131.     SUB    AX,Word Ptr CS:[EXEBASE]
  132.     PUSH    AX                ; Save reloc segment value
  133.     PUSH    DI                ; Save reloc offset value
  134.     MOV    AH,40H
  135.     MOV    BX,1
  136.     MOV    CX,4
  137.     MOV    DX,SP
  138.     PUSH    SS
  139.     POP    DS
  140.     INT    21H                ; Write reloc entry to file
  141. WERRO2:    JC    WERROR
  142.     INC    Word Ptr CS:[BUFFER+06H]    ; Increment reloc entry count
  143.     POP    AX
  144.     POP    AX
  145.     POP    DS
  146.     POP    DX
  147.     POP    CX
  148.     POP    BX
  149.     POP    AX
  150.     RET
  151. WRIREL    ENDP
  152.  
  153. UNPDON:    MOV    BP,DS                ; Save minimum allocation
  154.     LES    AX,Dword Ptr DS:[0]        ; Get CS:IP
  155.     PUSH    CS
  156.     POP    DS                ; Restore our DS
  157.     MOV    Word Ptr DS:[BUFFER+0EH],SI    ; Save SS
  158.     MOV    Word Ptr DS:[BUFFER+10H],DI    ; Save SP
  159.     MOV    Word Ptr DS:[BUFFER+14H],AX    ; Save IP
  160.     MOV    Word Ptr DS:[BUFFER+16H],ES    ; Save CS
  161.     MOV    DX,4
  162.     MOV    AX,7H
  163.     ADD    AX,Word Ptr CS:[BUFFER+06H]    ; Compute size written so far
  164.     MUL    DX
  165.     MOV    CX,AX
  166.     NEG    CX
  167.     AND    CH,1                ; Compute needed pad MOD 512
  168.     ADD    AX,CX                ; Compute size after padding
  169.     ADC    DX,0
  170.     SHR    DX,1                ; Convert it to paragraphs
  171.     RCR    AX,1
  172.     SHR    DX,1
  173.     RCR    AX,1
  174.     SHR    DX,1
  175.     RCR    AX,1
  176.     SHR    DX,1
  177.     RCR    AX,1
  178.     PUSH    AX
  179.     MOV    DX,Offset ZERBUF
  180.     MOV    AH,40H
  181.     MOV    BX,1
  182.     AND    CX,CX
  183.     JZ    NORADJ
  184.     INT    21H                ; Write pad bytes
  185.     JC    WERRO2
  186. NORADJ:    POP    BX
  187.     XCHG    Word Ptr DS:[BUFFER+08H],BX    ; Save padded size, paragraphs
  188.     MOV    DX,Offset BUFFER        ; (BX now image offse, para)
  189.     MOV    SI,DS
  190.     LEA    SI,[SI+BX+(Offset BUFFER-Offset START+100H)/10H] ; Image, para
  191.     MOV    AX,Word Ptr DS:[BUFFER+02H]
  192.     DEC    AX                ; Compute original size
  193.     AND    AX,1FFH
  194.     SHR    AX,1
  195.     SHR    AX,1
  196.     SHR    AX,1
  197.     SHR    AX,1
  198.     MOV    DX,Word Ptr DS:[BUFFER+04H]
  199.     SHL    DX,1
  200.     SHL    DX,1
  201.     SHL    DX,1
  202.     SHL    DX,1
  203.     SHL    DX,1
  204.     ADD    AX,DX
  205.     SUB    AX,20H-1
  206.     SUB    AX,BX
  207.     MOV    DS,SI
  208.     NEG    SI
  209.     LEA    SI,[SI+BP]
  210.     SUB    AX,SI
  211.     ADD    Word Ptr CS:[BUFFER+0AH],AX    ; New min allocation value
  212.     CMP    Word Ptr CS:[BUFFER+0CH],0FFFFH    ; Old max alloc = -1?
  213.     JZ    ALLMAX
  214.     ADD    Word Ptr CS:[BUFFER+0CH],AX    ; No, compute new max alloc
  215. ALLMAX:    MOV    AX,SI                ; Recompute file size
  216.     SHL    AL,1
  217.     SHL    AL,1
  218.     SHL    AL,1
  219.     MOV    AH,0
  220.     SHL    AX,1
  221.     MOV    Word Ptr CS:[BUFFER+02H],AX    ; Save size MOD 512
  222.     MOV    AX,SI                ; Get image size
  223.     ADD    AX,Word Ptr CS:[BUFFER+08H]    ; Get reloc size (= 0 MOD 512)
  224.     SHR    AX,1
  225.     SHR    AX,1
  226.     SHR    AX,1
  227.     SHR    AX,1
  228.     SHR    AX,1
  229.     TEST    SI,1FH                ; = 0 MOD 512 ?
  230.     JZ    EXACBL
  231.     INC    AX                ; No, add overflow "sector"
  232. EXACBL:    MOV    Word Ptr CS:[BUFFER+04H],AX    ; Save "sector" count
  233. WRILOP:    MOV    CX,SI
  234.     SHL    CX,1
  235.     SHL    CX,1
  236.     SHL    CX,1
  237.     SHL    CX,1
  238.     SUB    SI,0F80H
  239.     JB    WRILEX
  240.     MOV    CX,0F800H
  241. WRILEX:    MOV    AH,40H                ; Write all of image
  242.     MOV    BX,1
  243.     XOR    DX,DX
  244.     INT    21H
  245.     JC    WERRO3
  246.     MOV    AX,DS
  247.     ADD    AX,0F80H
  248.     MOV    DS,AX
  249.     CMP    SI,0F000H
  250.     JB    WRILOP
  251.  
  252.     MOV    AX,4200H            ; Seek to beginning of file
  253.     MOV    BX,1
  254.     XOR    CX,CX
  255.     XOR    DX,DX
  256.     INT    21H
  257.     JC    WERRO3
  258.     PUSH    CS
  259.     POP    DS
  260.     MOV    AH,40H                ; Write updated exe header
  261.     MOV    BX,1
  262.     MOV    CX,1CH
  263.     MOV    Word Ptr DS:[BUFFER+18H],CX    ; Fill in start of reloc table
  264.     MOV    DX,Offset BUFFER
  265. GOOEXI:    INT    21H
  266.     MOV    AX,4C00H
  267.     JNC    GOOEXI
  268. WERRO3:    JMP    WERROR
  269.  
  270. NOPTXT    DB    "File is not EXEpacked$"
  271. TOOTXT    DB    "Out of memory$"
  272. WRITXT    DB    "Write error$"
  273. REATXT    DB    "Read error$"
  274.  
  275. EXEBASE    Label    Word
  276.  
  277. ZERBUF    EQU    EXEBASE+2
  278.  
  279.     ORG    ZERBUF+1FCH-300H
  280. BUFALI:
  281.     ORG    $+((Offset START-Offset BUFALI) AND 15)
  282.  
  283. BUFFER    EQU    $+300H
  284.  
  285. CODE ENDS
  286.     END    START
  287.