zlib 压缩解压 zip文件 带密码

于 2024-09-04 11:15:50 发布
阅读量337 收藏
点赞数 3
分类专栏： C++ Win32 Windows 文章标签： zlib zip 压缩解压
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flame_Cyclone/article/details/141888301
版权
Win32 同时被 3 个专栏收录
73 篇文章 1 订阅
订阅专栏
C++
69 篇文章 0 订阅
订阅专栏
Windows
44 篇文章 0 订阅
订阅专栏

使用zlib, 进行文件夹/文件进行加密压缩/解压缩

zlib_zip.h

#pragma once

// 压缩文件
int compress_zip_file(
    const char* input_path,                 // 输入路径(必须是已存在的文件或文件夹)
    const char* output_path,                // 输出文件路径
    const char* password                    // 密码(可为 NULL)
);

// 解压缩文件
int uncompress_zip_file(
    const char* input_file,                 // 输入文件路径(必须是 zip 文档)
    const char* output_dir,                 // 输出文件夹路径
    const char* password                    // 密码(可为 NULL)
);

zlib_zip.c

#include "zlib_zip.h"
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <io.h>
#include <time.h>
#include <direct.h>

#define FILE_PATH_MAX               (260)
#define FILE_READ_BUF_SIZE          (1024 * 1024)

#define ZLIB_WINAPI
#ifdef __cplusplus
extern "C"
{
#endif

#include "minizip/zip.h"
#include "minizip/unzip.h"

#ifdef __cplusplus
}
#endif

// 获取文件 CRC32
static int get_file_crc32(const char* file_path, unsigned long* crc_result)
{
    int err = ZIP_OK;
    FILE* input_file = NULL;
    void* input_buf = NULL;
    unsigned long calculate_crc = 0;
    size_t input_read_size = 0;

    do
    {
        // 打开文件
        err = fopen_s(&input_file, file_path, "rb");
        if (0 != err)
        {
            err = ZIP_ERRNO;
            break;
        }

        // 分配缓冲
        input_buf = malloc(FILE_READ_BUF_SIZE);
        if (NULL == input_buf)
        {
            err = ZIP_ERRNO;
            break;
        }

        while (1)
        {
            input_read_size = fread(input_buf, 1, FILE_READ_BUF_SIZE, input_file);
            if (input_read_size < 0)
            {
                err = ZIP_ERRNO;
                break;
            }

            if (0 == input_read_size)
            {
                break;
            }

            calculate_crc = crc32(calculate_crc, (const Bytef*)input_buf, (uInt)input_read_size);
            if (input_read_size < FILE_READ_BUF_SIZE)
            {
                break;
            }
        }

    } while (0);

    if (ZIP_OK == err && NULL != crc_result)
    {
        *crc_result = calculate_crc;
    }

    if (NULL != input_file)
    {
        fclose(input_file);
    }

    if (NULL != input_buf)
    {
        free(input_buf);
    }

    return err;
}

// 添加文件到 zip 文档
static int add_file_to_zip(
    zipFile* zip_file, 
    const char* file_path,
    const char* password
    )
{
    FILE* input_file = NULL;
    void* input_buf = NULL;
    errno_t err = 0;

    do
    {
        // 分配缓冲
        input_buf = malloc(FILE_READ_BUF_SIZE);
        if (NULL == input_buf)
        {
            err = ZIP_ERRNO;
            break;
        }

        // 打开文件
        err = fopen_s(&input_file, file_path, "rb");
        if (0 != err)
        {
            break;
        }

        zip_fileinfo zi = { 0 };
        struct stat stat_info = { 0 };
        struct tm file_date = { 0 };

        // 获取文件时间
        if (0 == stat(file_path, &stat_info))
        {
            localtime_s(&file_date, &stat_info.st_mtime);

            zi.tmz_date.tm_sec = file_date.tm_sec;
            zi.tmz_date.tm_min = file_date.tm_min;
            zi.tmz_date.tm_hour = file_date.tm_hour;
            zi.tmz_date.tm_mday = file_date.tm_mday;
            zi.tmz_date.tm_mon = file_date.tm_mon;
            zi.tmz_date.tm_year = file_date.tm_year;
        }

        zi.external_fa = _A_ARCH;

        uLong crc32 = 0;
        err = get_file_crc32(file_path, &crc32);
        if (ZIP_OK != err)
        {
            break;
        }

        err = zipOpenNewFileInZip3(
            zip_file, 
            file_path, 
            NULL, 
            NULL, 
            0, 
            NULL, 
            0, 
            NULL, 
            Z_DEFLATED, 
            Z_BEST_COMPRESSION, 
            0, 
            -MAX_WBITS, 
            DEF_MEM_LEVEL, 
            Z_DEFAULT_STRATEGY, 
            password, 
            crc32
        );

        if (ZIP_OK != err)
        {
            break;
        }

        // 写入 zip 文件
        size_t input_read_size = 0;
        while (TRUE)
        {
            // 读取输入数据
            input_read_size = fread_s(input_buf, FILE_READ_BUF_SIZE, 1, FILE_READ_BUF_SIZE, input_file);

            // 文件读取完毕退出循环
            if (0 == input_read_size)
            {
                break;
            }

            // 发生错误则退出循环
            if (0 != ferror(input_file))
            {
                err = ZIP_ERRNO;
                break;
            }

            // 将数据写入 zip 中的文件
            err = zipWriteInFileInZip(zip_file, input_buf, (unsigned int)input_read_size);
            if (ZIP_OK != err)
            {
                break;
            }

            if (input_read_size < FILE_READ_BUF_SIZE)
            {
                break;
            }
        }

        zipCloseFileInZip(zip_file);

    } while (0);

    if (NULL != input_file)
    {
        fclose(input_file);
    }

    if (NULL != input_buf)
    {
        free(input_buf);
    }

    return err;
}

