golang解压带密码的zip包的方法详解

和依珊

目录

• Zip文件详解
  
  
  
  • ZIP 文件格式主要特性
    
  • 常用算法
    
  • Zip格式结构图总览
    
  • Zip文件结构详解
    
    
    
    • 数据区
      
    • 中央目录记录区（核心目录记录区 ）
      
    • 中央目录记录尾部区
      
    
    
  • 压缩包解压过程
    
    
    
    • 方式1 通过解析中央目录区来解压
      
    • 方式2 通过读取本地文件头来解压
      
    • 两种解压方式对比
      
    
    
  
  
• golang解压zip包
  
  
  
  • 官方archive/zip
    
  • 第三方包github.com/yeka/zip
    
  • 自己实现解压加密的zip包
    
  
  

Zip文件详解

ZIP 文件格式是一种常用的压缩和归档格式，用于将多个文件和目录打包到一个单独的文件中，同时对其内容进行压缩以减少文件大小。ZIP 文件格式的设计旨在支持多种压缩算法、加密和数据完整性校验。以下是 ZIP 文件格式的主要特性和常用算法：

ZIP 文件格式主要特性

文件头：
每个文件都有一个本地文件头和一个中央目录文件头。文件头包含文件名、压缩方法、时间戳、CRC-32 校验和、压缩前后的大小等信息。
数据描述符：
可选的后缀结构，包含文件的 CRC-32 校验和、压缩大小和未压缩大小。
中央目录：
ZIP 文件的末尾包含一个中央目录记录，列出了 ZIP 文件中的所有文件和目录的文件头信息，用于快速定位和访问。
结束记录：
ZIP 文件末尾的“中央目录结束记录”标识了中央目录的结束，包含中央目录的偏移量和大小等信息。
一个简单的 ZIP 文件可以包含多个文件的本地文件头、压缩数据、中央目录和结束记录。解压工具通过读取中央目录找到各个文件的偏移量和大小，然后根据这些信息读取和解压文件数据。
以下是一个 ZIP 文件结构的简化示例：

1. [本地文件头1] [文件数据1] [本地文件头2] [文件数据2] ... [中央目录] [中央目录结束记录]

复制代码

ZIP 文件格式因其广泛的支持和高效的压缩性能，广泛应用于文件归档和传输。DEFLATE 算法是其最常用的压缩算法，提供了良好的平衡点。

常用算法

压缩算法：

• DEFLATE：这是 ZIP 文件中最常用的压缩算法，由 Phil Katz 发明。它结合了 LZ77 算法和 Huffman 编码，提供了良好的压缩比和解压速度。
  
• STORE：不进行任何压缩，仅用于存储数据。适用于已经被压缩过的数据，如 JPEG 图像或 MP3 音频文件。
  
• 其他压缩方法：ZIP 规范还支持其他压缩方法，如 BZIP2、LZMA 和 PPMd，但这些方法在实际使用中较为少见。
  

加密算法：

• 传统 ZIP 加密：早期的 ZIP 文件使用一种相对简单的对称加密方法，但这种方法的安全性较弱。
  
• AES 加密：一些现代的 ZIP 工具支持使用高级加密标准 (AES) 进行加密，提供了更强的安全性。
  

校验算法：

• CRC-32：用于每个文件的数据完整性校验。每个文件都有一个 CRC-32 校验和，用于检测数据传输或存储过程中的错误。
  

Zip格式结构图总览

Zip文件结构详解

zip格式压缩包主要由三大部分组成：数据区、中央目录记录区（也有叫核心目录记录）、中央目录记录尾部区。

数据区

数据区是由一系列本地文件记录组成，本地文件记录主要是记录了压缩前后文件的元数据以及存放压缩后的文件，组成部分也分为三大部分：

1. 本地文件头

复制代码

、

1. 文件数据

复制代码

、

1. 文件描述

复制代码

本地文件头

1. local file header signature     4 bytes  (0x04034b50)
   
2. version needed to extract       2 bytes
   
3. general purpose bit flag        2 bytes
   
4. compression method              2 bytes
   
5. last mod file time              2 bytes
   
6. last mod file date              2 bytes
   
7. crc-32                          4 bytes
   
