wip

1 files changed, 103 insertions, 21 deletions

diff --git a/main.go b/main.go
index cab47d5..88ff7c1 100644
--- a/main.go
+++ b/main.go
@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
+	"fmt"
+	"hash/crc32"
 	"io"
 	"log"
 	"os"
@@ -37,18 +39,29 @@ func main() {
 			var hdr File
 			if err := parseFileHeader(&hdr, f); err != nil {
 				pos, _ := f.Seek(0, io.SeekCurrent)
-				log.Fatalf("failed to read file header at %d: %s", pos, err)
+				log.Fatalf("failed to read file header at 0x%x: %s", pos, err)
 			}
+			hdr.HeaderOffset, _ = f.Seek(0, io.SeekCurrent)
 			j, _ := json.MarshalIndent(hdr, "", "  ")
-			log.Printf("File: %s", string(j))
-			if pos, err := f.Seek(int64(hdr.CompressedSize), io.SeekCurrent); err != nil {
-				log.Fatalf("failed to seek to next header, stopped at %d: %s", pos, err)
+			log.Printf("File at 0x%x: %s", hdr.HeaderOffset, string(j))
+			if hdr.Flags&0x08 > 0 {
+				log.Printf("Searching for file's end...")
+				if err = findAndUseDataDescriptor(&hdr, f); err != nil {
+					log.Fatalf("failed to udpate using data descriptor at 0x%x: %s", hdr.HeaderOffset, err)
+				}
+			}
+			if pos, err := f.Seek(hdr.HeaderOffset+int64(hdr.CompressedSize), io.SeekStart); err != nil {
+				log.Fatalf("failed to seek to next header, stopped at 0x%x: %s", pos, err)
 			}
+
+		case dataDescriptorSignature:
+			io.CopyN(io.Discard, f, 12)
+
 		case directoryHeaderSignature:
 			var hdr File
 			if err = readDirectoryHeader(&hdr, f); err != nil {
 				pos, _ := f.Seek(0, io.SeekCurrent)
-				log.Fatalf("failed to read directory header at %d: %s", pos, err)
+				log.Fatalf("failed to read directory header at 0x%x: %s", pos, err)
 			}
 			j, _ := json.MarshalIndent(hdr, "", "  ")
 			log.Printf("Directory: %s", string(j))
@@ -56,13 +69,13 @@ func main() {
 			var hdr directoryEnd
 			if err := parseDirectoryEnd(&hdr, f); err != nil {
 				pos, _ := f.Seek(0, io.SeekCurrent)
-				log.Fatalf("failed to read directory end at %d: %s", pos, err)
+				log.Fatalf("failed to read directory end at 0x%x: %s", pos, err)
 			}
 			j, _ := json.MarshalIndent(hdr, "", "  ")
 			log.Printf("Directory End: %s", string(j))
 		default:
 			pos, _ := f.Seek(0, io.SeekCurrent)
-			log.Fatalf("invalid header signature at %d: got %08x", pos, signature)
+			log.Fatalf("invalid header signature at 0x%x: got %08x", pos, signature)
 		}
 	}
 }
@@ -96,7 +109,7 @@ func parseFileHeader(f *File, r io.Reader) error {
 
 	needUSize := f.UncompressedSize == ^uint32(0)
 	needCSize := f.CompressedSize == ^uint32(0)
-	needHeaderOffset := f.headerOffset == int64(^uint32(0))
+	needHeaderOffset := f.HeaderOffset == int64(^uint32(0))
 
 	// Best effort to find what we need.
 	// Other zip authors might not even follow the basic format,
@@ -138,7 +151,7 @@ parseExtras:
 				if len(fieldBuf) < 8 {
 					return ErrFormat
 				}
-				f.headerOffset = int64(fieldBuf.uint64())
+				f.HeaderOffset = int64(fieldBuf.uint64())
 			}
 		case ntfsExtraID:
 			if len(fieldBuf) < 4 {
@@ -200,7 +213,8 @@ parseExtras:
 	return nil
 }
 
