Skip to content

Commit eaa7dba

Browse files
PatriceJiangPatriceJiang
authored
Merge pull request #384 from PatriceJiang/upgrade_unzip_to_1.2
Upgrade unzip to 1.2
2 parents 7581699 + e2b5974 commit eaa7dba

File tree

7 files changed

+2362
-2663
lines changed

7 files changed

+2362
-2663
lines changed

‎unzip/crypt.h

+125-87
Original file line numberDiff line numberDiff line change
@@ -1,130 +1,168 @@
11
/* crypt.h -- base code for traditional PKWARE encryption
2-
Version 1.01e, February 12th, 2005
2+
Version 1.2.0, September 16th, 2017
33
4+
Copyright (C) 2012-2017 Nathan Moinvaziri
5+
https://github.com/nmoinvaz/minizip
46
Copyright (C) 1998-2005 Gilles Vollant
5-
Modifications for Info-ZIP crypting
6-
Copyright (C) 2003 Terry Thorsen
7+
Modifications for Info-ZIP crypting
8+
http://www.winimage.com/zLibDll/minizip.html
9+
Copyright (C) 2003 Terry Thorsen
710
811
This code is a modified version of crypting code in Info-ZIP distribution
912
1013
Copyright (C) 1990-2000 Info-ZIP. All rights reserved.
1114
12-
See the Info-ZIP LICENSE file version 2000-Apr-09 or later for terms of use
13-
which also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
15+
This program is distributed under the terms of the same license as zlib.
16+
See the accompanying LICENSE file for the full text of the license.
17+
*/
1418

15-
The encryption/decryption parts of this source code (as opposed to the
16-
non-echoing password parts) were originally written in Europe. The
17-
whole source package can be freely distributed, including from the USA.
18-
(Prior to January 2000, re-export from the US was a violation of US law.)
19+
#ifndef _MINICRYPT_H
20+
#define _MINICRYPT_H
1921

20-
This encryption code is a direct transcription of the algorithm from
21-
Roger Schlafly, described by Phil Katz in the file appnote.txt. This
22-
file (appnote.txt) is distributed with the PKZIP program (even in the
23-
version without encryption capabilities).
22+
#include <stdint.h>
23+
#include <stdlib.h>
24+
#include <time.h>
2425

25-
If you don't need crypting in your application, just define symbols
26-
NOCRYPT and NOUNCRYPT.
27-
*/
26+
# ifndef ZCR_SEED2
27+
# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
28+
# endif
29+
30+
#if ZLIB_VERNUM < 0x1270
31+
typedef unsigned long z_crc_t;
32+
#endif
33+
34+
#define RAND_HEAD_LEN 12
35+
36+
/***************************************************************************/
37+
38+
#define CRC32(c, b) ((*(pcrc_32_tab+(((uint32_t)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
39+
40+
/***************************************************************************/
41+
42+
#define zdecode(pkeys,pcrc_32_tab,c) \
43+
(update_keys(pkeys,pcrc_32_tab, c ^= decrypt_byte(pkeys)))
44+
45+
#define zencode(pkeys,pcrc_32_tab,c,t) \
46+
(t = decrypt_byte(pkeys), update_keys(pkeys,pcrc_32_tab,c), t^(c))
2847

29-
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
48+
/***************************************************************************/
3049

31-
/***********************************************************************
32-
* Return the next byte in the pseudo-random sequence
33-
*/
34-
static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
50+
/* Return the next byte in the pseudo-random sequence */
51+
static uint8_t decrypt_byte(uint32_t *pkeys)
3552
{
3653
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
37-
* unpredictable manner on 16-bit systems; not a problem
38-
* with any known compiler so far, though */
54+
* unpredictable manner on 16-bit systems; not a problem
55+
* with any known compiler so far, though */
3956

40-
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
41-
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
57+
temp = ((uint32_t)(*(pkeys + 2)) & 0xffff) | 2;
58+
return (uint8_t)(((temp * (temp ^ 1)) >> 8) & 0xff);
4259
}
4360

44-
/***********************************************************************
45-
* Update the encryption keys with the next byte of plain text
46-
*/
47-
static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
61+
/* Update the encryption keys with the next byte of plain text */
62+
static uint8_t update_keys(uint32_t *pkeys, const z_crc_t *pcrc_32_tab, int32_t c)
4863
{
49-
(*(pkeys+0)) = CRC32((*(pkeys+0)), c);
50-
(*(pkeys+1)) += (*(pkeys+0)) & 0xff;
51-
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
64+
(*(pkeys + 0)) = (uint32_t)CRC32((*(pkeys + 0)), c);
65+
(*(pkeys + 1)) += (*(pkeys + 0)) & 0xff;
66+
(*(pkeys + 1)) = (*(pkeys + 1)) * 134775813L + 1;
5267
{
53-
register int keyshift = (int)((*(pkeys+1)) >> 24);
54-
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
68+
int32_t keyshift = (int32_t)((*(pkeys + 1)) >> 24);
69+
(*(pkeys + 2)) = (uint32_t)CRC32((*(pkeys + 2)), keyshift);
5570
}
5671
return c;
5772
}
5873