8. compressed size                 4 bytes
   
9. uncompressed size               4 bytes
   
10. file name length                2 bytes
    
11. extra field length              2 bytes
    
12. 
    
13. file name (variable size)
    
14. extra field (variable size)

复制代码

本地文件头主要是记录了压缩文件的元数据：

• loca file header signature：0~3，4个字节，用来存放本地文件头标识，一般为固定值
  1. 0x04034b50

  复制代码
  ，用于解压时候，读取判断文件头的开始；
  
• version needed to extract：4~5，2个字节，记录解压缩文件所需的最低支持的ZIP规范版本，apk压缩版本默认是20, 即Deflate压缩方式。该字段值=解压所需的最低ZIP规范版本*10，比如，最低支持的ZIP规范版本是2.0，那么该字段的值就是20。每个版本定义如下。
  

1. 当前最低功能版本定义如下：（压缩包记录的解压版本都是需要版本*10，比如：2.0 * 10 = 20）
   
2. 1.0 – 默认值
   
3. 1.1 – 文件是卷标
   
4. 2.0 – 文件是一个文件夹（目录）
   
5. 2.0 – 使用 Deflate 压缩来压缩文件
   
6. 2.0 – 使用传统的 PKWARE 加密对文件进行加密
   
7. 2.1 – 使用 Deflate64™ 压缩文件
   
8. 2.5 – 使用 PKWARE DCL Implode 压缩文件
   
9. 2.7 – 文件是补丁数据集
   
10. 4.5 – 文件使用 ZIP64 格式扩展
    
11. 4.6 – 使用 BZIP2 压缩文件压缩
    
12. 5.0 – 文件使用 DES 加密
    
13. 5.0 – 文件使用 3DES 加密
    
14. 5.0 – 使用原始 RC2 加密对文件进行加密
    
15. 5.0 – 使用 RC4 加密对文件进行加密
    
16. 5.1 – 文件使用 AES 加密进行加密
    
17. 5.1 – 使用更正的 RC2 加密对文件进行加密
    
18. 5.2 – 使用更正的 RC2-64 加密对文件进行加密
    
19. 6.1 – 使用非 OAEP 密钥包装对文件进行加密
    
20. 6.2 – 中央目录加密

复制代码

• genaral purpose bit flag：6~7，2个字节，记录通用标志位，第0位为
  1. 1

  复制代码
  时（即二进制：00000000 00000001），表示文件被加密，解压时候需要解密；第3位为
  1. 1

  复制代码
  时候（即二进制：00000000 00000100），表示有数据描述部分，本地文件头中的 CRC-32、压缩大小和未压缩大小字段都被设置为0（虽然zip规范是这么定义，但是发现有些压缩包即使声明有数据描述部分，但是本地文件头的CRC-32、压缩大小和未压缩大小依然还是设置为真实值） ， 正确的值被放在紧跟在压缩数据之后的数据描述部分，apk的通用标志位默认传0即可，也有传2048、2056，目前第15位是PKWARE保留位。
  
• compression method：8~9，2个字节，记录压缩包所用到的压缩方式，apk默认Deflate压缩，传8即可, 要是传0 ，则是不压缩，各种压缩方式对应数值如下：
  

1. 0 – The file is stored (no compression)
   
2. 1 – The file is Shrunk
   
3. 2 – The file is Reduced with compression factor 1
   
4. 3 – The file is Reduced with compression factor 2
   
5. 4 – The file is Reduced with compression factor 3
   
6. 5 – The file is Reduced with compression factor 4
   
7. 6 – The file is Imploded
   
8. 7 – Reserved for Tokenizing compression algorithm
   
9. 8 – The file is Deflated
   
10. 9 – Enhanced Deflating using Deflate64™
    
11. 10 – PKWARE Data Compression Library Imploding
    
12. 11 – Reserved by PKWARE
    
13. 12 – File is compressed using BZIP2 algorithm

复制代码

• last mod file time：10~11，2个字节，记录文件最后修改时间，是MS-DOS格式编码的时间
  

• last mod date time：12~13，2个字节，记录文件最后修改日期，是MS-DOS格式编码的日期
  
• crc-32：14~17，4个字节，记录文件未压缩时的CRC-32校验码
  