// 添加路径到 zip 文档
static int add_path_to_zip(
    zipFile* zip_file, 
    const char* path_name,
    const char* password
)
{
    char file_path[FILE_PATH_MAX] = { 0 };
    struct _finddata_t  find_data = { 0 };
    struct stat buf = { 0 };
    errno_t err = 0;

    if ('\0' != *path_name)
    {
        err = stat(path_name, &buf);
        if (0 != err)
        {
            return err;
        }
    }
    else
    {
        buf.st_mode = S_IFDIR;
    }

    // 检查是否为文件夹
    if (S_IFDIR & buf.st_mode)
    {
        // 拼接得到遍历路径
        strcpy_s(file_path, sizeof(file_path), path_name);

        if ('\0' != *path_name)
        {
            strcat_s(file_path, sizeof(file_path), "/");
        }

        strcat_s(file_path, sizeof(file_path), "*.*");
        intptr_t find_handle = _findfirst(file_path, &find_data);
        if (0 == find_handle)
        {
            err = ZIP_ERRNO;
            return err;
        }

        do
        {
            // 拼接文件路径
            strcpy_s(file_path, sizeof(file_path), path_name);
            if ('\0' != *path_name)
            {
                strcat_s(file_path, sizeof(file_path), "/");
            }
            strcat_s(file_path, sizeof(file_path), find_data.name);

            // 上一级目录与当前目录跳过
            if (0 == _stricmp("..", find_data.name) || 0 == _stricmp(".", find_data.name))
            {
                continue;
            }

            // 文件夹则递归处理
            if (_A_SUBDIR & find_data.attrib)
            {
                zip_fileinfo zi = { 0 };
                struct stat stat_info = { 0 };
                struct tm file_date = { 0 };

                // 获取文件时间
                if (0 == stat(path_name, &stat_info))
                {
                    localtime_s(&file_date, &stat_info.st_mtime);

                    zi.tmz_date.tm_sec = file_date.tm_sec;
                    zi.tmz_date.tm_min = file_date.tm_min;
                    zi.tmz_date.tm_hour = file_date.tm_hour;
                    zi.tmz_date.tm_mday = file_date.tm_mday;
                    zi.tmz_date.tm_mon = file_date.tm_mon;
                    zi.tmz_date.tm_year = file_date.tm_year;
                }

                zi.external_fa = _A_ARCH | _A_SUBDIR;

                // 拼接文件路径
                strcpy_s(file_path, sizeof(file_path), path_name);
                if ('\0' != *path_name)
                {
                    strcat_s(file_path, sizeof(file_path), "/");
                }
                strcat_s(file_path, sizeof(file_path), find_data.name);
                strcat_s(file_path, sizeof(file_path), "/");

                // 在 zip 文件中创建新文件
                if (ZIP_OK != zipOpenNewFileInZip(zip_file, file_path, &zi, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION))
                {
                    break;
                }

                err = zipCloseFileInZip(zip_file);
                if (ZIP_OK != err)
                {
                    break;
                }

                // 拼接文件路径
                strcpy_s(file_path, sizeof(file_path), path_name);
                if ('\0' != *path_name)
                {
                    strcat_s(file_path, sizeof(file_path), "/");
                }
                strcat_s(file_path, sizeof(file_path), find_data.name);

                if (ZIP_OK != add_path_to_zip(zip_file, file_path, password))
                {
                    break;
                }
            }
            else
            {
                err = add_file_to_zip(zip_file, file_path, password);
                if (EACCES == err)
                {
                    continue;
                }

                if (ZIP_OK != err)
                {
                    break;
                }
            }

        } while (0 == _findnext(find_handle, &find_data));

        _findclose(find_handle);
    }
    else
    {
        return add_file_to_zip(zip_file, path_name, password);
    }

    return err;
}

