public

Author: zhuweiyou

.gitignore

@@ -0,0 +1,3 @@
+.idea
+wxapkg.iml
+wxapkg.exe

decrypt.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/sha1"
+	"fmt"
+	"golang.org/x/crypto/pbkdf2"
+	"log"
+	"os"
+)
+
+type DecryptOptions struct {
+	Wxid          string
+	Iv            string
+	Salt          string
+	WxapkgPath    string
+	DecWxapkgPath string
+}
+
+const DecryptTo = "_decrypt"
+
+func Decrypt(from string, wxid string) error {
+	return decrypt(&DecryptOptions{
+		Wxid:          wxid,
+		Iv:            "the iv: 16 bytes",
+		Salt:          "saltiest",
+		WxapkgPath:    from,
+		DecWxapkgPath: from + DecryptTo,
+	})
+}
+
+func decrypt(options *DecryptOptions) error {
+	dataByte, err := os.ReadFile(options.WxapkgPath)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	dk := pbkdf2.Key([]byte(options.Wxid), []byte(options.Salt), 1000, 32, sha1.New)
+	block, _ := aes.NewCipher(dk)
+	blockMode := cipher.NewCBCDecrypter(block, []byte(options.Iv))
+	originData := make([]byte, 1024)
+	blockMode.CryptBlocks(originData, dataByte[6:1024+6])
+
+	afData := make([]byte, len(dataByte)-1024-6)
+	var xorKey = byte(0x66)
+	if len(options.Wxid) >= 2 {
+		xorKey = options.Wxid[len(options.Wxid)-2]
+	}
+	for i, b := range dataByte[1024+6:] {
+		afData[i] = b ^ xorKey
+	}
+
+	originData = append(originData[:1023], afData...)
+
+	err = os.WriteFile(options.DecWxapkgPath, originData, 0666)
+	if err != nil {
+		return fmt.Errorf("write file error: %v", err)
+	}
+
+	return nil
+}

go.mod

@@ -0,0 +1,5 @@
+module wxapkg
+
+go 1.20
+
+require golang.org/x/crypto v0.11.0

go.sum

@@ -0,0 +1,2 @@
+golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA=
+golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=

main.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	from := strings.ReplaceAll(os.Args[1], "\\", "/")
+	fromParts := strings.Split(from, "/")
+	wxid := fromParts[len(fromParts)-3]
+	fmt.Println("wxid", wxid)
+
+	err := Decrypt(from, wxid)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	err = Unpack(from + DecryptTo)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	fmt.Println("success")
+}

unpack.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+type UnpackFile struct {
+	nameLen uint32
+	name    string
+	offset  uint32
+	size    uint32
+}
+
+func Unpack(from string) error {
+	f, err := os.Open(from)
+	if err != nil {
+		return fmt.Errorf("error opening file: %v", err)
+	}
+	defer f.Close()
+
+	root := filepath.Dir(from)
+	name := filepath.Base(from) + "_unpack"
+
+	var firstMark byte
+	if err := binary.Read(f, binary.BigEndian, &firstMark); err != nil {
+		return fmt.Errorf("error reading first header mark: %v", err)
+	}
+	fmt.Println("first header mark =", firstMark)
+
+	var info1 uint32
+	if err := binary.Read(f, binary.BigEndian, &info1); err != nil {
+		return fmt.Errorf("error reading info1: %v", err)
+	}
+	fmt.Println("info1 =", info1)
+
+	var indexInfoLength uint32
+	if err := binary.Read(f, binary.BigEndian, &indexInfoLength); err != nil {
+		return fmt.Errorf("error reading indexInfoLength: %v", err)
+	}
+	fmt.Println("indexInfoLength =", indexInfoLength)
+
+	var bodyInfoLength uint32
+	if err := binary.Read(f, binary.BigEndian, &bodyInfoLength); err != nil {
+		return fmt.Errorf("error reading bodyInfoLength: %v", err)
+	}
+	fmt.Println("bodyInfoLength =", bodyInfoLength)
+
+	var lastMark byte
+	if err := binary.Read(f, binary.BigEndian, &lastMark); err != nil {
+		return fmt.Errorf("error reading last header mark: %v", err)
+	}
+	fmt.Println("last header mark =", lastMark)
+
+	if firstMark != 0xBE || lastMark != 0xED {
+		return fmt.Errorf("it's not a wxapkg file")
+	}
+
+	var fileCount uint32
+	if err := binary.Read(f, binary.BigEndian, &fileCount); err != nil {
+		return fmt.Errorf("error reading fileCount: %v", err)
+	}
+	fmt.Println("fileCount =", fileCount)
+
+	fileList := make([]UnpackFile, 0, fileCount)
+
+	for i := uint32(0); i < fileCount; i++ {
+		var data UnpackFile
+		if err := binary.Read(f, binary.BigEndian, &data.nameLen); err != nil {
+			return fmt.Errorf("error reading nameLen: %v", err)
+		}
+
+		nameBytes := make([]byte, data.nameLen)
+		if _, err := f.Read(nameBytes); err != nil {
+			return fmt.Errorf("error reading name: %v", err)
+		}
+		data.name = string(nameBytes)
+
+		if err := binary.Read(f, binary.BigEndian, &data.offset); err != nil {
+			return fmt.Errorf("error reading offset: %v", err)
+		}
+
+		if err := binary.Read(f, binary.BigEndian, &data.size); err != nil {
+			return fmt.Errorf("error reading size: %v", err)
+		}
+
+		fmt.Println("readFile =", data.name, "at Offset =", data.offset)
+
+		fileList = append(fileList, data)
+	}
+
+	for _, d := range fileList {
+		d.name = "/" + name + d.name
+		path := filepath.Join(root, filepath.Dir(d.name))
+
+		if err := os.MkdirAll(path, os.ModePerm); err != nil {
+			return fmt.Errorf("error creating directory: %v", err)
+		}
+
+		w, err := os.Create(filepath.Join(root, d.name))
+		if err != nil {
+			return fmt.Errorf("error creating file: %v", err)
+		}
+
+		_, err = f.Seek(int64(d.offset), 0)
+		if err != nil {
+			w.Close()
+			return fmt.Errorf("error seeking to offset: %v", err)
+		}
+
+		buf := make([]byte, d.size)
+		_, err = f.Read(buf)
+		if err != nil {
+			w.Close()
+			return fmt.Errorf("Error reading from file: %v", err)
+		}
+
+		_, err = w.Write(buf)
+		if err != nil {
+			return fmt.Errorf("error writing to file: %v", err)
+		}
+
+		w.Close()
+		fmt.Println("writeFile =", filepath.Join(root, d.name))
+	}
+
+	return nil
+}