• compressed size：18~21，4个字节，记录文件压缩后的大小
  
• uncompressed size：22~25，4个字节，记录文件未压缩的大小
  
• file name length：26~27，2个字节，记录文件名的长度(假设文件名长度为n)
  
• extra field length：28~29，2个字节，记录扩展区的长度(假设扩展区长度为m)
  
• file name：30~30+n，n个字节，记录文件名
  
• extral field：30+n~30+n+m，m个字节，记录扩展数据
  

文件数据
文件数据紧跟在本地文件头之后，一般是压缩后的文件数据或压缩方式选择不压缩时候，用来存储未压缩文件数据。
文件描述
文件描述符仅在通用位标志的第 3 位被设置为1时才存在。 它是字节对齐的，紧跟在文件数据的最后一个字节之后。当且仅当无法在 .ZIP 文件中查找时才使用此描述符，例如：当输出 的.ZIP 文件是标准输出或不可查找设备时使用文件描述，换句话说，正常情况下都不需要使用。

（ 数据描述符标识不一定有，因为一开始规范是没有的，后面才加上去的）

中央目录记录区（核心目录记录区 ）

中心目录区的结构如下。

1. [file header 1]
   
2. .
   
3. .
   
4. .
   
5. [file header n]
   
6. [digital signature]

复制代码

1. central file header signature   4 bytes  (0x02014b50)
   
2. version made by                 2 bytes
   
3. version needed to extract       2 bytes
   
4. general purpose bit flag        2 bytes
   
5. compression method              2 bytes
   
6. last mod file time              2 bytes
   
7. last mod file date              2 bytes
   
8. crc-32                          4 bytes
   
9. compressed size                 4 bytes
   
10. uncompressed size               4 bytes
    
11. file name length                2 bytes
    
12. extra field length              2 bytes
    
13. file comment length             2 bytes
    
14. disk number start               2 bytes
    
15. internal file attributes        2 bytes
    
16. external file attributes        4 bytes
    
17. relative offset of local header 4 bytes
    
18. 
    
19. file name (variable size)
    
20. extra field (variable size)
    
21. file comment (variable size)

复制代码

中央目录记录区是有一系列中央目录记录所组成，一条中央目录记录对应数据区中的一个压缩文件记录，中央目录记录由以下部分构成：（中央目录区通常由多个文件头（file header）组成，每一个被压缩的文件都有一个对应的file header（注意，这里不是local file header），用于标识和定位该文件在ZIP文件中的位置。这个文件头和本地文件头类似，记录了被压缩文件的元数据信息，包括文件原始大小，压缩之后的大小，文件注释等。）

• central file header signature：0~3，4个字节，记录核心目录文件头标识，固定值：
  1. 0x02014b50

  复制代码
  ，用于解压时候，查找判断是否是中央目录的开始位置
  
• version made by：4~5，2个字节，记录压缩所用的版本，同数据区本地文件头的解压所需版本，apk设置20
  
• 6~7：2个字节，记录解压所需的最小版本，同数据区本地文件头的解压所需版本，apk设置20
  
• 8~9：2个字节，通用位标记，同数据区本地文件头的通用位标记
  
• 压缩方法、文件最后修改时间、文件最后修改日期、CRC-32校验码、压缩后大小、未压缩大小、文件名长度、扩展区长度，这几个字段的含义都等同于数据区本地文件头对应字段的含义
  
• file comment length：32~33，2个字节，记录文件注释的长度
  
• disk number start：34~35，2个字节，记录文件开始位置的磁盘编号，一般传0即可
  
• 36~41：内部文件属性、外部文件属性，一般也是传0即可
  
• 42~45：4个字节，记录数据区本地文件头相对于压缩包开始位置的偏移量
  

数据签名（digital signature）：

1. header signature                4 bytes  (0x05054b50)
   
2. size of data                    2 bytes
   
3. signature data (variable size)

复制代码

• header signature：数字签名起始标识，固定值为0x05054b50。
  
• size of data：数字签名数据大小。
  
• signature data ：签名数据
  

中央目录记录尾部区

中央目录记录尾部主要作用是用来定位中央目录记录区的开始位置，同时记录压缩包的注释内容：