-func parseDirectoryEnd(d *directoryEnd, r io.Reader) error {
+func parseDirectoryEnd(d *directoryEnd, r io.ReadSeeker) error {
+	d.HeaderOffset, _ = r.Seek(0, io.SeekCurrent)
 	var hdr [directoryEndLen]byte
 	if _, err := io.ReadFull(r, hdr[:]); err != nil {
 		return err
@@ -226,15 +240,17 @@ func parseDirectoryEnd(d *directoryEnd, r io.Reader) error {
 	return nil
 }
 
-const searchChunkSize = 4096
+const searchSize = 4096
+
+func search(r io.Reader, term []byte, offset int64) (int64, error) {
+	termLen := len(term)
+	buf := make([]byte, searchSize+termLen)
 
-func find(r io.Reader, search []byte) (int64, error) {
-	var offset int64
-	tailLen := len(search) - 1
-	chunk := make([]byte, searchChunkSize+tailLen)
-	n, err := r.Read(chunk[tailLen:])
-	idx := bytes.Index(chunk[tailLen:n+tailLen], search)
+	var err error
+	var n, idx int
 	for {
+		n, err = r.Read(buf[termLen:])
+		idx = bytes.Index(buf[:n+termLen], term)
 		if idx >= 0 {
 			return offset + int64(idx), nil
 		}
@@ -243,9 +259,75 @@ func find(r io.Reader, search []byte) (int64, error) {
 		} else if err != nil {
 			return -1, err
 		}
-		copy(chunk, chunk[searchChunkSize:])
-		offset += searchChunkSize
-		n, err = r.Read(chunk[tailLen:])
-		idx = bytes.Index(chunk[:n+tailLen], search)
+		copy(buf, buf[searchSize:])
+		offset += searchSize
+	}
+}
+
+func parseDataDescriptor(f *File, r io.Reader) error {
+	var buf [dataDescriptorLen]byte
+
+	if _, err := io.ReadFull(r, buf[:]); err != nil {
+		return err
+	}
+	b := readBuf(buf[:])
+	f.DescriptorCRC32 = b.uint32()
+	f.DescriptorCompressedSize = b.uint32()
+	f.DescriptorUncompressedSize = b.uint32()
+
+	log.Printf("compsize=%d, size=%d", f.DescriptorCompressedSize, f.DescriptorUncompressedSize)
+
+	return nil
+}
+
+var dataDescriptorSignatureBytes = []byte{'P', 'K', 0x07, 0x08}
+
+func findAndUseDataDescriptor(f *File, r io.ReadSeeker) error {
+	pos, err := r.Seek(0, io.SeekCurrent)
+	if err != nil {
+		return err
+	}
+	for {
+		descriptorPos, err := search(r, dataDescriptorSignatureBytes, pos)
+		if err != nil {
+			return fmt.Errorf("failed to find descriptor maxed at 0x%x: %s", descriptorPos, err)
+		}
+		log.Printf("found descriptor at offset 0x%x", descriptorPos)
+		if pos, err = r.Seek(descriptorPos, io.SeekStart); err != nil {
+			return fmt.Errorf("failed to seek to descriptor at 0x%x: %s", pos, err)
+		}
+		if err := parseDataDescriptor(f, r); err != nil {
+			return fmt.Errorf("failed to read descriptor : %s", err)
+		}
+		if descriptorPos-int64(f.DescriptorCompressedSize) == f.HeaderOffset+4 {
+			break
+		} else {
+			log.Printf("invalid size: expected offset %x (hex) != %x (hex), compsize=%d, size=%d",
+				f.HeaderOffset+4, descriptorPos-int64(f.DescriptorCompressedSize), f.DescriptorCompressedSize, f.DescriptorUncompressedSize)
+		}
+		if pos, err = r.Seek(descriptorPos+4, io.SeekStart); err != nil {
+			return fmt.Errorf("failed to seek to descriptor at 0x%x: %s", pos, err)
+		} else {
+			// log.Printf("resetted to offset %d", pos)
+		}
+	}
+
+	// bring back at the beginning of the header (due to chunking)
+	if _, err := r.Seek(f.HeaderOffset, io.SeekStart); err != nil {
+		return fmt.Errorf("failed to seek to beginning at %d: %s", f.HeaderOffset, err)
+	}
+	crc := crc32.NewIEEE()
+	if _, err := io.CopyN(crc, r, int64(f.DescriptorCompressedSize)); err != nil {
+		return fmt.Errorf("failed to calculate CRC32: %s", err)
 	}
+	crcSum := crc.Sum32()
+	if f.DescriptorCRC32 != crcSum {
+		return fmt.Errorf("invalid CRC32: calculated %08x, have in decriptor %08x", crcSum, f.DescriptorCRC32)
+	}
+
+	f.CRC32 = crcSum
+	f.UncompressedSize = f.DescriptorUncompressedSize
+	f.CompressedSize = f.DescriptorCompressedSize
+
+	return nil
 }