bump support for minizip to 3.0.6

Author: jhudsonWA

.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

@@ -1,5 +1,5 @@
 PODS:
-  - SSZipArchive (2.5.0)
+  - SSZipArchive (2.5.1)
 
 DEPENDENCIES:
   - SSZipArchive (from `..`)
@@ -9,7 +9,7 @@ EXTERNAL SOURCES:
     :path: ".."
 
 SPEC CHECKSUMS:
-  SSZipArchive: 47b4ac3dbcb37e319bde9dd3a706f627de1d77d3
+  SSZipArchive: 838576d09fe0196781dacb1c589d193604d22353
 
 PODFILE CHECKSUM: 570af5c3534cb262ca98be3dedfff7caa40f00ed
 

Example/Podfile.lock

@@ -24,6 +24,7 @@ let package = Package(
                 .define("HAVE_STDINT_H"),
                 .define("HAVE_WZAES"),
                 .define("HAVE_ZLIB"),
+                .define("ZLIB_COMPAT")
             ],
             linkerSettings: [
                 .linkedLibrary("z"),

Package.swift

@@ -30,25 +30,23 @@ The following steps should be taken by project maintainers when they update mini
 2. Have cmake:
 `brew install cmake`
 3. Run cmake on minizip repo with our desired configuration:
-`cmake . -DMZ_BZIP2=OFF -DMZ_LZMA=OFF`
+`cmake . -DMZ_BZIP2=OFF -DMZ_LZMA=OFF -DMZ_ZLIB=ON -DMZ_LIBCOMP=OFF`
 4. Look at the file `./CMakeFiles/minizip.dir/DependInfo.cmake` it will give you the following information:
 - The list of C files that we need to include.
 
-Note: It will suggest we include libcomp and that only works on macos 10.11 and up, so the .c and .h file should not be included until we bump the min os versions.
-
 5. Look at the file `./CMakeFiles/minizip.dir/flags.make` it will give you the following information:
 
-- The list of compiler flags that we need to include 
+- The list of compiler flags that we need to include (as of minizip 3.0.5 we have to include either zlib-ng OR ZLIB_COMPAT)
 
 Note: These should not be changed unless you have issues compiling or we bump the min os versions. 
 
-HAVE_INTTYPES_H HAVE_PKCRYPT HAVE_STDINT_H HAVE_WZAES HAVE_ZLIB
+HAVE_INTTYPES_H HAVE_PKCRYPT HAVE_STDINT_H HAVE_WZAES HAVE_ZLIB ZLIB_COMPAT
 
 With the exception of the last two: "MZ_ZIP_SIGNING" "_POSIX_C_SOURCE=200112L"
 
-With later version of minizip it will want to switch to libcomp it will suggest we include libcomp and that only works on macos 10.11 and up.
 
 6. Set those flags in SSZipArchive.podspec (for CocoaPods) and in ZipArchive.xcodeproj (for Carthage)
+
 7. Replace the .h and .c files with the latest ones, except for `mz_compat.h`, which is customized to expose some struct in SSZipCommon.h and to provide support for optional aes.
 
-Note: we can also use `cmake -G Xcode . -DMZ_BZIP2=OFF -DMZ_LZMA=OFF` to get the list of files to include in an xcodeproj of its own, from where we can remove unneeded `zip.h` and `unzip.h`.
+Note: we can also use `cmake -G Xcode . -DMZ_BZIP2=OFF -DMZ_LZMA=OFF -DMZ_ZLIB=ON -DMZ_LIBCOMP=OFF` to get the list of files to include in an xcodeproj of its own, from where we can remove unneeded `zip.h` and `unzip.h`.

Release-Instructions.md

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = 'SSZipArchive'
-  s.version      = '2.5.0'
+  s.version      = '2.5.1'
   s.summary      = 'Utility class for zipping and unzipping files on iOS, tvOS, watchOS, and macOS.'
   s.description  = 'SSZipArchive is a simple utility class for zipping and unzipping files on iOS, tvOS, watchOS, and macOS. It supports AES and PKWARE encryption.'
   s.homepage     = 'https://github.com/ZipArchive/ZipArchive'
@@ -16,5 +16,5 @@ Pod::Spec.new do |s|
   s.libraries = 'z', 'iconv'
   s.framework = 'Security'
   s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES',
-    'GCC_PREPROCESSOR_DEFINITIONS' => 'HAVE_INTTYPES_H HAVE_PKCRYPT HAVE_STDINT_H HAVE_WZAES HAVE_ZLIB' }
+    'GCC_PREPROCESSOR_DEFINITIONS' => 'HAVE_INTTYPES_H HAVE_PKCRYPT HAVE_STDINT_H HAVE_WZAES HAVE_ZLIB ZLIB_COMPAT' }
 end