1. end of central dir signature    4 bytes  (0x06054b50)
   
2. number of this disk             2 bytes
   
3. number of the disk with the
   
4. start of the central directory  2 bytes
   
5. total number of entries in the
   
6. central directory on this disk  2 bytes
   
7. total number of entries in
   
8. the central directory           2 bytes
   
9. size of the central directory   4 bytes
   
10. offset of start of central
    
11. directory with respect to
    
12. the starting disk number        4 bytes
    
13. .ZIP file comment length        2 bytes
    
14. .ZIP file comment       (variable size)

复制代码

• end of central dir signature：0~3，4个字节，中央目录记录尾部开头标记，固定值：
  1. 0x06054b50

  复制代码
  ，用于解压时，查找判断中央目录尾部的起始位置
  
• number of this disk：4~5，2个字节，记录中央目录记录尾部区所在磁盘编号
  
• number of the disk with the start of the central directory：6~7，2个字节，记录中央目录开始位置所在的磁盘编号
  
• total number of entries in the central directory on this disk：8~9，2个字节，该磁盘上所记录的核心目录数量
  
• total number of entries in the central directory：10~11，2个字节，zip压缩包中的文件总数
  
• size of the central directory：12~15，4个字节，整个中央目录的大小（以字节为单位）
  
• offset of start of central directory with respect to the starting disk number：16~19，4个字节，中央目录开始位置相对位移
  
• ZIP file comment length：20~21，2个字节，注释内容的长度（假设长度为n）
  
• ZIP file comment：22~22+n，n个字节，注释内容
  

中央目录结束标识是ZIP文件解压的入口。通过读取中央目录结束标识，解压缩软件可以快速地找到中央目录，并据此解析整个ZIP文件的结构和内容。通过里面的中央核心目录区的大小可以找到对应的中央目录模块，然后根据中央目录文件头中的本地文件头偏移（relative offset of local header）可以寻址到对应的文件，并进行解压。
每个压缩文件都必须且仅有一个中央目录结束标识。如果ZIP文件损坏或结构不正确，可能会导致中央目录结束标识丢失或损坏，从而使得解压缩软件无法正确读取和解析ZIP文件。

压缩包解压过程


方式1 通过解析中央目录区来解压

通过ZIP文件的结构我们发现，ZIP文件的中央目录区保存了所有的文件信息。所以，可以通过中央目录区拿到所有的文件信息并进行解压，步骤如下所示。

• 首先在 ZIP 文件末尾通过中央目录结束标识 (0x06054b50)找到中央目录结束标识数据块。
  
• 通过中央目录结束标识中的中央目录区开始位置偏移找到中央目录区数据块。
  
• 根据中央目录区的File Header中的 local file header的偏移量找到对应的local file header。
  
• 根据 local file header找到对应的file data
  
• 解密 file data（如果需要）；
  
• 解压 file data；
  

方式2 通过读取本地文件头来解压

根据 ZIP 文件格式标准可知，除了 中央目录区， 本地文件头中也包含了每个文件的相关信息。因此，可以基于本地文件头去解压文件数据，其解压流程就可以变为：

• 从头开始，通过本地文件头标识搜索对应的 local file header
  
• 读取 local file header并找到file data；
  
• 解密 file data（如果需要）；
  
• 解压 file data；
  

两种解压方式对比

通过两种解压方式可以明显看出，两种解压方式适用的场景不同。
方式1适用场景：

• 适用于在解压文件已经存在于磁盘上，并且需要解压压缩包中所有的文件。
  

方式2适用场景：

• 当文件不在磁盘上，比如从网络接收的数据，想边接收边解压；
  
• 需要顺序解压ZIP文件前面的一小部分文件，可以使用这种方式，因为方式1读中央目录区会带来额外的耗时；
  
• ZIP文件中的中央目录区遭到损坏；
  

golang解压zip包


官方archive/zip

golang zip包的解压有官方的zip包（archive/zip），但是官方给的zip解压包代码只有解压不带密码的zip包。
下面给出解压操作的封装：

