📄 zip.cod
字号:
; 307 : { /* data overflow - hack for ZIP64 */
; 308 : for (n = 0; n < nbByte; n++)
00017 85 d2 test edx, edx
00019 7e 0f jle SHORT $LN3@ziplocal_p
0001b 52 push edx
0001c 68 ff 00 00 00 push 255 ; 000000ffH
00021 56 push esi
00022 e8 00 00 00 00 call _memset
00027 83 c4 0c add esp, 12 ; 0000000cH
$LN3@ziplocal_p:
; 309 : {
; 310 : buf[n] = 0xff;
; 311 : }
; 312 : }
; 313 : }
0002a c3 ret 0
_ziplocal_putValue_inmemory ENDP
; Function compile flags: /Ogtpy
_TEXT ENDS
; COMDAT _ziplocal_putValue
_TEXT SEGMENT
_buf$ = -4 ; size = 4
_filestream$ = 8 ; size = 4
_ziplocal_putValue PROC ; COMDAT
; _pzlib_filefunc_def$ = edi
; _x$ = ecx
; _nbByte$ = esi
; 271 : {
00000 51 push ecx
; 272 : unsigned char buf[4];
; 273 : int n;
; 274 : for (n = 0; n < nbByte; n++)
00001 33 c0 xor eax, eax
00003 85 f6 test esi, esi
00005 7e 0d jle SHORT $LN7@ziplocal_p@2
$LL9@ziplocal_p@2:
; 275 : {
; 276 : buf[n] = (unsigned char)(x & 0xff);
00007 88 0c 04 mov BYTE PTR _buf$[esp+eax+4], cl
0000a 83 c0 01 add eax, 1
; 277 : x >>= 8;
0000d c1 e9 08 shr ecx, 8
00010 3b c6 cmp eax, esi
00012 7c f3 jl SHORT $LL9@ziplocal_p@2
$LN7@ziplocal_p@2:
; 278 : }
; 279 : if (x != 0)
00014 85 c9 test ecx, ecx
00016 74 17 je SHORT $LN5@ziplocal_p@2
; 280 : { /* data overflow - hack for ZIP64 (X Roche) */
; 281 : for (n = 0; n < nbByte; n++)
00018 85 f6 test esi, esi
0001a 7e 13 jle SHORT $LN5@ziplocal_p@2
0001c 56 push esi
0001d 8d 44 24 04 lea eax, DWORD PTR _buf$[esp+8]
00021 68 ff 00 00 00 push 255 ; 000000ffH
00026 50 push eax
00027 e8 00 00 00 00 call _memset
0002c 83 c4 0c add esp, 12 ; 0000000cH
$LN5@ziplocal_p@2:
; 282 : {
; 283 : buf[n] = 0xff;
; 284 : }
; 285 : }
; 286 :
; 287 : if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
0002f 8b 54 24 08 mov edx, DWORD PTR _filestream$[esp]
00033 8b 47 1c mov eax, DWORD PTR [edi+28]
00036 56 push esi
00037 8d 4c 24 04 lea ecx, DWORD PTR _buf$[esp+8]
0003b 51 push ecx
0003c 8b 4f 08 mov ecx, DWORD PTR [edi+8]
0003f 52 push edx
00040 50 push eax
00041 ff d1 call ecx
00043 2b c6 sub eax, esi
00045 f7 d8 neg eax
00047 1b c0 sbb eax, eax
; 288 : return ZIP_ERRNO;
; 289 : else
; 290 : return ZIP_OK;
; 291 : }
00049 83 c4 14 add esp, 20 ; 00000014H
0004c c3 ret 0
_ziplocal_putValue ENDP
; Function compile flags: /Ogtpy
_TEXT ENDS
; COMDAT _init_linkedlist
_TEXT SEGMENT
_init_linkedlist PROC ; COMDAT
; _ll$ = eax
; 189 : ll->first_block = ll->last_block = NULL;
00000 c7 40 04 00 00
00 00 mov DWORD PTR [eax+4], 0
00007 c7 00 00 00 00
00 mov DWORD PTR [eax], 0
; 190 : }
0000d c3 ret 0
_init_linkedlist ENDP
; Function compile flags: /Ogtpy
_TEXT ENDS
; COMDAT _free_datablock
_TEXT SEGMENT
_free_datablock PROC ; COMDAT
; _ldi$ = eax
; 178 : while (ldi!=NULL)
00000 85 c0 test eax, eax
00002 74 1c je SHORT $LN2@free_datab
00004 56 push esi
00005 57 push edi
00006 8b 3d 00 00 00
00 mov edi, DWORD PTR __imp__free
0000c 8d 64 24 00 npad 4
$LL3@free_datab:
; 179 : {
; 180 : linkedlist_datablock_internal* ldinext = ldi->next_datablock;
00010 8b 30 mov esi, DWORD PTR [eax]
; 181 : TRYFREE(ldi);
00012 50 push eax
00013 ff d7 call edi
00015 83 c4 04 add esp, 4
00018 85 f6 test esi, esi
; 182 : ldi = ldinext;
0001a 8b c6 mov eax, esi
0001c 75 f2 jne SHORT $LL3@free_datab
0001e 5f pop edi
0001f 5e pop esi
$LN2@free_datab:
; 183 : }
; 184 : }
00020 c3 ret 0
_free_datablock ENDP
; Function compile flags: /Ogtpy
_TEXT ENDS
; COMDAT _allocate_new_datablock
_TEXT SEGMENT
_allocate_new_datablock PROC ; COMDAT
; 163 : linkedlist_datablock_internal* ldi;
; 164 : ldi = (linkedlist_datablock_internal*)
; 165 : ALLOC(sizeof(linkedlist_datablock_internal));
00000 68 00 10 00 00 push 4096 ; 00001000H
00005 ff 15 00 00 00
00 call DWORD PTR __imp__malloc
0000b 83 c4 04 add esp, 4
; 166 : if (ldi!=NULL)
0000e 85 c0 test eax, eax
00010 74 14 je SHORT $LN1@allocate_n
; 167 : {
; 168 : ldi->next_datablock = NULL ;
00012 c7 00 00 00 00
00 mov DWORD PTR [eax], 0
; 169 : ldi->filled_in_this_block = 0 ;
00018 c7 40 08 00 00
00 00 mov DWORD PTR [eax+8], 0
; 170 : ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
0001f c7 40 04 f0 0f
00 00 mov DWORD PTR [eax+4], 4080 ; 00000ff0H
$LN1@allocate_n:
; 171 : }
; 172 : return ldi;
; 173 : }
00026 c3 ret 0
_allocate_new_datablock ENDP
; Function compile flags: /Ogtpy
; File d:\src\vs2005\cpp\ceremoteclient\zlib123\contrib\minizip\crypt.h
_TEXT ENDS
; COMDAT _update_keys
_TEXT SEGMENT
_update_keys PROC ; COMDAT
; _pkeys$ = esi
; _pcrc_32_tab$ = edi
; _c$ = eax
; 50 : (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
00000 8b 0e mov ecx, DWORD PTR [esi]
00002 8b d1 mov edx, ecx
00004 33 d0 xor edx, eax
00006 c1 e9 08 shr ecx, 8
00009 81 e2 ff 00 00
00 and edx, 255 ; 000000ffH
0000f 8b 14 97 mov edx, DWORD PTR [edi+edx*4]
00012 33 d1 xor edx, ecx
; 51 : (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
00014 0f b6 ca movzx ecx, dl
; 52 : (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
00017 03 4e 04 add ecx, DWORD PTR [esi+4]
0001a 89 16 mov DWORD PTR [esi], edx
; 53 : {
; 54 : register int keyshift = (int)((*(pkeys+1)) >> 24);
; 55 : (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
0001c 8b 56 08 mov edx, DWORD PTR [esi+8]
0001f 69 c9 05 84 08
08 imul ecx, 134775813 ; 08088405H
00025 83 c1 01 add ecx, 1
00028 89 4e 04 mov DWORD PTR [esi+4], ecx
0002b c1 e9 18 shr ecx, 24 ; 00000018H
0002e 33 ca xor ecx, edx
00030 81 e1 ff 00 00
00 and ecx, 255 ; 000000ffH
00036 c1 ea 08 shr edx, 8
00039 33 14 8f xor edx, DWORD PTR [edi+ecx*4]
0003c 89 56 08 mov DWORD PTR [esi+8], edx
; 56 : }
; 57 : return c;
; 58 : }
0003f c3 ret 0
_update_keys ENDP
; Function compile flags: /Ogtpy
_TEXT ENDS
; COMDAT _decrypt_byte
_TEXT SEGMENT
_decrypt_byte PROC ; COMDAT
; _pkeys$ = eax
; 37 : unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
; 38 : * unpredictable manner on 16-bit systems; not a problem
; 39 : * with any known compiler so far, though */
; 40 :
; 41 : temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
00000 8b 40 08 mov eax, DWORD PTR [eax+8]
00003 25 fd ff 00 00 and eax, 65533 ; 0000fffdH
00008 83 c8 02 or eax, 2
; 42 : return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
0000b 8b c8 mov ecx, eax
0000d 83 f1 01 xor ecx, 1
00010 0f af c8 imul ecx, eax
00013 0f b6 c5 movzx eax, ch
; 43 : }
00016 c3 ret 0
_decrypt_byte ENDP
; Function compile flags: /Ogtpy
; File c:\program files\microsoft visual studio 8\vc\include\time.inl
_TEXT ENDS
; COMDAT _time
_TEXT SEGMENT
_time PROC ; COMDAT
; 135 : return _time64(_Time);
00000 6a 00 push 0
00002 ff 15 00 00 00
00 call DWORD PTR __imp___time64
00008 83 c4 04 add esp, 4
; 136 : }
0000b c3 ret 0
_time ENDP
; Function compile flags: /Ogtpy
; File d:\src\vs2005\cpp\ceremoteclient\zlib123\contrib\minizip\zip.c
; COMDAT _zipFlushWriteBuffer
_TEXT SEGMENT
_t$80918 = -8 ; size = 4
tv216 = -4 ; size = 4
_zipFlushWriteBuffer PROC ; COMDAT
; _zi$ = ebx
; 946 : {
00000 83 ec 08 sub esp, 8
; 947 : int err=ZIP_OK;
; 948 :
; 949 : if (zi->ci.encrypt != 0)
00003 83 bb 90 40 00
00 00 cmp DWORD PTR [ebx+16528], 0
0000a 74 56 je SHORT $LN2@zipFlushWr
; 950 : {
; 951 : #ifndef NOCRYPT
; 952 : uInt i;
; 953 : int t;
; 954 : for (i=0;i<zi->ci.pos_in_buffered_data;i++)
0000c 83 7b 6c 00 cmp DWORD PTR [ebx+108], 0
00010 76 50 jbe SHORT $LN2@zipFlushWr
00012 55 push ebp
00013 b8 78 ff ff ff mov eax, -136 ; ffffff78H
00018 56 push esi
00019 2b c3 sub eax, ebx
0001b 57 push edi
0001c 8d b3 94 40 00
00 lea esi, DWORD PTR [ebx+16532]
00022 8d ab 88 00 00
00 lea ebp, DWORD PTR [ebx+136]
00028 89 44 24 10 mov DWORD PTR tv216[esp+20], eax
0002c 8d 64 24 00 npad 4
$LL4@zipFlushWr:
; 955 : zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
; 956 : zi->ci.buffered_data[i],t);
00030 8b c6 mov eax, esi
00032 e8 00 00 00 00 call _decrypt_byte
00037 8b bb a0 40 00
00 mov edi, DWORD PTR [ebx+16544]
0003d 89 44 24 0c mov DWORD PTR _t$80918[esp+20], eax
00041 0f b6 45 00 movzx eax, BYTE PTR [ebp]
00045 e8 00 00 00 00 call _update_keys
0004a 8a 44 24 0c mov al, BYTE PTR _t$80918[esp+20]
0004e 30 45 00 xor BYTE PTR [ebp], al
00051 8b 4c 24 10 mov ecx, DWORD PTR tv216[esp+20]
00055 83 c5 01 add ebp, 1
00058 03 cd add ecx, ebp
0005a 3b 4b 6c cmp ecx, DWORD PTR [ebx+108]
0005d 72 d1 jb SHORT $LL4@zipFlushWr
0005f 5f pop edi
00060 5e pop esi
00061 5d pop ebp
$LN2@zipFlushWr:
; 957 : #endif
; 958 : }
; 959 : if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
; 960 : !=zi->ci.pos_in_buffered_data)
00062 8b 53 6c mov edx, DWORD PTR [ebx+108]
00065 8b 4b 20 mov ecx, DWORD PTR [ebx+32]
00068 52 push edx
00069 8b 53 1c mov edx, DWORD PTR [ebx+28]
0006c 8d 83 88 00 00
00 lea eax, DWORD PTR [ebx+136]
00072 50 push eax
00073 8b 43 08 mov eax, DWORD PTR [ebx+8]
00076 51 push ecx
00077 52 push edx
00078 ff d0 call eax
0007a 83 c4 10 add esp, 16 ; 00000010H
0007d 3b 43 6c cmp eax, DWORD PTR [ebx+108]
; 962 : zi->ci.pos_in_buffered_data = 0;
00080 c7 43 6c 00 00
00 00 mov DWORD PTR [ebx+108], 0
00087 74 07 je SHORT $LN10@zipFlushWr
; 961 : err = ZIP_ERRNO;
00089 83 c8 ff or eax, -1
; 964 : }
0008c 83 c4 08 add esp, 8
0008f c3 ret 0
$LN10@zipFlushWr:
; 963 : return err;
00090 33 c0 xor eax, eax
; 964 : }
00092 83 c4 08 add esp, 8
00095 c3 ret 0
_zipFlushWriteBuffer ENDP
; Function compile flags: /Ogtpy
_TEXT ENDS
; COMDAT _ziplocal_getLong
_TEXT SEGMENT
_i$ = -4 ; size = 4
_pX$ = 8 ; size = 4
_ziplocal_getLong PROC ; COMDAT
; _pzlib_filefunc_def$ = ecx
; _filestream$ = eax
; 402 : {
00000 51 push ecx
00001 53 push ebx
00002 55 push ebp
00003 8b 6c 24 10 mov ebp, DWORD PTR _pX$[esp+8]
00007 56 push esi
00008 57 push edi
00009 8b f8 mov edi, eax
; 403 : uLong x ;
; 404 : int i;
; 405 : int err;
; 406 :
; 407 : err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
0000b 8d 44 24 10 lea eax, DWORD PTR _i$[esp+20]
0000f 8b f1 mov esi, ecx
00011 50 push eax
00012 e8 00 00 00 00 call _ziplocal_getByte
; 408 : x = (uLong)i;
00017 8b 4c 24 14 mov ecx, DWORD PTR _i$[esp+24]
0001b 83 c4 04 add esp, 4
; 409 :
; 410 : if (err==ZIP_OK)
0001e 85 c0 test eax, eax
00020 8b d9 mov ebx, ecx
00022 75 11 jne SHORT $LN5@ziplocal_g@2
; 411 : err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
00024 8d 4c 24 10 lea ecx, DWORD PTR _i$[esp+20]
00028 51 push ecx
00029 e8 00 00 00 00 call _ziplocal_getByte
0002e 8b 4c 24 14 mov ecx, DWORD PTR _i$[esp+24]
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -