[本地文件頭1] [文件數(shù)據(jù)1] [本地文件頭2] [文件數(shù)據(jù)2] ... [中央目錄] [中央目錄結(jié)束記錄]

local file header signature     4 bytes  (0x04034b50)
version needed to extract       2 bytes
general purpose bit flag        2 bytes
compression method              2 bytes
last mod file time              2 bytes
last mod file date              2 bytes
crc-32                          4 bytes
compressed size                 4 bytes
uncompressed size               4 bytes
file name length                2 bytes
extra field length              2 bytes

file name (variable size)
extra field (variable size)

當(dāng)前最低功能版本定義如下：（壓縮包記錄的解壓版本都是需要版本*10，比如：2.0 * 10 = 20）
1.0 – 默認(rèn)值
1.1 – 文件是卷標(biāo)
2.0 – 文件是一個(gè)文件夾（目錄）
2.0 – 使用 Deflate 壓縮來壓縮文件
2.0 – 使用傳統(tǒng)的 PKWARE 加密對文件進(jìn)行加密
2.1 – 使用 Deflate64? 壓縮文件
2.5 – 使用 PKWARE DCL Implode 壓縮文件
2.7 – 文件是補(bǔ)丁數(shù)據(jù)集
4.5 – 文件使用 ZIP64 格式擴(kuò)展
4.6 – 使用 BZIP2 壓縮文件壓縮
5.0 – 文件使用 DES 加密
5.0 – 文件使用 3DES 加密
5.0 – 使用原始 RC2 加密對文件進(jìn)行加密
5.0 – 使用 RC4 加密對文件進(jìn)行加密
5.1 – 文件使用 AES 加密進(jìn)行加密
5.1 – 使用更正的 RC2 加密對文件進(jìn)行加密
5.2 – 使用更正的 RC2-64 加密對文件進(jìn)行加密
6.1 – 使用非 OAEP 密鑰包裝對文件進(jìn)行加密
6.2 – 中央目錄加密

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

[file header 1]
.
.
. 
[file header n]
[digital signature]

central file header signature   4 bytes  (0x02014b50)
version made by                 2 bytes
version needed to extract       2 bytes
general purpose bit flag        2 bytes
compression method              2 bytes
last mod file time              2 bytes
last mod file date              2 bytes
crc-32                          4 bytes
compressed size                 4 bytes
uncompressed size               4 bytes
file name length                2 bytes
extra field length              2 bytes
file comment length             2 bytes
disk number start               2 bytes
internal file attributes        2 bytes
external file attributes        4 bytes
relative offset of local header 4 bytes

file name (variable size)
extra field (variable size)
file comment (variable size)

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

end of central dir signature    4 bytes  (0x06054b50)
number of this disk             2 bytes
number of the disk with the
start of the central directory  2 bytes
total number of entries in the
central directory on this disk  2 bytes
total number of entries in
the central directory           2 bytes
size of the central directory   4 bytes
offset of start of central
directory with respect to
the starting disk number        4 bytes
.ZIP file comment length        2 bytes
.ZIP file comment       (variable size)

func Unzip(src, dst string) error {
	// zip.NewReader() 適合從stream中讀取字節(jié)序列
	zf, err := zip.OpenReader(src)
	if err != nil {
		return err
	}
	defer zf.Close()

	for _, file := range zf.File {
		// fmt.Println(file.Name)
		path := filepath.Join(dst, file.Name)
		// 如果是目錄則創(chuàng)建目錄
		if file.FileInfo().IsDir() {
			if err = os.MkdirAll(path, 0o644); err != nil {
				return err
			}
			continue
		}
		f, err := os.Create(path)
		if err != nil {
			return err
		}
		reader, err := file.Open()
		if err != nil {
			return err
		}
		_, err = io.Copy(f, reader)
		if err != nil {
			return err
		}
		_ = f.Close()
		_ = reader.Close()
	}
	return nil
}

func main() {
	log.Println(Unzip("Go.zip", "./static"))
}