1. func Unzip(src, dst string) error {
   
2.         // zip.NewReader() 适合从stream中读取字节序列
   
3.         zf, err := zip.OpenReader(src)
   
4.         if err != nil {
   
5.                 return err
   
6.         }
   
7.         defer zf.Close()
   
8. 
   
9.         for _, file := range zf.File {
   
10.                 // fmt.Println(file.Name)
    
11.                 path := filepath.Join(dst, file.Name)
    
12.                 // 如果是目录则创建目录
    
13.                 if file.FileInfo().IsDir() {
    
14.                         if err = os.MkdirAll(path, 0o644); err != nil {
    
15.                                 return err
    
16.                         }
    
17.                         continue
    
18.                 }
    
19.                 f, err := os.Create(path)
    
20.                 if err != nil {
    
21.                         return err
    
22.                 }
    
23.                 reader, err := file.Open()
    
24.                 if err != nil {
    
25.                         return err
    
26.                 }
    
27.                 _, err = io.Copy(f, reader)
    
28.                 if err != nil {
    
29.                         return err
    
30.                 }
    
31.                 _ = f.Close()
    
32.                 _ = reader.Close()
    
33.         }
    
34.         return nil
    
35. }
    
36. 
    
37. func main() {
    
38.         log.Println(Unzip("Go.zip", "./static"))
    
39. }

复制代码

通常情况下，目录权限设为 0755，文件权限设为 0644 更为合适。
在 Unix 和 Unix-like 操作系统（如 Linux）中，文件权限使用三位八进制数来表示，每一位分别表示所有者（Owner）、组（Group）和其他人（Others）的权限。每一位的权限可以是 1（执行权限），2（写入权限），4（读取权限）的组合。它们的组合值表示特定的权限设置。
权限位的含义：

• 1：执行权限 (Execute)
  
• 2：写入权限 (Write)
  
• 4：读取权限 (Read)
  

这些权限可以相加来组合权限。例如：

• 7 (4+2+1)：读取、写入和执行权限 (Read + Write + Execute)
  
• 6 (4+2)：读取和写入权限 (Read + Write)
  
• 5 (4+1)：读取和执行权限 (Read + Execute)
  
• 4：读取权限 (Read)
  
• 3 (2+1)：写入和执行权限 (Write + Execute)
  
• 2：写入权限 (Write)
  
• 1：执行权限 (Execute)
  
• 0：无权限 (No permissions)
  

权限设置示例：
权限设置通常以三位八进制数表示，例如

1. 0755

复制代码

，每一位代表不同用户类别的权限：

• 第一位（Owner 权限）：
  1. 7

  复制代码
  ，表示所有者有读取、写入和执行权限。
  
• 第二位（Group 权限）：
  1. 5

  复制代码
  ，表示组用户有读取和执行权限。
  
• 第三位（Others 权限）：
  1. 5

  复制代码
  ，表示其他用户有读取和执行权限。
  

1. rwxr-xr-x

复制代码

• 1. r

  复制代码
  代表读取权限
  
• 1. w

  复制代码
  代表写入权限
  
• 1. x

  复制代码
  代表执行权限
  
• 1. -

  复制代码
  代表没有该权限
  

示例解释：

1. 0755

复制代码

:

• 所有者（Owner）权限：
  1. 7

  复制代码
  (rwx) 读取、写入和执行
  
• 组（Group）权限：
  1. 5

  复制代码
  (r-x) 读取和执行
  
• 其他人（Others）权限：
  1. 5

  复制代码
  (r-x) 读取和执行
  

1. 0644

复制代码

:

• 所有者（Owner）权限：
  1. 6

  复制代码
  (rw-) 读取和写入
  
• 组（Group）权限：
  1. 4

  复制代码
  (r–) 读取
  
• 其他人（Others）权限：
  1. 4

  复制代码
  (r–) 读取
  

第三方包github.com/yeka/zip

使用

1. go get github.com/yeka/zip

复制代码

安装后，代码都不需要改变，只是导入的zip包替换为第三方即可：

https://github.com/yeka/zip，关于这个库里面的整个代码是在官方的zip库的基础上做了一些修改，并且这个库里面的代码抛弃了注册的功能，直接把解密代码写在了open文件里，废弃了一个很好用的功能。

自己实现解压加密的zip包