SSZipArchive.podspec

@@ -14,8 +14,8 @@
 /***************************************************************************/
 
 /* MZ_VERSION */
-#define MZ_VERSION                      ("3.0.4")
-#define MZ_VERSION_BUILD                (030004)
+#define MZ_VERSION                      ("3.0.6")
+#define MZ_VERSION_BUILD                (030006)
 
 /* MZ_ERROR */
 #define MZ_OK                           (0)  /* zlib */
@@ -126,8 +126,14 @@
 #define MZ_HASH_MD5_SIZE                (16)
 #define MZ_HASH_SHA1                    (20)
 #define MZ_HASH_SHA1_SIZE               (20)
+#define MZ_HASH_SHA224                  (22)
+#define MZ_HASH_SHA224_SIZE             (28)
 #define MZ_HASH_SHA256                  (23)
 #define MZ_HASH_SHA256_SIZE             (32)
+#define MZ_HASH_SHA384                  (24)
+#define MZ_HASH_SHA384_SIZE             (48)
+#define MZ_HASH_SHA512                  (25)
+#define MZ_HASH_SHA512_SIZE             (64)
 #define MZ_HASH_MAX_SIZE                (256)
 
 /* MZ_ENCODING */

SSZipArchive/minizip/mz.h

@@ -14,31 +14,17 @@
 #include "mz_crypt.h"
 
 #if defined(HAVE_ZLIB)
-#  include "zlib.h"
-#  if defined(ZLIBNG_VERNUM) && !defined(ZLIB_COMPAT)
+#  if !defined(ZLIB_COMPAT)
 #    include "zlib-ng.h"
+#    define ZLIB_PREFIX(x) zng_ ## x
+#  else
+#    include "zlib.h"
+#    define ZLIB_PREFIX(x) x
 #  endif
 #elif defined(HAVE_LZMA)
 #  include "lzma.h"
 #endif
 
-/***************************************************************************/
-/* Define z_crc_t in zlib 1.2.5 and less or if using zlib-ng */
-
-#if defined(HAVE_ZLIB) && defined(ZLIBNG_VERNUM)
-#  if defined(ZLIB_COMPAT)
-#    define ZLIB_PREFIX(x) x
-#  else
-#    define ZLIB_PREFIX(x) zng_ ## x
-#  endif
-   typedef uint32_t z_crc_t;
-#elif defined(HAVE_ZLIB)
-#  define ZLIB_PREFIX(x) x
-#  if (ZLIB_VERNUM < 0x1270)
-     typedef unsigned long z_crc_t;
-#  endif
-#endif
-
 /***************************************************************************/
 
 #if defined(MZ_ZIP_NO_CRYPTO)