59-
60-
/***********************************************************************
61-
* Initialize the encryption keys and the random header according to
62-
* the given password.
63-
*/
64-
static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
74+
/* Initialize the encryption keys and the random header according to the given password. */
75+
static void init_keys(const char *passwd, uint32_t *pkeys, const z_crc_t *pcrc_32_tab)
6576
{
66-
*(pkeys+0) = 305419896L;
67-
*(pkeys+1) = 591751049L;
68-
*(pkeys+2) = 878082192L;
69-
while (*passwd != 0) {
70-
update_keys(pkeys,pcrc_32_tab,(int)*passwd);
71-
passwd++;
77+
*(pkeys + 0) = 305419896L;
78+
*(pkeys + 1) = 591751049L;
79+
*(pkeys + 2) = 878082192L;
80+
while (*passwd != 0)
81+
{
82+
update_keys(pkeys, pcrc_32_tab, *passwd);
83+
passwd += 1;
7284
}
7385
}
7486

75-
#define zdecode(pkeys,pcrc_32_tab,c) \
76-
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
77-
78-
#define zencode(pkeys,pcrc_32_tab,c,t) \
79-
(t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
80-
81-
#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
82-
83-
#define RAND_HEAD_LEN 12
84-
/* "last resort" source for second part of crypt seed pattern */
85-
# ifndef ZCR_SEED2
86-
# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
87-
# endif
88-
89-
static int crypthead(const char* passwd, /* password string */
90-
unsigned char* buf, /* where to write header */
91-
int bufSize,
92-
unsigned long* pkeys,
93-
const unsigned long* pcrc_32_tab,
94-
unsigned long crcForCrypting)
87+
#ifndef NOCRYPT
88+
/* Generate cryptographically secure random numbers */
89+
static int cryptrand(unsigned char *buf, unsigned int len)
9590
{
96-
int n; /* index in random header */
97-
int t; /* temporary */
98-
int c; /* random byte */
99-
unsigned char header[RAND_HEAD_LEN-2]; /* random header */
100-
static unsigned calls = 0; /* ensure different random header each time */
91+
/*
92+
Important This API is deprecated. New and existing software should
93+
start using Cryptography Next Generation APIs.
94+
Microsoft may remove this API in future releases.
95+
see: https://docs.microsoft.com/zh-cn/windows/desktop/api/wincrypt/nf-wincrypt-cryptgenrandom
96+
*/
97+
#define CRYPTGENRANDOM_DEPRECATED 1
98+
#if defined(_WIN32) && !defined(CRYPTGENRANDOM_DEPRECATED)
99+
HCRYPTPROV provider;
100+
unsigned __int64 pentium_tsc[1];
101+
int rlen = 0;
102+
int result = 0;
103+
104+
105+
if (CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
106+
{
107+
result = CryptGenRandom(provider, len, buf);
108+
CryptReleaseContext(provider, 0);
109+
if (result)
110+
return len;
111+
}
101112

102-
if (bufSize<RAND_HEAD_LEN)
103-
return 0;
113+
for (rlen = 0; rlen < (int)len; ++rlen)
114+
{
115+
if (rlen % 8 == 0)
116+
QueryPerformanceCounter((LARGE_INTEGER *)pentium_tsc);
117+
buf[rlen] = ((unsigned char*)pentium_tsc)[rlen % 8];
118+
}
104119

120+
return rlen;
121+
#else
122+
static unsigned calls = 0; /* ensure different random header each time */
105123
/* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
106-
* output of rand() to get less predictability, since rand() is
107-
* often poorly implemented.
108-
*/
124+
* output of rand() to get less predictability, since rand() is
125+
* often poorly implemented.
126+
*/
109127
if (++calls == 1)
110128
{
111129
srand((unsigned)(time(NULL) ^ ZCR_SEED2));
112130
}
113-
init_keys(passwd, pkeys, pcrc_32_tab);
114-
for (n = 0; n < RAND_HEAD_LEN-2; n++)
115-
{
116-
c = (rand() >> 7) & 0xff;
117-
header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
131+
for(unsigned int i = 0; i < len; ++i){
132+
buf[i] = rand() % 256;
118133
}
134+
return len;
135+
#endif
136+
}
137+
138+
/* Create encryption header */
139+
static int crypthead(const char *passwd, uint8_t *buf, int buf_size, uint32_t *pkeys,
140+
const z_crc_t *pcrc_32_tab, uint8_t verify1, uint8_t verify2)
141+
{
142+
uint8_t n = 0; /* index in random header */
143+
uint8_t header[RAND_HEAD_LEN - 2]; /* random header */
144+
uint16_t t = 0; /* temporary */
145+
146+
if (buf_size < RAND_HEAD_LEN)
147+
return 0;
148+
149+
init_keys(passwd, pkeys, pcrc_32_tab);
150+
151+
/* First generate RAND_HEAD_LEN-2 random bytes. */
152+
cryptrand(header, RAND_HEAD_LEN - 2);
153+
119154
/* Encrypt random header (last two bytes is high word of crc) */
120155
init_keys(passwd, pkeys, pcrc_32_tab);
121-
for (n = 0; n < RAND_HEAD_LEN-2; n++)
122-
{
123-
buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
124-
}
125-
buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
126-
buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
156+
157+
for (n = 0; n < RAND_HEAD_LEN - 2; n++)
158+
buf[n] = (uint8_t)zencode(pkeys, pcrc_32_tab, header[n], t);
159+
160+
buf[n++] = (uint8_t)zencode(pkeys, pcrc_32_tab, verify1, t);
161+
buf[n++] = (uint8_t)zencode(pkeys, pcrc_32_tab, verify2, t);
127162
return n;
128163
}
164+
#endif
165+
166+
/***************************************************************************/
129167

130168
#endif

0 commit comments

Comments
 (0)