golang官方的zip代码库，https://golang.google.cn/pkg/archive/zip/#pkg-examples有两个注册接口，一个是压缩和一个是解压的：

官方注册压缩器方法示例：

1. package main
   
2. 
   
3. import (
   
4.         "archive/zip"
   
5.         "bytes"
   
6.         "compress/flate"
   
7.         "io"
   
8. )
   
9. 
   
10. func main() {
    
11.         // Override the default Deflate compressor with a higher compression level.
    
12. 
    
13.         // Create a buffer to write our archive to.
    
14.         buf := new(bytes.Buffer)
    
15. 
    
16.         // Create a new zip archive.
    
17.         w := zip.NewWriter(buf)
    
18. 
    
19.         // Register a custom Deflate compressor.
    
20.         w.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {
    
21.                 return flate.NewWriter(out, flate.BestCompression)
    
22.         })
    
23. 
    
24.         // Proceed to add files to w.
    
25. }

复制代码

类比这个案例可以写出：

1. func main() {
   
2.         zf, _ := zip.OpenReader("")
   
3.         zf.RegisterDecompressor(zip.Deflate, func(r io.Reader) io.ReadCloser {
   
4.                
   
5.                 // TODO:解密算法实现
   
6. 
   
7.                 return flate.NewReader(r)
   
8.         })
   
9. }

复制代码

接下来实现解密算法（官方链接：https://support.pkware.com/pkzip/appnote）：

zip标准文件：https://pkwaredownloads.blob.core.windows.net/pem/APPNOTE.txt，温馨提示：不要机器翻译成中文。

1. ZIP 文件加密算法通常使用一种简单的流加密方法，称为 ZipCrypto。解密过程包括初始化三个 32 位整数 key0, key1, 和 key2，并根据密码和加密的字节数据更新这些值。加密和解密使用同样的逻辑，只是加密是将明文转换为密文，而解密是将密文转换为明文。

复制代码

1. type ZipCrypto struct {
   
2.     password []byte
   
3.     Keys     [3]uint32
   
4. }
   
5. 
   
6. func NewZipCrypto(passphrase []byte) *ZipCrypto {
   
7.     z := &ZipCrypto{}
   
8.     z.password = passphrase
   
9.     z.init()
   
10.     return z
    
11. }
    
12. 
    
13. func (z *ZipCrypto) init() {
    
14.     z.Keys[0] = 0x12345678
    
15.     z.Keys[1] = 0x23456789
    
16.     z.Keys[2] = 0x34567890
    
17. 
    
18.     for i := 0; i < len(z.password); i++ {
    
19.         z.updateKeys(z.password[i])
    
20.     }
    
21. }
    
22. 
    
23. func (z *ZipCrypto) updateKeys(byteValue byte) {
    
24.     z.Keys[0] = crc32update(z.Keys[0], byteValue)
    
25.     z.Keys[1] += z.Keys[0] & 0xff
    
26.     z.Keys[1] = z.Keys[1]*134775813 + 1
    
27.     z.Keys[2] = crc32update(z.Keys[2], (byte)(z.Keys[1]>>24))
    
28. }
    
29. 
    
30. func (z *ZipCrypto) magicByte() byte {
    
31.     var t uint32 = z.Keys[2] | 2
    
32.     return byte((t * (t ^ 1)) >> 8)
    
33. }
    
34. 
    
35. func (z *ZipCrypto) Encrypt(data []byte) []byte {
    
36.     length := len(data)
    
37.     chiper := make([]byte, length)
    
38.     for i := 0; i < length; i++ {
    
39.         v := data[i]
    
40.         chiper[i] = v ^ z.magicByte()
    
41.         z.updateKeys(v)
    
42.     }
    
43.     return chiper
    
44. }
    
45. 
    
46. func (z *ZipCrypto) Decrypt(chiper []byte) []byte {
    
47.     length := len(chiper)
    
48.     plain := make([]byte, length)
    
49.     for i, c := range chiper {
    
50.         v := c ^ z.magicByte()
    
51.         z.updateKeys(v)
    
52.         plain[i] = v
    
53.     }
    
54.     return plain
    
55. }
    
56. 
    
57. func crc32update(pCrc32 uint32, bval byte) uint32 {
    
58.     return crc32.IEEETable[(pCrc32^uint32(bval))&0xff] ^ (pCrc32 >> 8)
    
59. }