// 创建文件夹
static errno_t create_directory(const char* input_path)
{
    char dir_buf[FILE_PATH_MAX] = { 0 };
    struct stat buf = { 0 };
    errno_t err = 0;
    const char* dir_path = input_path;

    while ('\0' != *dir_path)
    {
        dir_path++;

        if ('/' == *dir_path)
        {
            strncpy_s(dir_buf, sizeof(dir_buf), input_path, dir_path - input_path);
            err = stat(dir_buf, &buf); 
            if ((0 == err))
            {
                // 已存在路径但不是文件夹则终止处理
                if (!(S_IFDIR & buf.st_mode))
                {
                    err = ENOENT;
                    break;
                }
            }
            else
            {
                // 文件夹不存在则创建
                err = _mkdir(dir_buf);
            }

            if (0 != err)
            {
                break;
            }
        }
    }

    return err;
}

// 压缩文件
int compress_zip_file(
    const char* input_path,                 // 输入路径(必须是已存在的文件或文件夹)
    const char* output_path,                // 输出文件路径
    const char* password                    // 密码
)
{
    errno_t err = ZIP_OK;

    if (NULL == input_path || NULL == output_path)
    {
        return ZIP_PARAMERROR;
    }

    if ('\0' == *input_path || '\0' == *output_path)
    {
        return ZIP_PARAMERROR;
    }

    do
    {
        // 创建 zip 文件
        zipFile zFile = zipOpen(output_path, 0);
        if (NULL == zFile)
        {
            err = ZIP_ERRNO;
            break;
        }

        // 添加 路径到 zip 文件
        err = add_path_to_zip(zFile, input_path, password);
        if(ZIP_OK != err)
        {
            err = ZIP_ERRNO;
            break;
        }

        // 关闭 zip 文件
        err = zipClose(zFile, NULL);
        if(ZIP_OK != err)
        {
            err = ZIP_ERRNO;
            break;
        }

        err = ZIP_OK;

    } while (0);

    return err;
}

// 解压缩文件
int uncompress_zip_file(
    const char* input_file,                 // 输入文件路径
    const char* output_dir,                 // 输出文件夹路径
    const char* password                    // 密码
)
{
    char file_path[FILE_PATH_MAX] = { 0 };
    unzFile unzFile = NULL;
    void* input_buf = NULL;
    errno_t err = 0;

    if (NULL == input_file || NULL == output_dir)
    {
        return UNZ_PARAMERROR;
    }

    do
    {
        unzFile = unzOpen(input_file);
        if (NULL == unzFile)
        {
            err = UNZ_ERRNO;
            break;
        }

        input_buf = malloc(FILE_READ_BUF_SIZE);
        if (NULL == input_buf)
        {
            err = UNZ_ERRNO;
            break;
        }

        unz_global_info global_info = { 0 };
        err = unzGetGlobalInfo(unzFile, &global_info);
        if (UNZ_OK != err)
        {
            break;
        }
        
        for (uLong i = 0; i < global_info.number_entry; i++)
        {
            char file_name[FILE_PATH_MAX] = { 0 };
            unz_file_info file_info = { 0 };

            // 获取文件信息
            err = unzGetCurrentFileInfo(unzFile, &file_info, file_name, sizeof(file_name), NULL, 0, NULL, 0);
            if (UNZ_OK != err)
            {
                break;
            }

            // 拼接文件路径
            strcpy_s(file_path, sizeof(file_path), output_dir);
            if ('\0' != output_dir[0])
            {
                strcat_s(file_path, sizeof(file_path), "/");
            }
            strcat_s(file_path, sizeof(file_path), file_name);

            // 检查是否为文件夹
            if (_A_SUBDIR & file_info.external_fa)
            {
                err = create_directory(file_path);
                if (UNZ_OK != err)
                {
                    break;
                }
            }
            else
            {
                FILE* output_file = NULL;

                // 打开当前文件
                err = unzOpenCurrentFilePassword(unzFile, password);
                if (UNZ_OK != err)
                {
                    break;
                }

                // 打开输出文件
                err = fopen_s(&output_file, file_path, "wb");
                if (0 != err)
                {
                    err = UNZ_ERRNO;
                    break;
                }

                while (1)
                {
                    // 读取数据
                    int input_read_size = unzReadCurrentFile(unzFile, input_buf, FILE_READ_BUF_SIZE);
                    if (input_read_size < 0)
                    {
                        err = UNZ_ERRNO;
                        break;
                    }

                    if (input_read_size == 0)
                    {
                        break;
                    }

                    // 输出数据
                    if (input_read_size != fwrite(input_buf, 1, input_read_size, output_file))
                    {
                        err = UNZ_ERRNO;
                        break;
                    }

                    if (input_read_size < FILE_READ_BUF_SIZE)
                    {
                        break;
                    }
                }

                fclose(output_file);

                err = unzCloseCurrentFile(unzFile);
                if (UNZ_OK != err)
                {
                    break;
                }

            }

            // 转到下一个文件
            err = unzGoToNextFile(unzFile);
            if (UNZ_OK != err)
            {
                if (UNZ_END_OF_LIST_OF_FILE == err)
                {
                    err = UNZ_OK;
                }

                break;
            }
        }
        
    } while (0);

    // 关闭 zip 文件
    if (NULL != unzFile)
    {
        unzClose(unzFile);
    }

    // 释放读取缓冲
    if (NULL != input_buf)
    {
        free(input_buf);
    }

    return err;
}