@@ -49,6 +35,12 @@ int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
 
 uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size) {
 #if defined(HAVE_ZLIB)
+   /* Define z_crc_t in zlib 1.2.5 and less or if using zlib-ng */
+#  if (ZLIB_VERNUM < 0x1270)
+    typedef unsigned long z_crc_t;
+#  else
+    typedef uint32_t z_crc_t;
+#  endif
     return (uint32_t)ZLIB_PREFIX(crc32)((z_crc_t)value, buf, (uInt)size);
 #elif defined(HAVE_LZMA)
     return (uint32_t)lzma_crc32(buf, (size_t)size, (uint32_t)value);

SSZipArchive/minizip/mz_crypt.c

@@ -29,15 +29,25 @@ int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
 /***************************************************************************/
 
 typedef struct mz_crypt_sha_s {
-    CC_SHA1_CTX     ctx1;
-    CC_SHA256_CTX   ctx256;
-    int32_t         error;
-    int32_t         initialized;
-    uint16_t        algorithm;
+    union {
+        CC_SHA1_CTX   ctx1;
+        CC_SHA256_CTX ctx256;
+        CC_SHA512_CTX ctx512;
+    };
+    int32_t           error;
+    int32_t           initialized;
+    uint16_t          algorithm;
 } mz_crypt_sha;
 
 /***************************************************************************/
 
+static const uint8_t mz_crypt_sha_digest_size[] = {
+    MZ_HASH_SHA1_SIZE,                     0, MZ_HASH_SHA224_SIZE,
+    MZ_HASH_SHA256_SIZE, MZ_HASH_SHA384_SIZE, MZ_HASH_SHA512_SIZE
+};
+
+/***************************************************************************/
+
 void mz_crypt_sha_reset(void *handle) {
     mz_crypt_sha *sha = (mz_crypt_sha *)handle;
 
@@ -53,12 +63,25 @@ int32_t mz_crypt_sha_begin(void *handle) {
 
     mz_crypt_sha_reset(handle);
 
-    if (sha->algorithm == MZ_HASH_SHA1)
+    switch (sha->algorithm) {
+    case MZ_HASH_SHA1:
         sha->error = CC_SHA1_Init(&sha->ctx1);
-    else if (sha->algorithm == MZ_HASH_SHA256)
+        break;
+    case MZ_HASH_SHA224:
+        sha->error = CC_SHA224_Init(&sha->ctx256);
+        break;
+    case MZ_HASH_SHA256:
         sha->error = CC_SHA256_Init(&sha->ctx256);
-    else
+        break;
+    case MZ_HASH_SHA384:
+        sha->error = CC_SHA384_Init(&sha->ctx512);
+        break;
+    case MZ_HASH_SHA512:
+        sha->error = CC_SHA512_Init(&sha->ctx512);
+        break;
+    default:
         return MZ_PARAM_ERROR;
+    }
 
     if (!sha->error)
         return MZ_HASH_ERROR;
@@ -73,10 +96,23 @@ int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size) {
     if (sha == NULL || buf == NULL || !sha->initialized)
         return MZ_PARAM_ERROR;
 
-    if (sha->algorithm == MZ_HASH_SHA1)
+    switch (sha->algorithm) {
+    case MZ_HASH_SHA1:
         sha->error = CC_SHA1_Update(&sha->ctx1, buf, size);
-    else
+        break;
+    case MZ_HASH_SHA224:
+        sha->error = CC_SHA224_Update(&sha->ctx256, buf, size);
+        break;
+    case MZ_HASH_SHA256:
         sha->error = CC_SHA256_Update(&sha->ctx256, buf, size);
+        break;
+    case MZ_HASH_SHA384:
+        sha->error = CC_SHA384_Update(&sha->ctx512, buf, size);
+        break;
+    case MZ_HASH_SHA512:
+        sha->error = CC_SHA512_Update(&sha->ctx512, buf, size);
+        break;
+    }
 
     if (!sha->error)
         return MZ_HASH_ERROR;
@@ -89,15 +125,25 @@ int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size) {
 
     if (sha == NULL || digest == NULL || !sha->initialized)
         return MZ_PARAM_ERROR;
+    if (digest_size < mz_crypt_sha_digest_size[sha->algorithm - MZ_HASH_SHA1])
+        return MZ_PARAM_ERROR;
 
-    if (sha->algorithm == MZ_HASH_SHA1) {
-        if (digest_size < MZ_HASH_SHA1_SIZE)
-            return MZ_BUF_ERROR;
+    switch (sha->algorithm) {
+    case MZ_HASH_SHA1:
         sha->error = CC_SHA1_Final(digest, &sha->ctx1);
-    } else {
-        if (digest_size < MZ_HASH_SHA256_SIZE)
-            return MZ_BUF_ERROR;
+        break;
+    case MZ_HASH_SHA224:
+        sha->error = CC_SHA224_Final(digest, &sha->ctx256);
+        break;
+    case MZ_HASH_SHA256:
         sha->error = CC_SHA256_Final(digest, &sha->ctx256);
+        break;
+    case MZ_HASH_SHA384:
+        sha->error = CC_SHA384_Final(digest, &sha->ctx512);
+        break;
+    case MZ_HASH_SHA512:
+        sha->error = CC_SHA512_Final(digest, &sha->ctx512);
+        break;
     }
 
     if (!sha->error)
@@ -108,7 +154,8 @@ int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size) {
 
 void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm) {
     mz_crypt_sha *sha = (mz_crypt_sha *)handle;
-    sha->algorithm = algorithm;
+    if (MZ_HASH_SHA1 <= algorithm && algorithm <= MZ_HASH_SHA512)
+        sha->algorithm = algorithm;
 }
 
 void *mz_crypt_sha_create(void **handle) {

SSZipArchive/minizip/mz_crypt_apple.c

@@ -33,7 +33,9 @@ int32_t mz_path_combine(char *path, const char *join, int32_t max_path) {
         path[max_path - 1] = 0;
     } else {
         mz_path_append_slash(path, max_path, MZ_PATH_SLASH_PLATFORM);
-        strncat(path, join, max_path - path_len);
+        path_len = (int32_t)strlen(path);
+        if (max_path > path_len)
+            strncat(path, join, max_path - path_len - 1);
     }
 
     return MZ_OK;
@@ -277,17 +279,17 @@ int32_t mz_path_get_filename(const char *path, const char **filename) {
 
 int32_t mz_dir_make(const char *path) {
     int32_t err = MZ_OK;
-    int16_t len = 0;
+    size_t len = 0;
     char *current_dir = NULL;
     char *match = NULL;
     char hold = 0;
 
 
-    len = (int16_t)strlen(path);
-    if (len <= 0)
+    len = strlen(path);
+    if (len <= 0 || len > INT16_MAX)
         return 0;
 
-    current_dir = (char *)MZ_ALLOC((uint16_t)len + 1);
+    current_dir = (char *)MZ_ALLOC(len + 1);
     if (current_dir == NULL)
         return MZ_MEM_ERROR;
 

SSZipArchive/minizip/mz_os.c

@@ -222,7 +222,8 @@ int32_t mz_os_get_file_date(const char *path, time_t *modified_date, time_t *acc
         /* Not all systems allow stat'ing a file with / appended */
         len = strlen(path);
         name = (char *)malloc(len + 1);
-        strncpy(name, path, len + 1);
+        strncpy(name, path, len);
+        name[len - 1] = 0;
         mz_path_remove_slash(name);
 
         if (stat(name, &path_stat) == 0) {

SSZipArchive/minizip/mz_os_posix.c

@@ -13,14 +13,15 @@
 #include "mz_strm.h"
 #include "mz_strm_zlib.h"
 
-#include "zlib.h"
-#if defined(ZLIBNG_VERNUM) && !defined(ZLIB_COMPAT)
+#if !defined(ZLIB_COMPAT)
 #  include "zlib-ng.h"
+#else
+#  include "zlib.h"
 #endif
 
 /***************************************************************************/
 
-#if defined(ZLIBNG_VERNUM) && !defined(ZLIB_COMPAT)
+#if !defined(ZLIB_COMPAT)
 #  define ZLIB_PREFIX(x) zng_ ## x
    typedef zng_stream zlib_stream;
 #else

SSZipArchive/minizip/mz_strm_zlib.c

@@ -2230,6 +2230,16 @@ int32_t mz_zip_entry_seek_local_header(void *handle) {
     return mz_stream_seek(zip->stream, zip->file_info.disk_offset + zip->disk_offset_shift, MZ_SEEK_SET);
 }
 
+int32_t mz_zip_entry_get_compress_stream(void *handle, void **compress_stream) {
+    mz_zip *zip = (mz_zip *)handle;
+    if (zip == NULL || compress_stream == NULL)
+        return MZ_PARAM_ERROR;
+    *compress_stream = zip->compress_stream;
+    if (*compress_stream == NULL)
+        return MZ_EXIST_ERROR;
+    return MZ_OK;
+}
+
 int32_t mz_zip_entry_close(void *handle) {
     return mz_zip_entry_close_raw(handle, UINT64_MAX, 0);
 }

SSZipArchive/minizip/mz_zip.c

@@ -139,6 +139,9 @@ int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compresse
 int32_t mz_zip_entry_seek_local_header(void *handle);
 /* Seeks to the local header for the entry */
 
+int32_t mz_zip_entry_get_compress_stream(void *handle, void **compress_stream);
+/* Get a pointer to the compression stream used for the current entry */
+
 int32_t mz_zip_entry_close_raw(void *handle, int64_t uncompressed_size, uint32_t crc32);
 /* Close the current file in the zip file where raw is compressed data */
 

SSZipArchive/minizip/mz_zip.h

@@ -211,8 +211,8 @@ int32_t mz_zip_reader_close(void *handle) {
         mz_stream_os_delete(&reader->file_stream);
 
     if (reader->mem_stream != NULL) {
-        mz_stream_mem_close(reader->mem_stream);
-        mz_stream_mem_delete(&reader->mem_stream);
+        mz_stream_close(reader->mem_stream);
+        mz_stream_delete(&reader->mem_stream);
     }
 
     return err;
@@ -1143,7 +1143,8 @@ int32_t mz_zip_writer_open_file(void *handle, const char *path, int64_t disk_siz
 
         /* Create destination directory if it doesn't already exist */
         if (strchr(path, '/') != NULL || strrchr(path, '\\') != NULL) {
-            strncpy(directory, path, sizeof(directory));
+            strncpy(directory, path, sizeof(directory) - 1);
+            directory[sizeof(directory) - 1] = 0;
             mz_path_remove_filename(directory);
             if (mz_os_file_exists(directory) != MZ_OK)
                 mz_dir_make(directory);