复制代码

实现加密解密算法后写一个小例子来测试下：

1. func main() {
   
2.         password := "generalzy"
   
3.         zc := NewZipCrypto(password)
   
4. 
   
5.         // 示例数据
   
6.         data := []byte("Hello, ZipCrypto!")
   
7.         fmt.Printf("Original: %s\n", data)
   
8. 
   
9.         // 加密数据
   
10.         encrypted := zc.Encrypt(data)
    
11.         fmt.Printf("Encrypted: %x\n", encrypted)
    
12. 
    
13.         // 初始化解密器
    
14.         zcDecrypt := NewZipCrypto(password)
    
15. 
    
16.         // 解密数据
    
17.         decrypted := zcDecrypt.Decrypt(encrypted)
    
18.         fmt.Printf("Decrypted: %s\n", decrypted)
    
19. }

复制代码

要利用 zip 包提供的注册方法来注册解密函数，可以使用 RegisterDecompressor 方法。首先，需要扩展之前的 ZipCrypto 实现，使其能够解密压缩数据流。然后，可以将这个解密流注册到 zip 包中。
最后给出整体代码：

1. package main
   
2. 
   
3. import (
   
4.         "archive/zip"
   
5.         "bytes"
   
6.         "compress/flate"
   
7.         "fmt"
   
8.         "hash/crc32"
   
9.         "io"
   
10.         "io/ioutil"
    
11.         "os"
    
12.         "path/filepath"
    
13. )
    
14. 
    
15. type ZipCrypto struct {
    
16.         password []byte
    
17.         Keys     [3]uint32
    
18. }
    
19. 
    
20. func NewZipCrypto(passphrase []byte) *ZipCrypto {
    
21.         z := &ZipCrypto{}
    
22.         z.password = passphrase
    
23.         z.init()
    
24.         return z
    
25. }
    
26. 
    
27. func (z *ZipCrypto) init() {
    
28.         z.Keys[0] = 0x12345678
    
29.         z.Keys[1] = 0x23456789
    
30.         z.Keys[2] = 0x34567890
    
31. 
    
32.         for i := 0; i < len(z.password); i++ {
    
33.                 z.updateKeys(z.password[i])
    
34.         }
    
35. }
    
36. 
    
37. func (z *ZipCrypto) updateKeys(byteValue byte) {
    
38.         z.Keys[0] = crc32update(z.Keys[0], byteValue)
    
39.         z.Keys[1] += z.Keys[0] & 0xff
    
40.         z.Keys[1] = z.Keys[1]*134775813 + 1
    
41.         z.Keys[2] = crc32update(z.Keys[2], (byte)(z.Keys[1]>>24))
    
42. }
    
43. 
    
44. func (z *ZipCrypto) magicByte() byte {
    
45.         var t uint32 = z.Keys[2] | 2
    
46.         return byte((t * (t ^ 1)) >> 8)
    
47. }
    
48. 
    
49. func (z *ZipCrypto) Encrypt(data []byte) []byte {
    
50.         length := len(data)
    
51.         chiper := make([]byte, length)
    
52.         for i := 0; i < length; i++ {
    
53.                 v := data[i]
    
54.                 chiper[i] = v ^ z.magicByte()
    
55.                 z.updateKeys(v)
    
56.         }
    
57.         return chiper
    
58. }
    
59. 
    
60. func (z *ZipCrypto) Decrypt(chiper []byte) []byte {
    
61.         length := len(chiper)
    
62.         plain := make([]byte, length)
    
63.         for i, c := range chiper {
    
64.                 v := c ^ z.magicByte()
    
65.                 z.updateKeys(v)
    
66.                 plain[i] = v
    
67.         }
    
68.         return plain
    
69. }
    
70. 
    
71. func crc32update(pCrc32 uint32, bval byte) uint32 {
    
72.         return crc32.IEEETable[(pCrc32^uint32(bval))&0xff] ^ (pCrc32 >> 8)
    
73. }
    
74. 
    