rwxr-xr-x

package main

import (
	"archive/zip"
	"bytes"
	"compress/flate"
	"io"
)

func main() {
	// Override the default Deflate compressor with a higher compression level.

	// Create a buffer to write our archive to.
	buf := new(bytes.Buffer)

	// Create a new zip archive.
	w := zip.NewWriter(buf)

	// Register a custom Deflate compressor.
	w.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {
		return flate.NewWriter(out, flate.BestCompression)
	})

	// Proceed to add files to w.
}

func main() {
	zf, _ := zip.OpenReader("")
	zf.RegisterDecompressor(zip.Deflate, func(r io.Reader) io.ReadCloser {
		
		// TODO:解密算法實(shí)現(xiàn)

		return flate.NewReader(r)
	})
}

type ZipCrypto struct {
    password []byte
    Keys     [3]uint32
}
 
func NewZipCrypto(passphrase []byte) *ZipCrypto {
    z := &ZipCrypto{}
    z.password = passphrase
    z.init()
    return z
}
 
func (z *ZipCrypto) init() {
    z.Keys[0] = 0x12345678
    z.Keys[1] = 0x23456789
    z.Keys[2] = 0x34567890
 
    for i := 0; i < len(z.password); i++ {
        z.updateKeys(z.password[i])
    }
}
 
func (z *ZipCrypto) updateKeys(byteValue byte) {
    z.Keys[0] = crc32update(z.Keys[0], byteValue)
    z.Keys[1] += z.Keys[0] & 0xff
    z.Keys[1] = z.Keys[1]*134775813 + 1
    z.Keys[2] = crc32update(z.Keys[2], (byte)(z.Keys[1]>>24))
}
 
func (z *ZipCrypto) magicByte() byte {
    var t uint32 = z.Keys[2] | 2
    return byte((t * (t ^ 1)) >> 8)
}
 
func (z *ZipCrypto) Encrypt(data []byte) []byte {
    length := len(data)
    chiper := make([]byte, length)
    for i := 0; i < length; i++ {
        v := data[i]
        chiper[i] = v ^ z.magicByte()
        z.updateKeys(v)
    }
    return chiper
}
 
func (z *ZipCrypto) Decrypt(chiper []byte) []byte {
    length := len(chiper)
    plain := make([]byte, length)
    for i, c := range chiper {
        v := c ^ z.magicByte()
        z.updateKeys(v)
        plain[i] = v
    }
    return plain
}
 
func crc32update(pCrc32 uint32, bval byte) uint32 {
    return crc32.IEEETable[(pCrc32^uint32(bval))&0xff] ^ (pCrc32 >> 8)
}

func main() {
	password := "generalzy"
	zc := NewZipCrypto(password)

	// 示例數(shù)據(jù)
	data := []byte("Hello, ZipCrypto!")
	fmt.Printf("Original: %s\n", data)

	// 加密數(shù)據(jù)
	encrypted := zc.Encrypt(data)
	fmt.Printf("Encrypted: %x\n", encrypted)

	// 初始化解密器
	zcDecrypt := NewZipCrypto(password)

	// 解密數(shù)據(jù)
	decrypted := zcDecrypt.Decrypt(encrypted)
	fmt.Printf("Decrypted: %s\n", decrypted)
}

package main

import (
	"archive/zip"
	"bytes"
	"compress/flate"
	"fmt"
	"hash/crc32"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
)

type ZipCrypto struct {
	password []byte
	Keys     [3]uint32
}

func NewZipCrypto(passphrase []byte) *ZipCrypto {
	z := &ZipCrypto{}
	z.password = passphrase
	z.init()
	return z
}

func (z *ZipCrypto) init() {
	z.Keys[0] = 0x12345678
	z.Keys[1] = 0x23456789
	z.Keys[2] = 0x34567890

	for i := 0; i < len(z.password); i++ {
		z.updateKeys(z.password[i])
	}
}