测试

main.c

#include "zlib_zip.h"

int main()
{
    compress_zip_file("zlib 1.3.1", "2024.zip", "12345678");
    uncompress_zip_file("2024.zip", "2024", "12345678");
    return 0;
}

Flame_Cyclone
关注
专栏目录
C++ Zlib库实现zip文件压缩解压(支持递归压缩)
10-10
C++利用Zlib库实现zip文件压缩及解压 支持递归压缩.可配合自动更新功能实现zip压缩包进得软件更新
使用 zlib库 解压缩 zip文件
12-07
第三方类库选用有名的zlib，官方网址为http://www.zlib.net/，vc6.0使用zlib库解压zip文件
zlib解压缩zip
超频化石鱼的博客
02-07 9317
将zconf.h，zlib.h，zlibwapi.dll，zlibwapi.lib这4个文件放到项目目录下，并将头文件导入到工程中。       将zlib-1.2.8\contrib\minizip文件夹下除miniunz.c和minizip.c以外的.h与.c文件放到项目目录下，并将zip.h与unzip.h导入到工程中。       这样，就可以使用zip.h和unzip.h中的函数操作
心得 ~ 使用 zlib库 解压缩 zip文件
热门推荐
Iceti9er的专栏
07-05 1万+
最近在完成一个项目，需要用到C++语言读取一个zip文件内指定文件的内容。在网上查阅了不少资料，针对过程中遇到的问题，自己也研究了一下，现将方法心得记录下来。 关于解压文件的方法，根据网上的资料，大概有以下三种方法： 调用rar.exe等外部程序。使用第三方类库。自己写解压方法。 第一种方法，个人感觉不太靠谱，舍去。第三种方法，本人对zip压缩算法一头雾水，加上暂时没必要做此类研究，舍去
[zlib]_[初级]_[使用Zlib完整解压zip内容]
06-26
http://blog.csdn.net/infoworld/article/details/46648709 使用zlib解压zip文件,vs2010
使用 ZLib 压缩/解压 ZIP 文件
okadler0518的专栏
01-12 1万+
zlib
Qt使用自带zlib解压zip文件示例
12-07
Qt为了方便开发者，已经集成了zlib的功能，使得在Qt应用程序中解压ZIP文件变得简单易行。 首先，我们要了解Qt中的QIODevice类。这个类是所有输入/输出设备的基础，包括文件、网络套接字和内存缓冲区等。在处理ZIP...
C++ 基于ZLIB压缩库的数据或文件的压缩与解压缩小程序.zip
11-11
本项目“C++ 基于ZLIB压缩库的数据或文件的压缩与解压缩小程序”正是利用了ZLIB库来实现这个功能。 ZLIB库是基于DEFLATE算法的，这是一种混合了LZ77（一种字典压缩方法）和霍夫曼编码（一种熵编码方法）的高效压缩...
VB6.0调用 DLL版ZIP压缩文件夹目录和解压ZIP文件
07-17
VB6.0调用 DLL版ZIP压缩文件夹目录和解压ZIP文件，网上很多源码不好用，所以就自己做了一个。原始代码是VC++的用VS2019编译了一个，DLL封装了下。调用很简单 '调用方法如下: 'CreateZipFileA "C:\123", "C:\123.zip...
使用zlib库解压*.zip文件
leno的专栏
08-08 8680
1.编辑zlib静态库 1）实现zip文件压缩和解压的zlib库部分代码（基于zlib-1.2.5） 这是zlib-1.2.5源码：http://download.csdn.net/download/sunxianliang1/9597876  这是整理好的源代码（只是把需要的挑选出来，可以用vs编译成库使用）：http://download.csdn.net/download/sunxia
C++语言用zlib库解压zip文件
08-20
本文档中的代码使用的C++语言，代码量不大，使用的是第三方的zlib库，可以实现多文件的解压。
zlib库的使用，可以压缩和解压文件夹.zip
03-15
zlib库的使用，可以压缩和解压文件夹。 压缩: CreateDirFromZip("test\\example2", "test\\example.zip"); 解压: CreateZipFromDir("test\\example", "test\\example.zip");
Zlib压缩解压工具
05-15
Zlib压缩解压工具，第一次用请先运行reg.bat注册组件
使用zlib解压.apk/.zip文件（Windows&Ubuntu）
LeeHDsniper的博客
05-05 9759
解压出apk文件的内容是进行apk分析的第一步，而.apk文件其实就是.zip文件。也就是说首先要实现zip文件的解压缩。本文将分别介绍在Windows和Ubuntu下如何使用zlib这一开源库对zip文件进行解压。
使用zlib解压标准zip文件
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
06-08 4313
zlib库可以解压zip压缩数据，但是在做标准zip文件解压的时候发现会出现问题，原因其实是因为zlib的压缩格式与标准zip的压缩格式有那么一点区别，最初这个问题让我很纠结，在经过实验后，我将标准zip压缩的文件与使用zlib库函数压缩的文件使用二进制编辑器打开时发现了它们的一点点区别，使用zlib库函数压缩后的数据与标准zip压缩后的数据相比在头部多了个0x9c78，（而且数据的尾部也稍有不同
Zlib库的使用实现对zip文件的解压缩（二）
我不是萧海哇的博客
12-24 1883
接之前的一篇文章 http://blog.csdn.net/ljh0302/article/details/50384457 现在详细地给出利用zlib对.zip文件进行解压缩的过程： 参考文章（非常详细）：http://m.blog.csdn.net/blog/wiceti9er/9252295 #include "unzip.h" #include "zip.h" #include <iostream> #include <fstream> using namespace std
zlib压缩和解压的使用
化石
09-11 9569
1、unzOpen(filePath) 这个方法可以打开一个压缩文件，返回一个句柄，这个句柄将在后面的方法中被用到。 2、unzGetGlobalInfo() 这个可以得到全局的信息。常用的是压缩包里的文件个数。 3、unzGotoFirstFile() 定位到压缩文件中的第一个文件。     3.1 unzGetCurrentFileI
使用Zlib对文件和目录进加密打包和解包
xpg4321的博客
08-23 6068
zlib就不做解释了，本人使用的是1.2.7版本，并用C++进行了封装，用到了Qt。 功能： 1.使用线程，不会卡死界面支. 2.支持递归目录，目录和单个文件。 3.可以同时进行多项任务。 4.返回每项任务的任务进度。 5.打包和解包的详细过程信息。 6.支持从包文件中只解压一个文件。 步骤: 1.下载zlib压缩包并解压。 2.找到zlib解压目录下的zlib-1.2.7\c
linux中用c++实现压缩解压zip文件
最新发布
04-29
在Linux操作系统中，使用C语言编写程序来实现压缩和解压Zip文件可以采用zlib库。这个库提供了压缩和解压缩不同类型的压缩格式的功能，包括zip格式。 要使用zlib库，需要在程序中引入zlib.h头文件，并使用相关的函数进行压缩和解压缩操作。例如，要压缩文件，可以使用zlib库中的compress函数。 具体实现步骤可以分为以下几个步骤： 1. 引入zlib.h头文件。 2. 打开需要压缩的文件。 3. 创建输出文件，用于存放压缩后的文件。 4. 使用compress函数进行压缩操作，并将压缩后的数据写入输出文件。 5. 关闭输入和输出文件。 要解压Zip文件，可以使用zlib库中的uncompress函数。具体实现步骤类似于压缩操作。 总体来说，在Linux中使用C语言实现压缩和解压Zip文件可以通过zlib库实现。这个库提供了压缩和解压缩不同类型的压缩格式的功能，是一个非常方便实用的工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值