75. func ZipCryptoDecryptor(r *io.SectionReader, password []byte) (*io.SectionReader, error) {
    
76.         z := NewZipCrypto(password)
    
77.         b := make([]byte, r.Size())
    
78. 
    
79.         r.Read(b)
    
80. 
    
81.         m := z.Decrypt(b)
    
82.         return io.NewSectionReader(bytes.NewReader(m), 12, int64(len(m))), nil
    
83. }
    
84. 
    
85. type unzip struct {
    
86.         offset int64
    
87.         fp     *os.File
    
88.         name   string
    
89. }
    
90. 
    
91. func (uz *unzip) init() (err error) {
    
92.         uz.fp, err = os.Open(uz.name)
    
93.         return err
    
94. }
    
95. 
    
96. func (uz *unzip) close() {
    
97.         if uz.fp != nil {
    
98.                 uz.fp.Close()
    
99.         }
    
100. }
     
101. 
     
102. func (uz *unzip) Size() int64 {
     
103.         if uz.fp == nil {
     
104.                 if err := uz.init(); err != nil {
     
105.                         return -1
     
106.                 }
     
107.         }
     
108. 
     
109.         fi, err := uz.fp.Stat()
     
110.         if err != nil {
     
111.                 return -1
     
112.         }
     
113. 
     
114.         return fi.Size() - uz.offset
     
115. }
     
116. 
     
117. func (uz *unzip) ReadAt(p []byte, off int64) (int, error) {
     
118.         if uz.fp == nil {
     
119.                 if err := uz.init(); err != nil {
     
120.                         return 0, err
     
121.                 }
     
122.         }
     
123. 
     
124.         return uz.fp.ReadAt(p, off+uz.offset)
     
125. }
     
126. 
     
127. 
     
128. // DeCompressZip 解压zip包
     
129. func DeCompressZip(zipFile, dest, passwd string, offset int64) error {
     
130.         uz := &unzip{offset: offset, name: zipFile}
     
131.         defer uz.close()
     
132. 
     
133.         zr, err := zip.NewReader(uz, uz.Size())
     
134.         if err != nil {
     
135.                 return err
     
136.         }
     
137. 
     
138.         if passwd != "" {
     
139.                 // Register a custom Deflate compressor.
     
140.                 zr.RegisterDecompressor(zip.Deflate, func(r io.Reader) io.ReadCloser {
     
141.                         rs := r.(*io.SectionReader)
     
142.                         r, _ = ZipCryptoDecryptor(rs, []byte(passwd))
     
143.                         return flate.NewReader(r)
     
144.                 })
     
145. 
     
146.                 zr.RegisterDecompressor(zip.Store, func(r io.Reader) io.ReadCloser {
     
147.                         rs := r.(*io.SectionReader)
     
148.                         r, _ = ZipCryptoDecryptor(rs, []byte(passwd))
     
149.                         return ioutil.NopCloser(r)
     
150.                 })
     
151.         }
     
152. 
     
153.         for _, f := range zr.File {
     
154.                 fpath := filepath.Join(dest, f.Name)
     
155.                 if f.FileInfo().IsDir() {
     
156.                         os.MkdirAll(fpath, os.ModePerm)
     
157.                         continue
     
158.                 }
     
159. 
     
160.                 if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
     
161.                         return err
     
162.                 }
     
163. 
     
164.                 inFile, err := f.Open()
     
165.                 if err != nil {
     
166.                         return err
     
167.                 }
     
168. 
     
169.                 outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
     
170.                 if err != nil {
     
171.                         inFile.Close()
     
172.                         return err
     
173.                 }
     
174. 
     
175.                 _, err = io.Copy(outFile, inFile)
     
176.                 inFile.Close()
     
177.                 outFile.Close()
     
178.                 if err != nil {
     
179.                         return err
     
180.                 }
     
181.         }
     
182. 
     
183.         return nil
     
184. }
     
185. 
     
186. func main() {
     
187.         err := DeCompressZip("Go.zip", "./tmp", "123456", 0)
     
188.         if err != nil {
     
189.                 fmt.Println(err)
     
190.         }
     
191.         return
     
192. }

复制代码

以上就是golang解压带密码的zip包的方法详解的详细内容，更多关于golang解压zip包的资料请关注晓枫资讯其它相关文章！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

高流寒

路过，支持一下