func (z *ZipCrypto) updateKeys(byteValue byte) {
	z.Keys[0] = crc32update(z.Keys[0], byteValue)
	z.Keys[1] += z.Keys[0] & 0xff
	z.Keys[1] = z.Keys[1]*134775813 + 1
	z.Keys[2] = crc32update(z.Keys[2], (byte)(z.Keys[1]>>24))
}

func (z *ZipCrypto) magicByte() byte {
	var t uint32 = z.Keys[2] | 2
	return byte((t * (t ^ 1)) >> 8)
}

func (z *ZipCrypto) Encrypt(data []byte) []byte {
	length := len(data)
	chiper := make([]byte, length)
	for i := 0; i < length; i++ {
		v := data[i]
		chiper[i] = v ^ z.magicByte()
		z.updateKeys(v)
	}
	return chiper
}

func (z *ZipCrypto) Decrypt(chiper []byte) []byte {
	length := len(chiper)
	plain := make([]byte, length)
	for i, c := range chiper {
		v := c ^ z.magicByte()
		z.updateKeys(v)
		plain[i] = v
	}
	return plain
}

func crc32update(pCrc32 uint32, bval byte) uint32 {
	return crc32.IEEETable[(pCrc32^uint32(bval))&0xff] ^ (pCrc32 >> 8)
}

func ZipCryptoDecryptor(r *io.SectionReader, password []byte) (*io.SectionReader, error) {
	z := NewZipCrypto(password)
	b := make([]byte, r.Size())

	r.Read(b)

	m := z.Decrypt(b)
	return io.NewSectionReader(bytes.NewReader(m), 12, int64(len(m))), nil
}

type unzip struct {
	offset int64
	fp     *os.File
	name   string
}

func (uz *unzip) init() (err error) {
	uz.fp, err = os.Open(uz.name)
	return err
}

func (uz *unzip) close() {
	if uz.fp != nil {
		uz.fp.Close()
	}
}

func (uz *unzip) Size() int64 {
	if uz.fp == nil {
		if err := uz.init(); err != nil {
			return -1
		}
	}

	fi, err := uz.fp.Stat()
	if err != nil {
		return -1
	}

	return fi.Size() - uz.offset
}

func (uz *unzip) ReadAt(p []byte, off int64) (int, error) {
	if uz.fp == nil {
		if err := uz.init(); err != nil {
			return 0, err
		}
	}

	return uz.fp.ReadAt(p, off+uz.offset)
}


// DeCompressZip 解壓zip包
func DeCompressZip(zipFile, dest, passwd string, offset int64) error {
	uz := &unzip{offset: offset, name: zipFile}
	defer uz.close()

	zr, err := zip.NewReader(uz, uz.Size())
	if err != nil {
		return err
	}

	if passwd != "" {
		// Register a custom Deflate compressor.
		zr.RegisterDecompressor(zip.Deflate, func(r io.Reader) io.ReadCloser {
			rs := r.(*io.SectionReader)
			r, _ = ZipCryptoDecryptor(rs, []byte(passwd))
			return flate.NewReader(r)
		})

		zr.RegisterDecompressor(zip.Store, func(r io.Reader) io.ReadCloser {
			rs := r.(*io.SectionReader)
			r, _ = ZipCryptoDecryptor(rs, []byte(passwd))
			return ioutil.NopCloser(r)
		})
	}

	for _, f := range zr.File {
		fpath := filepath.Join(dest, f.Name)
		if f.FileInfo().IsDir() {
			os.MkdirAll(fpath, os.ModePerm)
			continue
		}

		if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
			return err
		}

		inFile, err := f.Open()
		if err != nil {
			return err
		}

		outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
		if err != nil {
			inFile.Close()
			return err
		}

		_, err = io.Copy(outFile, inFile)
		inFile.Close()
		outFile.Close()
		if err != nil {
			return err
		}
	}

	return nil
}

func main() {
	err := DeCompressZip("Go.zip", "./tmp", "123456", 0)
	if err != nil {
		fmt.Println(err)
	}
	return
}